753 lines
28 KiB
C++
753 lines
28 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 "SyncDataBase"
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <sys/stat.h>
|
|
#include <errno.h>
|
|
|
|
#include "SyncDataBase.h"
|
|
#include "CPQLog.h"
|
|
|
|
#include "SSMAction.h"
|
|
#include "CPQDataBase.h"
|
|
#include "WhitebalanceDataBase.h"
|
|
|
|
#include "PQTableTypeOSD.h"
|
|
|
|
#include "CConfigFile.h"
|
|
|
|
SyncDataBase *SyncDataBase::mInstance = NULL;
|
|
SyncDataBase *SyncDataBase::GetInstance()
|
|
{
|
|
if (NULL == mInstance) {
|
|
mInstance = new SyncDataBase();
|
|
}
|
|
|
|
return mInstance;
|
|
}
|
|
|
|
static char DatabaseVersion[64] = "\0";
|
|
|
|
SyncDataBase::SyncDataBase()
|
|
{
|
|
const char *config_value;
|
|
config_value = CConfigFile::GetInstance()->GetString(CFG_SECTION_PQ, CGF_PQ_DATABASE_VERSION, "3.1");
|
|
snprintf(DatabaseVersion, sizeof(DatabaseVersion), "%s", config_value);
|
|
|
|
LOGD("%s DatabaseVersion %s !\n",__FUNCTION__, DatabaseVersion);
|
|
|
|
}
|
|
|
|
SyncDataBase::~SyncDataBase()
|
|
{
|
|
}
|
|
|
|
//============================ SSM DATA =================================================//
|
|
bool SyncDataBase::SyncDataBaseInit(void)
|
|
{
|
|
if (strlen(DatabaseVersion) <= 0) {
|
|
LOGD("%s DatabaseVersion is null !\n",__FUNCTION__);
|
|
return false;
|
|
}
|
|
|
|
char INFO[64];
|
|
if (CPQDataBase::GetInstance()->GetSyncData((void *)INFO, sizeof(INFO))) {
|
|
if (strcmp(DatabaseVersion, INFO) == 0 ) {
|
|
LOGD("%s DatabaseVersion %s sync has done!\n",__FUNCTION__, DatabaseVersion);
|
|
return true;
|
|
} else {
|
|
LOGD("%s sync version is not match %s != %s, need sync afresh!\n",__FUNCTION__, DatabaseVersion, INFO);
|
|
}
|
|
}
|
|
|
|
LOGD("%s Start sync %s to Current version!\n",__FUNCTION__, DatabaseVersion);
|
|
|
|
if (strcmp(DatabaseVersion, "3.1") == 0) {
|
|
SyncDataBasePictureMode();
|
|
SyncDataBasePictureModeData_3_1();
|
|
SyncDataBaseColorTempData();
|
|
SyncDataBaseWbGammaData();
|
|
SyncDataBaseCmsData_3_1();
|
|
SyncDataBaseBySourcePicture();
|
|
SyncDataBaseGlobalPicture();
|
|
SyncDataBaseLcdLvdsSsc();
|
|
} else {
|
|
SyncDataBasePictureMode();
|
|
SyncDataBasePictureModeData();
|
|
SyncDataBaseColorTempData();
|
|
SyncDataBaseWbGammaData();
|
|
SyncDataBaseCmsData();
|
|
SyncDataBaseBySourcePicture();
|
|
SyncDataBaseGlobalPicture();
|
|
SyncDataBaseLcdLvdsSsc();
|
|
}
|
|
|
|
snprintf(INFO, sizeof(INFO), "%s", DatabaseVersion);
|
|
if (!CPQDataBase::GetInstance()->SetSyncData((void *)INFO, sizeof(INFO))) {
|
|
LOGE("%s SetSyncData fail info is %s: !\n",__FUNCTION__, INFO);
|
|
return false;
|
|
}
|
|
|
|
LOGD("%s Done !\n",__FUNCTION__);
|
|
|
|
return true;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBasePictureMode(void)
|
|
{
|
|
LOGD("Sync PictureMode Start\n");
|
|
|
|
int Flag = 0;
|
|
int mode = 0;
|
|
SSM_PictureModeInfo param;
|
|
memset(¶m, 0, sizeof(SSM_PictureModeInfo));
|
|
PICTURE_MODE_DEFAULT pqmode;
|
|
for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
|
|
for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
|
|
if (!CheckIndexSupport(source, timming)) {
|
|
continue;
|
|
}
|
|
|
|
int offset = (source * MAX_SSM_PQ_TIMMING_INDEX + timming) * sizeof(SSM_PictureModeInfo);
|
|
if (!SSMAction::getInstance()->GetSsmDataParam((void *)¶m,
|
|
SSM_PQ_MODE_ID,
|
|
sizeof(SSM_PictureModeInfo),
|
|
offset,
|
|
false)) {
|
|
continue;
|
|
}
|
|
|
|
int offsetFlag = offset + sizeof(int);
|
|
if (param.Flag == 1 || param.Flag == offsetFlag)
|
|
mode = param.PictureMode;
|
|
else
|
|
continue;
|
|
|
|
if (!CPQDataBase::GetInstance()->GetPictureMode(&pqmode, source, timming)) {
|
|
if (!CPQDataBase::GetInstance()->GetPictureMode(&pqmode, 0, timming)) {
|
|
if (!CPQDataBase::GetInstance()->GetPictureMode(&pqmode, 0, 0)) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (timming == PQ_FMT_SDR) {
|
|
pqmode.Picture = mode;
|
|
} else if (timming == PQ_FMT_HDR) {
|
|
pqmode.Picture_HDR = mode;
|
|
} else if (timming == PQ_FMT_HDRP) {
|
|
pqmode.Picture_HLG = mode;
|
|
} else if (timming == PQ_FMT_DOLVI) {
|
|
pqmode.Picture_DOLVI = mode;
|
|
} else {
|
|
pqmode.Picture = mode;
|
|
}
|
|
|
|
if (!CPQDataBase::GetInstance()->SetPictureMode(&pqmode, source, timming)) {
|
|
LOGE("Sync pqmode source: %d, timming: %d!\n", source, timming);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGD("Sync PictureMode %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBasePictureModeData(void)
|
|
{
|
|
LOGI("Sync PictureMode Data Start\n");
|
|
|
|
int Flag = 0;
|
|
SSM_PICTURE_STRUCT PictureModeBase;
|
|
for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
|
|
for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
|
|
for (int mode = 0; mode < MAX_SSM_PICTUREMODE_INDEX; mode++) {
|
|
if (!CheckIndexSupport(source, timming))
|
|
continue;
|
|
|
|
int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_PICTUREMODE_INDEX +
|
|
timming * MAX_SSM_PICTUREMODE_INDEX + mode) *
|
|
MAX_SSM_PICTUREMODE_PARAM_SIZE;
|
|
if (!SSMAction::getInstance()->GetSsmDataParam((void *)&PictureModeBase,
|
|
SSM_PICTURE_ID,
|
|
sizeof(SSM_PICTURE_STRUCT),
|
|
offset,
|
|
true)) {
|
|
continue;
|
|
}
|
|
|
|
if (!CPQDataBase::GetInstance()->SetPictureModeData((PICTURE_MODE_PARAM *)&PictureModeBase, source, timming, mode)) {
|
|
LOGE("Sync PictureMode Data source: %d, timming: %d, mode: %d fail!\n", source, timming, mode);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("Sync PictureMode Data %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBasePictureModeData_3_1(void)
|
|
{
|
|
LOGI("Sync PictureMode Data Start\n");
|
|
|
|
int Flag = 0;
|
|
SSM_3_1_PICTURE_STRUCT PictureModeBase;
|
|
PICTURE_MODE_PARAM PictureModeTarget;
|
|
for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
|
|
for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
|
|
for (int mode = 0; mode < MAX_SSM_PICTUREMODE_INDEX; mode++) {
|
|
if (!CheckIndexSupport(source, timming))
|
|
continue;
|
|
|
|
int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_PICTUREMODE_INDEX +
|
|
timming * MAX_SSM_PICTUREMODE_INDEX + mode) *
|
|
MAX_SSM_PICTUREMODE_PARAM_SIZE;
|
|
if (!SSMAction::getInstance()->GetSsmDataParam((void *)&PictureModeBase,
|
|
SSM_PICTURE_ID,
|
|
sizeof(SSM_3_1_PICTURE_STRUCT),
|
|
offset,
|
|
true)) {
|
|
continue;
|
|
}
|
|
|
|
if (!CPQDataBase::GetInstance()->GetPictureModeData(&PictureModeTarget, source, timming, mode)) {
|
|
if (!CPQDataBase::GetInstance()->GetPictureModeData(&PictureModeTarget, 0, timming, mode)) {
|
|
if (!CPQDataBase::GetInstance()->GetPictureModeData(&PictureModeTarget, 0, 0, mode)) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
PictureModeTarget.Brightness = PictureModeBase.Brightness;
|
|
PictureModeTarget.Contrast = PictureModeBase.Contrast;
|
|
PictureModeTarget.Saturation = PictureModeBase.Saturation;
|
|
PictureModeTarget.Hue = PictureModeBase.Hue;
|
|
PictureModeTarget.Sharpness = PictureModeBase.Sharpness;
|
|
PictureModeTarget.Backlight = PictureModeBase.Backlight;
|
|
PictureModeTarget.Nr = PictureModeBase.Nr;
|
|
PictureModeTarget.DynamicContrast = PictureModeBase.DynamicContrast;
|
|
PictureModeTarget.ColorGamut = PictureModeBase.ColorGamut;
|
|
PictureModeTarget.ColorTemperature = PictureModeBase.ColorTemperature;
|
|
PictureModeTarget.LocalContrast = PictureModeBase.LocalContrast;
|
|
PictureModeTarget.BlackStretch = PictureModeBase.BlackStretch;
|
|
PictureModeTarget.WhiteStretch = 0;
|
|
PictureModeTarget.BlueStretch = PictureModeBase.BlueStretch;
|
|
PictureModeTarget.MpegNr = PictureModeBase.MpegNr;
|
|
PictureModeTarget.ChromaCoring = PictureModeBase.ChromaCoring;
|
|
PictureModeTarget.SuperResolution = PictureModeBase.SuperResolution;
|
|
PictureModeTarget.GammaMidLuminance = PictureModeBase.GammaMidLuminance;
|
|
PictureModeTarget.CmLevel = PictureModeBase.CmLevel;
|
|
PictureModeTarget.DynamicBacklight = PictureModeBase.DynamicBacklight;
|
|
PictureModeTarget.EyeProtection = PictureModeBase.EyeProtection;
|
|
PictureModeTarget.SmoothPlus = PictureModeBase.SmoothPlus;
|
|
PictureModeTarget.HdrTmo = PictureModeBase.HdrTmo;
|
|
//PictureModeTarget.AmlDolbyMode = PictureModeBase.AmlDolbyMode;
|
|
//PictureModeTarget.AmlDolbyDarkDetail = PictureModeBase.AmlDolbyDarkDetail;
|
|
PictureModeTarget.Deblock = PictureModeBase.MpegNr;
|
|
PictureModeTarget.Demosquito = PictureModeBase.MpegNr;
|
|
PictureModeTarget.Reserve1 = 0;
|
|
PictureModeTarget.Reserve2 = 0;
|
|
PictureModeTarget.Reserve3 = 0;
|
|
|
|
if (!CPQDataBase::GetInstance()->SetPictureModeData((PICTURE_MODE_PARAM *)&PictureModeTarget, source, timming, mode)) {
|
|
LOGE("Sync PictureMode Data source: %d, timming: %d, mode: %d fail!\n", source, timming, mode);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("Sync PictureMode Data %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBaseColorTempData(void)
|
|
{
|
|
LOGI("Sync ColorTemp Start!\n");
|
|
|
|
int Flag = 0;
|
|
SSM_COLORTEMP_STRUCT ColorTemp;
|
|
for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
|
|
for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
|
|
for (int level = 0; level < MAX_SSM_COLORTEMP_INDEX; level++) {
|
|
if (!CheckIndexSupport(source, timming))
|
|
continue;
|
|
|
|
int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_COLORTEMP_INDEX +
|
|
timming * MAX_SSM_COLORTEMP_INDEX + level) *
|
|
MAX_SSM_COLORTEMP_PARAM_SIZE;
|
|
if (!SSMAction::getInstance()->GetSsmDataParam((void *)&ColorTemp,
|
|
SSM_COLORTEMP_ID,
|
|
sizeof(SSM_COLORTEMP_STRUCT),
|
|
offset,
|
|
true)) {
|
|
continue;
|
|
}
|
|
|
|
if (!CPQDataBase::GetInstance()->SetColorTemperatureData((COLORTEMP_DATA *)&ColorTemp, source, timming, level)) {
|
|
LOGE("Sync ColorTemp source: %d, timming: %d, level: %d fail!\n", source, timming, level);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("Sync ColorTemp %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBaseWbGammaData(void)
|
|
{
|
|
LOGI("Sync ColorTemp Gamma Start\n");
|
|
|
|
int Flag = 0;
|
|
SSM_WB_GAMMA_TABLE WbGammaBase;
|
|
for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
|
|
for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
|
|
for (int level = 0; level < MAX_SSM_COLORTEMP_INDEX; level++) {
|
|
for (int mode = 0; mode < WB_GAMMA_MODE_MAX; mode++) {
|
|
int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_COLORTEMP_INDEX * WB_GAMMA_MODE_MAX +
|
|
timming * MAX_SSM_COLORTEMP_INDEX * WB_GAMMA_MODE_MAX +
|
|
level * WB_GAMMA_MODE_MAX + mode) *
|
|
MAX_SSM_WB_GAMMA_PARAM_SIZE;
|
|
if (!SSMAction::getInstance()->GetSsmDataParam((void *)&WbGammaBase,
|
|
SSM_WB_GAMMA_ID,
|
|
sizeof(SSM_WB_GAMMA_TABLE),
|
|
offset,
|
|
true)) {
|
|
continue;
|
|
}
|
|
|
|
if (!CPQDataBase::GetInstance()->SetGammaOffsetData((GAMMA_OFFSET_DATA *)&WbGammaBase, level, mode, source, timming)) {
|
|
LOGE("Sync ColorTemp Gamma source: %d, timming: %d, level: %d, mode: %d fail!\n", source, timming, level, mode);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("Sync ColorTemp Gamma %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBaseCmsData_3_1(void)
|
|
{
|
|
LOGI("%s Sync Cms Start\n", __FUNCTION__);
|
|
|
|
int Flag = 0;
|
|
SSM_TABLE_CMS Cms;
|
|
int offset = 0;
|
|
|
|
if (SSMAction::getInstance()->GetSsmDataParam((void *)&Cms.CmsEnable,
|
|
VPP_DATA_POS_COLOR_TUNE_START,
|
|
sizeof(int),
|
|
offset,
|
|
false)) {
|
|
if (SSMAction::getInstance()->GetSsmDataParam((void *)&Cms.CmsColor,
|
|
VPP_DATA_POS_COLORCUSTOMIZE_CM_START,
|
|
sizeof(vpp_cms_cm_param_t),
|
|
offset,
|
|
false)) {
|
|
for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
|
|
for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
|
|
for (int mode = 0; mode < MAX_SSM_PICTUREMODE_INDEX; mode++) {
|
|
if (!CheckIndexSupport(source, timming))
|
|
continue;
|
|
|
|
if (!CPQDataBase::GetInstance()->SetColorCustomizeData((TABLE_CMS *)&Cms, mode, source, timming)) {
|
|
LOGE("source: %d, timming: %d, level: %d fail!\n", source, timming, mode);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("%s Sync Cms %d End\n", __FUNCTION__, Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBaseCmsData(void)
|
|
{
|
|
LOGI("Sync Cms Start\n");
|
|
|
|
int Flag = 0;
|
|
SSM_TABLE_CMS Cms;
|
|
for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
|
|
for (int timming = 0; timming < MAX_SSM_PQ_TIMMING_INDEX; timming ++) {
|
|
for (int mode = 0; mode < MAX_SSM_PICTUREMODE_INDEX; mode++) {
|
|
if (!CheckIndexSupport(source, timming))
|
|
continue;
|
|
|
|
int offset = (source * MAX_SSM_PQ_TIMMING_INDEX * MAX_SSM_PICTUREMODE_INDEX +
|
|
timming * MAX_SSM_PICTUREMODE_INDEX +
|
|
mode) *
|
|
MAX_SSM_COLORCUSTOMIZE_CM_PARAM_SIZE;
|
|
if (!SSMAction::getInstance()->GetSsmDataParam((void *)&Cms,
|
|
SSM_CMS_ID,
|
|
sizeof(SSM_TABLE_CMS),
|
|
offset,
|
|
true)) {
|
|
continue;
|
|
}
|
|
|
|
if (!CPQDataBase::GetInstance()->SetColorCustomizeData((TABLE_CMS *)&Cms, mode, source, timming)) {
|
|
LOGE("source: %d, timming: %d, level: %d fail!\n", source, timming, mode);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("Sync Cms %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBaseBySourcePicture(void)
|
|
{
|
|
LOGI("Sync BySourcePicture Start\n");
|
|
|
|
int Flag = 0;
|
|
PICTURE_SETTING_BY_SRC PictureExt;
|
|
for (int source = 0; source < MAX_SSM_PQ_SRC_INDEX; source++) {
|
|
if (!CPQDataBase::GetInstance()->GetPictureStructDataBySrc(&PictureExt, source + 1)) {
|
|
if (!CPQDataBase::GetInstance()->GetPictureStructDataBySrc(&PictureExt, PQ_SRC_DEFAULT)) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
SSMAction::getInstance()->SSMReadMemcMode(source, &PictureExt.Memc);
|
|
for (int j = 0; j < VPP_MEMC_MODE_MAX; j++) {
|
|
SSMAction::getInstance()->SSMReadMemcDeblurLevel(source * VPP_MEMC_MODE_MAX + j, &PictureExt.memc[j].DeBlurLevel);
|
|
SSMAction::getInstance()->SSMReadMemcDeJudderLevel(source * VPP_MEMC_MODE_MAX + j, &PictureExt.memc[j].DeJudderLevel);
|
|
}
|
|
SSMAction::getInstance()->SSMReadMcDiMode(source, &PictureExt.McDiMode);
|
|
SSMAction::getInstance()->SSMReadDisplayMode(source, &PictureExt.DisplayMode);
|
|
SSMAction::getInstance()->SSMReadLocalDimming(source, &PictureExt.LocalDimming);
|
|
|
|
if (!CPQDataBase::GetInstance()->SetPictureStructDataBySrc(&PictureExt, source + 1)) {
|
|
LOGE("SetPictureStructDataBySrc source: %d fail!\n", source);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
|
|
LOGI("Sync BySourcePicture %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBaseGlobalPicture(void)
|
|
{
|
|
LOGI("Sync GlobalPicture Start\n");
|
|
|
|
int Flag = 0;
|
|
PICTURE_SETTING_GLOBAL Global;
|
|
if (!CPQDataBase::GetInstance()->GetPictureStructDataGlobal(&Global)) {
|
|
return Flag;
|
|
}
|
|
|
|
SSMAction::getInstance()->SSMReadAipqEnableVal(&Global.aipq_enable);
|
|
SSMAction::getInstance()->SSMReadAiSrMode(&Global.aipq_mode);
|
|
SSMAction::getInstance()->SSMReadWhitebalanceGammaMode(0, &Global.WBGammaPoint);
|
|
SSMAction::getInstance()->SSMReadFilmMakerMode(&Global.FilmMakerEnable);
|
|
|
|
if (!CPQDataBase::GetInstance()->SetPictureStructDataGlobal(&Global)) {
|
|
LOGE("fail!\n");
|
|
} else {
|
|
Flag++;
|
|
}
|
|
|
|
LOGI("Sync GlobalPicture %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncDataBaseLcdLvdsSsc(void)
|
|
{
|
|
LOGI("Sync Lcd Lvds Ssc Start\n");
|
|
|
|
int Flag = 0;
|
|
LCD_LVDS_SSC ssc;
|
|
if (SSMAction::getInstance()->SSMReadLVDSSSC(0, sizeof(ssc), (int *)&ssc) < 0) {
|
|
return Flag;
|
|
}
|
|
|
|
if (!CPQDataBase::GetInstance()->SetLvdsSscData(&ssc, 0)) {
|
|
LOGE("fail!\n");
|
|
} else {
|
|
Flag++;
|
|
}
|
|
|
|
LOGI("Sync Lcd Lvds Ssc %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
|
|
//============================ CRI DATA =================================================//
|
|
bool SyncDataBase::SyncCriDataInit(void)
|
|
{
|
|
LOGD("%s Factory Start !\n",__FUNCTION__);
|
|
|
|
if (strlen(DatabaseVersion) <= 0) {
|
|
LOGD("%s DatabaseVersion is null !\n",__FUNCTION__);
|
|
return false;
|
|
}
|
|
|
|
LOGD("%s base cri data version is %s \n",__FUNCTION__, DatabaseVersion);
|
|
|
|
char INFO[64];
|
|
if (WhitebalanceDataBase::GetInstance()->GetSyncData((void *)INFO, sizeof(INFO))) {
|
|
if (strcmp(DatabaseVersion, INFO) == 0) {
|
|
LOGD("%s sync version is match %s == %s\n",__FUNCTION__, DatabaseVersion, INFO);
|
|
return true;
|
|
} else {
|
|
LOGD("%s sync version is not match %s != %s, need sync new version to %s!\n",__FUNCTION__,
|
|
DatabaseVersion, INFO, DatabaseVersion);
|
|
}
|
|
}
|
|
|
|
if (strcmp(DatabaseVersion, "3.1") == 0) {
|
|
SyncCriDataColorTempData();
|
|
SyncCriDataMultipointGammaData_3_1();
|
|
SyncCriDataGammaData_3_1();
|
|
} else {
|
|
SyncCriDataColorTempData();
|
|
SyncCriDataMultipointGammaData();
|
|
SyncCriDataGammaData();
|
|
}
|
|
|
|
snprintf(INFO, sizeof(INFO), "%s", DatabaseVersion);
|
|
if (!WhitebalanceDataBase::GetInstance()->SetSyncData((void *)INFO, sizeof(INFO))) {
|
|
LOGE("WhitebalanceDataBase::GetInstance()->SetSyncData %s fail!\n", INFO);
|
|
return false;
|
|
}
|
|
|
|
LOGD("%s Factory success!\n", __FUNCTION__);
|
|
|
|
return true;
|
|
}
|
|
|
|
int SyncDataBase::SyncCriDataColorTempData(void)
|
|
{
|
|
LOGI("Sync Factory ColorTemp Start\n");
|
|
|
|
int Flag = 0;
|
|
tcon_rgb_ogo_t ColorTempBase;
|
|
for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
|
|
int offset = CRI_RGBOGO_OFFSET + (CRI_RGBOGO_LEN * k);
|
|
int offsetFlag = offset + CRI_RGBOGO_LEN - 2;
|
|
if (!SSMAction::getInstance()->GetCriDataParam((void *)&ColorTempBase,
|
|
sizeof(tcon_rgb_ogo_t),
|
|
offset,
|
|
true,
|
|
offsetFlag,
|
|
2)) {
|
|
continue;
|
|
}
|
|
|
|
if (!WhitebalanceDataBase::GetInstance()->SetRGBGainOffsetData((COLORTEMP_DATA *)&ColorTempBase, k)) {
|
|
LOGE("Warning: SetRGBGainOffsetData level: %d fail!\n", k);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
|
|
LOGI("Sync Factory ColorTemp %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncCriDataMultipointGammaData(void)
|
|
{
|
|
LOGI("Sync Factory Multipoint Gamma Start\n");
|
|
|
|
int Flag = 0;
|
|
GAMMA_OFFSET_DATA ColorTempGamma;
|
|
ColorTempGamma.enable = 1;
|
|
for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
|
|
for (int l = 0; l < WB_GAMMA_MODE_MAX; l++) {
|
|
int offset = CRI_WB_GAMMA_OFFSET + (CRI_WB_GAMMA_LEN * (k * WB_GAMMA_MODE_MAX + l));
|
|
int offsetFlag = offset + CRI_WB_GAMMA_LEN - 2;
|
|
if (!SSMAction::getInstance()->GetCriDataParam((void *)&ColorTempGamma.Gamma,
|
|
sizeof(Multipoint_GAMMA_DATA),
|
|
offset,
|
|
true,
|
|
offsetFlag,
|
|
2)) {
|
|
continue;
|
|
}
|
|
|
|
if (!WhitebalanceDataBase::GetInstance()->SetWhitebalanceGammaData(&ColorTempGamma, k, l)) {
|
|
LOGE("WhitebalanceDataBase::GetInstance()->SetWhitebalanceGammaData level: %d mode: %d fail!\n", k, l);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("Sync Factory Multipoint Gamma %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncCriDataGammaData(void)
|
|
{
|
|
LOGI("Sync Factory Gamma Start\n");
|
|
|
|
int Flag = 0;
|
|
tcon_gamma_table_t Gamma;
|
|
for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
|
|
for (int l = 0; l < MAX_CH; l++) {
|
|
int offset = CRI_GAMMA_OFFSET + ((k * MAX_CH + l) * CRI_GAMMA_LEN);
|
|
int flag_offset = offset + CRI_GAMMA_LEN - sizeof(int);
|
|
if (!SSMAction::getInstance()->GetCriDataParam((void *)&Gamma,
|
|
sizeof(tcon_gamma_table_t),
|
|
offset,
|
|
true,
|
|
flag_offset,
|
|
4)) {
|
|
continue;
|
|
}
|
|
|
|
if (!WhitebalanceDataBase::GetInstance()->SetGammaTableData(&Gamma, k, l)) {
|
|
LOGE("Sync Gamma level: %d type: %d fail!\n", k, l);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("Sync Factory Gamma %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncCriDataMultipointGammaData_3_1(void)
|
|
{
|
|
LOGI("Sync Factory Multipoint Gamma Start\n");
|
|
|
|
int Flag = 0;
|
|
GAMMA_OFFSET_DATA ColorTempGamma;
|
|
ColorTempGamma.enable = 1;
|
|
for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
|
|
for (int l = 0; l < WB_GAMMA_MODE_MAX; l++) {
|
|
int offset = CRI_DATA_WB_GAMMA_OFFSET_3_1 + (CRI_DATE_WB_GAMMA_LEN_3_1 * (k * WB_GAMMA_MODE_MAX + l));
|
|
int offsetFlag = offset + CRI_DATE_WB_GAMMA_LEN_3_1 - 2;
|
|
if (!SSMAction::getInstance()->GetCriDataParam((void *)&ColorTempGamma.Gamma,
|
|
sizeof(Multipoint_GAMMA_DATA),
|
|
offset,
|
|
true,
|
|
offsetFlag,
|
|
2)) {
|
|
continue;
|
|
}
|
|
|
|
if (!WhitebalanceDataBase::GetInstance()->SetWhitebalanceGammaData(&ColorTempGamma, k, l)) {
|
|
LOGE("WhitebalanceDataBase::GetInstance()->SetWhitebalanceGammaData level: %d mode: %d fail!\n", k, l);
|
|
} else {
|
|
Flag++;
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("Sync Factory Multipoint Gamma %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
int SyncDataBase::SyncCriDataGammaData_3_1(void)
|
|
{
|
|
LOGI("Sync Factory Gamma Start\n");
|
|
|
|
int Flag = 0;
|
|
GAMMA_TABLE Gamma;
|
|
for (int k = 0; k < MAX_SSM_COLORTEMP_INDEX; k++) {
|
|
int offset = CRI_DATA_GAMMA_OFFSET_3_1 + (k * CRI_DATE_GAMMA_LEN_3_1);
|
|
int flag_offset = offset + CRI_DATE_GAMMA_LEN_3_1 - 2;
|
|
if (!SSMAction::getInstance()->GetCriDataParam((void *)&Gamma,
|
|
sizeof(GAMMA_TABLE),
|
|
offset,
|
|
true,
|
|
flag_offset,
|
|
2)) {
|
|
continue;
|
|
}
|
|
|
|
int ret = 0;
|
|
if (!WhitebalanceDataBase::GetInstance()->SetGammaTableData(&Gamma.R, k, RED_CH)) {
|
|
ret |= -1;
|
|
LOGE("Sync Gamma level: %d type: %d fail!\n", k, RED_CH);
|
|
}
|
|
|
|
if (!WhitebalanceDataBase::GetInstance()->SetGammaTableData(&Gamma.G, k, GREEN_CH)) {
|
|
ret |= -1;
|
|
LOGE("Sync Gamma level: %d type: %d fail!\n", k, GREEN_CH);
|
|
}
|
|
|
|
if (!WhitebalanceDataBase::GetInstance()->SetGammaTableData(&Gamma.B, k, BLUE_CH)) {
|
|
ret |= -1;
|
|
LOGE("Sync Gamma level: %d type: %d fail!\n", k, BLUE_CH);
|
|
}
|
|
|
|
if (ret == 0)
|
|
Flag++;
|
|
}
|
|
|
|
LOGI("Sync Factory Gamma %d End\n", Flag);
|
|
|
|
return Flag;
|
|
}
|
|
|
|
bool SyncDataBase::CheckIndexSupport(int source, int timming)
|
|
{
|
|
if ((source == PQ_SRC_TV) ||
|
|
(source >= PQ_SRC_AV1 && source <= PQ_SRC_YPBPR2) ||
|
|
(source == PQ_SRC_VGA) ||
|
|
(source == PQ_SRC_SVIDEO)) {
|
|
if (timming != PQ_FMT_SDR)
|
|
return false;
|
|
} else if (source >= PQ_SRC_IPTV && source < PQ_SRC_MAX) {
|
|
return false;
|
|
}
|
|
|
|
if (source != PQ_SRC_DEFAULT) {
|
|
if (timming == PQ_FMT_DEFAULT) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|