/******************************************************************************
|
*
|
* Copyright 2019, Fuzhou Rockchip Electronics Co.Ltd. All rights reserved.
|
* No part of this work may be reproduced, modified, distributed, transmitted,
|
* transcribed, or translated into any language or computer format, in any form
|
* or by any means without written permission of:
|
* Fuzhou Rockchip Electronics Co.Ltd .
|
*
|
*
|
*****************************************************************************/
|
/**
|
* @file ahdr.cpp
|
*
|
* @brief
|
* ADD_DESCRIPTION_HERE
|
*
|
*****************************************************************************/
|
#include "math.h"
|
#include "rk_aiq_types_atmo_algo_int.h"
|
#include "rk_aiq_types_atmo_algo_prvt.h"
|
#include "xcam_log.h"
|
|
/******************************************************************************
|
* AtmoStart()
|
*****************************************************************************/
|
RESULT AtmoStart
|
(
|
AtmoHandle_t pAtmoCtx
|
) {
|
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
// initial checks
|
if (pAtmoCtx == NULL) {
|
return (ATMO_RET_WRONG_HANDLE);
|
}
|
|
if ((ATMO_STATE_RUNNING == pAtmoCtx->state)
|
|| (ATMO_STATE_LOCKED == pAtmoCtx->state)) {
|
return (ATMO_RET_WRONG_STATE);
|
}
|
|
pAtmoCtx->state = ATMO_STATE_RUNNING;
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
return (ATMO_RET_SUCCESS);
|
}
|
/******************************************************************************
|
* AtmoStop()
|
*****************************************************************************/
|
RESULT AtmoStop
|
(
|
AtmoHandle_t pAtmoCtx
|
) {
|
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
// initial checks
|
if (pAtmoCtx == NULL) {
|
return (ATMO_RET_WRONG_HANDLE);
|
}
|
|
// before stopping, unlock the Atmo if locked
|
if (ATMO_STATE_LOCKED == pAtmoCtx->state) {
|
return (ATMO_RET_WRONG_STATE);
|
}
|
|
pAtmoCtx->state = ATMO_STATE_STOPPED;
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
|
return (ATMO_RET_SUCCESS);
|
}
|
/******************************************************************************
|
* TmoGetCurrPara()
|
*****************************************************************************/
|
float TmoGetCurrPara
|
(
|
float inPara,
|
float* inMatrixX,
|
float* inMatrixY,
|
int Max_Knots
|
) {
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
float x1 = 0.0f;
|
float x2 = 0.0f;
|
float value1 = 0.0f;
|
float value2 = 0.0f;
|
float outPara = 0.0f;
|
|
if(inPara < inMatrixX[0])
|
outPara = inMatrixY[0];
|
else if (inPara >= inMatrixX[Max_Knots - 1])
|
outPara = inMatrixY[Max_Knots - 1];
|
else
|
for(int i = 0; i < Max_Knots - 1; i++)
|
{
|
if(inPara >= inMatrixX[i] && inPara < inMatrixX[i + 1])
|
{
|
x1 = inMatrixX[i];
|
x2 = inMatrixX[i + 1];
|
value1 = inMatrixY[i];
|
value2 = inMatrixY[i + 1];
|
outPara = value1 + (inPara - x1) * (value1 - value2) / (x1 - x2);
|
break;
|
}
|
else
|
continue;
|
}
|
|
return outPara;
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
/******************************************************************************
|
* AtmoConfig()
|
*set default AtmoConfig data
|
*****************************************************************************/
|
void AtmoConfig
|
(
|
AtmoHandle_t pAtmoCtx
|
) {
|
LOGI_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
// initial checks
|
DCT_ASSERT(pAtmoCtx != NULL);
|
|
//config default PrevData data
|
pAtmoCtx->PrevData.CtrlData.FrameCnt = 0;
|
pAtmoCtx->PrevData.ro_hdrtmo_lgmean = 20000;
|
pAtmoCtx->PrevData.HandleData.GlobeLuma = 0.18;
|
pAtmoCtx->PrevData.HandleData.GlobeMaxLuma = 0.3;
|
pAtmoCtx->PrevData.HandleData.DetailsHighLight = 0.5;
|
pAtmoCtx->PrevData.HandleData.DetailsLowLight = 1;
|
pAtmoCtx->PrevData.HandleData.LocalTmoStrength = 0.3;
|
pAtmoCtx->PrevData.HandleData.GlobalTmoStrength = 0.5;
|
|
//set default ctrl info
|
pAtmoCtx->tmoAttr.CtlInfo.GlobalLumaMode = GLOBALLUMAMODE_ENVLV;
|
pAtmoCtx->tmoAttr.CtlInfo.DetailsHighLightMode = DETAILSHIGHLIGHTMODE_ENVLV;
|
pAtmoCtx->tmoAttr.CtlInfo.DetailsLowLightMode = DETAILSLOWLIGHTMODE_ISO;
|
pAtmoCtx->tmoAttr.CtlInfo.GlobalTmoMode = TMOTYPEMODE_DYNAMICRANGE;
|
pAtmoCtx->tmoAttr.CtlInfo.LocalTMOMode = TMOTYPEMODE_DYNAMICRANGE;
|
|
pAtmoCtx->tmoAttr.CtlInfo.Envlv = 1.0;
|
pAtmoCtx->tmoAttr.CtlInfo.ISO = 1.0;
|
pAtmoCtx->tmoAttr.CtlInfo.OEPdf = 1.0;
|
pAtmoCtx->tmoAttr.CtlInfo.FocusLuma = 1.0;
|
pAtmoCtx->tmoAttr.CtlInfo.DarkPdf = 1.0;
|
pAtmoCtx->tmoAttr.CtlInfo.DynamicRange = 1.0;
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
void AtmoGetStats
|
(
|
AtmoHandle_t pAtmoCtx,
|
rkisp_atmo_stats_t* ROData
|
) {
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lglow = ROData->tmo_stats.ro_hdrtmo_lglow;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmin = ROData->tmo_stats.ro_hdrtmo_lgmin;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmax = ROData->tmo_stats.ro_hdrtmo_lgmax;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lghigh = ROData->tmo_stats.ro_hdrtmo_lghigh;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmean = ROData->tmo_stats.ro_hdrtmo_lgmean;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_weightkey = ROData->tmo_stats.ro_hdrtmo_weightkey;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgrange0 = ROData->tmo_stats.ro_hdrtmo_lgrange0;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgrange1 = ROData->tmo_stats.ro_hdrtmo_lgrange1;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgavgmax = ROData->tmo_stats.ro_hdrtmo_lgavgmax;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_palpha = ROData->tmo_stats.ro_hdrtmo_palpha;
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_linecnt = ROData->tmo_stats.ro_hdrtmo_linecnt;
|
for(int i = 0; i < 32; i++)
|
pAtmoCtx->CurrStatsData.tmo_stats.ro_array_min_max[i] = ROData->tmo_stats.ro_array_min_max[i];
|
|
//get other stats from stats
|
for(int i = 0; i < 225; i++)
|
{
|
pAtmoCtx->CurrStatsData.other_stats.short_luma[i] = ROData->other_stats.short_luma[i];
|
pAtmoCtx->CurrStatsData.other_stats.long_luma[i] = ROData->other_stats.long_luma[i];
|
pAtmoCtx->CurrStatsData.other_stats.tmo_luma[i] = ROData->other_stats.tmo_luma[i];
|
}
|
|
if(pAtmoCtx->FrameNumber == 3)
|
{
|
for(int i = 0; i < 25; i++)
|
pAtmoCtx->CurrStatsData.other_stats.middle_luma[i] = ROData->other_stats.middle_luma[i];
|
}
|
|
LOGV_ATMO("%s: Ahdr RO data from register:\n", __FUNCTION__);
|
LOGV_ATMO("%s: ro_hdrtmo_lglow:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lglow);
|
LOGV_ATMO("%s: ro_hdrtmo_lgmin:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmin);
|
LOGV_ATMO("%s: ro_hdrtmo_lgmax:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmax);
|
LOGV_ATMO("%s: ro_hdrtmo_lghigh:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lghigh);
|
LOGV_ATMO("%s: ro_hdrtmo_weightkey:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_weightkey);
|
LOGV_ATMO("%s: ro_hdrtmo_lgmean:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmean);
|
LOGV_ATMO("%s: ro_hdrtmo_lgrange0:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgrange0);
|
LOGV_ATMO("%s: ro_hdrtmo_lgrange1:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgrange1);
|
LOGV_ATMO("%s: ro_hdrtmo_lgavgmax:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgavgmax);
|
LOGV_ATMO("%s: ro_hdrtmo_palpha:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_palpha);
|
LOGV_ATMO("%s: ro_hdrtmo_linecnt:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_linecnt);
|
for(int i = 0; i < 32; i++)
|
LOGV_ATMO("%s: ro_array_min_max[%d]:%d:\n", __FUNCTION__, i, pAtmoCtx->CurrStatsData.tmo_stats.ro_array_min_max[i]);
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
void AtmoGetAeResult
|
(
|
AtmoHandle_t pAtmoCtx,
|
AecPreResult_t AecHdrPreResult
|
) {
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
//get Ae Pre Result
|
pAtmoCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[AecHdrPreResult.NormalIndex];
|
pAtmoCtx->CurrAeResult.M2S_Ratio = AecHdrPreResult.M2S_ExpRatio;
|
pAtmoCtx->CurrAeResult.M2S_Ratio = pAtmoCtx->CurrAeResult.M2S_Ratio < 1 ? 1 : pAtmoCtx->CurrAeResult.M2S_Ratio;
|
pAtmoCtx->CurrAeResult.L2M_Ratio = AecHdrPreResult.L2M_ExpRatio;
|
pAtmoCtx->CurrAeResult.L2M_Ratio = pAtmoCtx->CurrAeResult.L2M_Ratio < 1 ? 1 : pAtmoCtx->CurrAeResult.L2M_Ratio;
|
pAtmoCtx->CurrAeResult.DynamicRange = AecHdrPreResult.DynamicRange;
|
pAtmoCtx->CurrAeResult.OEPdf = AecHdrPreResult.OverExpROIPdf[1];
|
pAtmoCtx->CurrAeResult.DarkPdf = AecHdrPreResult.LowLightROIPdf[1];
|
for(int i = 0; i < 225; i++)
|
{
|
pAtmoCtx->CurrAeResult.BlockLumaS[i] = pAtmoCtx->CurrStatsData.other_stats.short_luma[i];
|
pAtmoCtx->CurrAeResult.BlockLumaL[i] = pAtmoCtx->CurrStatsData.other_stats.long_luma[i];
|
}
|
if(pAtmoCtx->FrameNumber == 3)
|
for(int i = 0; i < 25; i++)
|
pAtmoCtx->CurrAeResult.BlockLumaM[i] = pAtmoCtx->CurrStatsData.other_stats.middle_luma[i];
|
else
|
for(int i = 0; i < 25; i++)
|
pAtmoCtx->CurrAeResult.BlockLumaM[i] = 0;
|
|
//transfer CurrAeResult data into AhdrHandle
|
switch (pAtmoCtx->FrameNumber)
|
{
|
case 1:
|
pAtmoCtx->CurrData.CtrlData.LExpo = AecHdrPreResult.LinearExp.exp_real_params.analog_gain * AecHdrPreResult.LinearExp.exp_real_params.integration_time;
|
pAtmoCtx->CurrData.CtrlData.L2S_Ratio = 1;
|
pAtmoCtx->CurrData.CtrlData.L2M_Ratio = 1;
|
pAtmoCtx->CurrData.CtrlData.L2L_Ratio = 1;
|
pAtmoCtx->CurrAeResult.ISO = AecHdrPreResult.LinearExp.exp_real_params.analog_gain * 50.0;
|
pAtmoCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[0];
|
pAtmoCtx->CurrAeResult.OEPdf = AecHdrPreResult.OverExpROIPdf[0];
|
pAtmoCtx->CurrAeResult.DarkPdf = AecHdrPreResult.LowLightROIPdf[0];
|
break;
|
case 2:
|
pAtmoCtx->CurrData.CtrlData.L2S_Ratio = pAtmoCtx->CurrAeResult.M2S_Ratio;
|
pAtmoCtx->CurrData.CtrlData.L2M_Ratio = 1;
|
pAtmoCtx->CurrData.CtrlData.L2L_Ratio = 1;
|
pAtmoCtx->CurrData.CtrlData.LExpo = AecHdrPreResult.HdrExp[1].exp_real_params.analog_gain * AecHdrPreResult.HdrExp[1].exp_real_params.integration_time;
|
pAtmoCtx->CurrAeResult.ISO = AecHdrPreResult.HdrExp[1].exp_real_params.analog_gain * 50.0;
|
pAtmoCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[1];
|
pAtmoCtx->CurrAeResult.OEPdf = AecHdrPreResult.OverExpROIPdf[1];
|
pAtmoCtx->CurrAeResult.DarkPdf = AecHdrPreResult.LowLightROIPdf[1];
|
break;
|
case 3:
|
pAtmoCtx->CurrData.CtrlData.L2S_Ratio = pAtmoCtx->CurrAeResult.L2M_Ratio * pAtmoCtx->CurrAeResult.M2S_Ratio;
|
pAtmoCtx->CurrData.CtrlData.L2M_Ratio = pAtmoCtx->CurrAeResult.L2M_Ratio;
|
pAtmoCtx->CurrData.CtrlData.L2L_Ratio = 1;
|
pAtmoCtx->CurrData.CtrlData.LExpo = AecHdrPreResult.HdrExp[2].exp_real_params.analog_gain * AecHdrPreResult.HdrExp[2].exp_real_params.integration_time;
|
pAtmoCtx->CurrAeResult.ISO = AecHdrPreResult.HdrExp[2].exp_real_params.analog_gain * 50.0;
|
pAtmoCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[2];
|
pAtmoCtx->CurrAeResult.OEPdf = AecHdrPreResult.OverExpROIPdf[1];
|
pAtmoCtx->CurrAeResult.DarkPdf = AecHdrPreResult.LowLightROIPdf[1];
|
break;
|
default:
|
LOGE_ATMO("%s: Wrong frame number in TMO mode!!!\n", __FUNCTION__);
|
break;
|
}
|
|
//Normalize the current envLv for AEC
|
float maxEnvLuma = 65 / 10;
|
float minEnvLuma = 0;
|
pAtmoCtx->CurrData.CtrlData.EnvLv = (pAtmoCtx->CurrAeResult.GlobalEnvLv - minEnvLuma) / (maxEnvLuma - minEnvLuma);
|
pAtmoCtx->CurrData.CtrlData.EnvLv = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.EnvLv, ENVLVMAX, ENVLVMIN);
|
|
LOGD_ATMO("%s: Current L2S_Ratio:%f L2M_Ratio:%f L2L_Ratio:%f\n", __FUNCTION__, pAtmoCtx->CurrData.CtrlData.L2S_Ratio,
|
pAtmoCtx->CurrData.CtrlData.L2M_Ratio, pAtmoCtx->CurrData.CtrlData.L2L_Ratio);
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
void AtmoGetSensorInfo
|
(
|
AtmoHandle_t pAtmoCtx,
|
AecProcResult_t AecHdrProcResult
|
) {
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
pAtmoCtx->SensorInfo.LongFrmMode = AecHdrProcResult.LongFrmMode && (pAtmoCtx->FrameNumber != 1);
|
|
for(int i = 0; i < 3; i++)
|
{
|
pAtmoCtx->SensorInfo.HdrMinGain[i] = AecHdrProcResult.HdrMinGain[i];
|
pAtmoCtx->SensorInfo.HdrMaxGain[i] = AecHdrProcResult.HdrMaxGain[i];
|
pAtmoCtx->SensorInfo.HdrMinIntegrationTime[i] = AecHdrProcResult.HdrMinIntegrationTime[i];
|
pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[i] = AecHdrProcResult.HdrMaxIntegrationTime[i];
|
}
|
|
if(pAtmoCtx->FrameNumber == 1)
|
{
|
//pAtmoCtx->SensorInfo.MaxExpoL = pAtmoCtx->SensorInfo.HdrMaxGain[1] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[1];
|
//pAtmoCtx->SensorInfo.MinExpoL = pAtmoCtx->SensorInfo.HdrMinGain[1] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[1];
|
//pAtmoCtx->SensorInfo.MaxExpoM = 0;
|
//pAtmoCtx->SensorInfo.MinExpoM = 0;
|
|
pAtmoCtx->CurrAeResult.LumaDeviationLinear = AecHdrProcResult.LumaDeviation;
|
pAtmoCtx->CurrAeResult.LumaDeviationLinear = abs(pAtmoCtx->CurrAeResult.LumaDeviationLinear);
|
}
|
else if(pAtmoCtx->FrameNumber == 2)
|
{
|
pAtmoCtx->SensorInfo.MaxExpoL = pAtmoCtx->SensorInfo.HdrMaxGain[1] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[1];
|
pAtmoCtx->SensorInfo.MinExpoL = pAtmoCtx->SensorInfo.HdrMinGain[1] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[1];
|
pAtmoCtx->SensorInfo.MaxExpoM = 0;
|
pAtmoCtx->SensorInfo.MinExpoM = 0;
|
|
pAtmoCtx->CurrAeResult.LumaDeviationL = AecHdrProcResult.HdrLumaDeviation[1];
|
pAtmoCtx->CurrAeResult.LumaDeviationL = abs(pAtmoCtx->CurrAeResult.LumaDeviationL);
|
pAtmoCtx->CurrAeResult.LumaDeviationS = AecHdrProcResult.HdrLumaDeviation[0];
|
pAtmoCtx->CurrAeResult.LumaDeviationS = abs(pAtmoCtx->CurrAeResult.LumaDeviationS);
|
}
|
else if(pAtmoCtx->FrameNumber == 3)
|
{
|
pAtmoCtx->SensorInfo.MaxExpoL = pAtmoCtx->SensorInfo.HdrMaxGain[2] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[2];
|
pAtmoCtx->SensorInfo.MinExpoL = pAtmoCtx->SensorInfo.HdrMinGain[2] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[2];
|
pAtmoCtx->SensorInfo.MaxExpoM = pAtmoCtx->SensorInfo.HdrMaxGain[1] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[1];
|
pAtmoCtx->SensorInfo.MinExpoM = pAtmoCtx->SensorInfo.HdrMinGain[1] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[1];
|
|
pAtmoCtx->CurrAeResult.LumaDeviationL = AecHdrProcResult.HdrLumaDeviation[2];
|
pAtmoCtx->CurrAeResult.LumaDeviationL = abs(pAtmoCtx->CurrAeResult.LumaDeviationL);
|
pAtmoCtx->CurrAeResult.LumaDeviationM = AecHdrProcResult.HdrLumaDeviation[1];
|
pAtmoCtx->CurrAeResult.LumaDeviationM = abs(pAtmoCtx->CurrAeResult.LumaDeviationM);
|
pAtmoCtx->CurrAeResult.LumaDeviationS = AecHdrProcResult.HdrLumaDeviation[0];
|
pAtmoCtx->CurrAeResult.LumaDeviationS = abs(pAtmoCtx->CurrAeResult.LumaDeviationS);
|
}
|
|
pAtmoCtx->SensorInfo.MaxExpoS = pAtmoCtx->SensorInfo.HdrMaxGain[0] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[0];
|
pAtmoCtx->SensorInfo.MinExpoS = pAtmoCtx->SensorInfo.HdrMinGain[0] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[0];
|
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* AtmoApiSetLevel()
|
*
|
*****************************************************************************/
|
void AtmoApiSetLevel
|
(
|
AtmoHandle_t pAtmoCtx
|
)
|
{
|
LOG1_ATMO("%s:enter!\n", __FUNCTION__);
|
|
//tmo data
|
pAtmoCtx->tmoAttr.stSetLevel.level = LIMIT_VALUE(pAtmoCtx->tmoAttr.stSetLevel.level, FASTMODELEVELMAX, FASTMODELEVELMIN);
|
|
float level = ((float)(pAtmoCtx->tmoAttr.stSetLevel.level)) / FASTMODELEVELMAX;
|
float level_default = 0.5;
|
float level_diff = level - level_default;
|
|
pAtmoCtx->CurrData.HandleData.GlobeLuma *= 1 + level_diff;
|
float GlobeLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma;
|
pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = MAXLUMAK * GlobeLuma + MAXLUMAB;
|
pAtmoCtx->CurrData.HandleData.GlobeMaxLuma =
|
LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma, GLOBEMAXLUMAMAX, GLOBEMAXLUMAMIN);
|
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight *= 1 + level_diff;
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight =
|
LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsHighLight, DETAILSHIGHLIGHTMAX, DETAILSHIGHLIGHTMIN);
|
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight *= 1 + level_diff;
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight =
|
LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsLowLight, DETAILSLOWLIGHTMAX, DETAILSLOWLIGHTMIN);
|
|
pAtmoCtx->AtmoConfig.bTmoEn = true;
|
pAtmoCtx->ProcRes.isLinearTmo = pAtmoCtx->FrameNumber == 1 ;
|
|
/*
|
pAtmoCtx->CurrData.HandleData.TmoContrast *= 1 + level_diff;
|
pAtmoCtx->CurrData.HandleData.TmoContrast =
|
LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.LocalTmoStrength, TMOCONTRASTMAX, TMOCONTRASTMIN);
|
*/
|
//paras after updating
|
LOGD_ATMO("%s: AHDR_OpMode_Fast set level:%d\n", __FUNCTION__, pAtmoCtx->tmoAttr.stSetLevel.level);
|
LOGD_ATMO("%s: After fast mode GlobeLuma:%f GlobeMaxLuma:%f DetailsHighLight:%f DetailsLowLight:%f LocalTmoStrength:%f \n", __FUNCTION__,
|
pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight, pAtmoCtx->CurrData.HandleData.DetailsLowLight,
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
|
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* ApiOffProcess()
|
*
|
*****************************************************************************/
|
void ApiOffProcess(AtmoHandle_t pAtmoCtx)
|
{
|
LOG1_ATMO("%s:enter!\n", __FUNCTION__);
|
|
//get Current GlobeLuma GlobeMaxLuma
|
if(pAtmoCtx->AtmoConfig.Luma.globalLumaMode == GLOBALLUMAMODE_ENVLV)
|
pAtmoCtx->CurrData.HandleData.GlobeLuma = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.EnvLv,
|
pAtmoCtx->AtmoConfig.Luma.EnvLv, pAtmoCtx->AtmoConfig.Luma.GlobeLuma, pAtmoCtx->AtmoConfig.Luma.len);
|
else if(pAtmoCtx->AtmoConfig.Luma.globalLumaMode == GLOBALLUMAMODE_ISO)
|
pAtmoCtx->CurrData.HandleData.GlobeLuma = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.ISO,
|
pAtmoCtx->AtmoConfig.Luma.ISO, pAtmoCtx->AtmoConfig.Luma.GlobeLuma, pAtmoCtx->AtmoConfig.Luma.len);
|
|
float GlobeLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma;
|
pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = MAXLUMAK * GlobeLuma + MAXLUMAB;
|
pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma, GLOBEMAXLUMAMAX, GLOBEMAXLUMAMIN);
|
|
//get Current local tmo
|
if(pAtmoCtx->AtmoConfig.local.localtmoMode == TMOTYPEMODE_DYNAMICRANGE)
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.DynamicRange,
|
pAtmoCtx->AtmoConfig.local.DynamicRange, pAtmoCtx->AtmoConfig.local.LocalTmoStrength, pAtmoCtx->AtmoConfig.local.len);
|
else if(pAtmoCtx->AtmoConfig.local.localtmoMode == TMOTYPEMODE_ENVLV)
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.EnvLv,
|
pAtmoCtx->AtmoConfig.local.EnvLv, pAtmoCtx->AtmoConfig.local.LocalTmoStrength, pAtmoCtx->AtmoConfig.local.len);
|
|
if(pAtmoCtx->AtmoConfig.global.isHdrGlobalTmo)
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength = 0;
|
|
//get Current global tmo
|
if(pAtmoCtx->AtmoConfig.global.mode == TMOTYPEMODE_DYNAMICRANGE)
|
pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.DynamicRange,
|
pAtmoCtx->AtmoConfig.global.DynamicRange, pAtmoCtx->AtmoConfig.global.GlobalTmoStrength, pAtmoCtx->AtmoConfig.global.len);
|
else if(pAtmoCtx->AtmoConfig.global.mode == TMOTYPEMODE_ENVLV)
|
pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.EnvLv,
|
pAtmoCtx->AtmoConfig.global.EnvLv, pAtmoCtx->AtmoConfig.global.GlobalTmoStrength, pAtmoCtx->AtmoConfig.global.len);
|
|
//get Current DetailsHighLight
|
if(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode == DETAILSHIGHLIGHTMODE_OEPDF)
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.OEPdf,
|
pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight, pAtmoCtx->AtmoConfig.DtsHiLit.len);
|
else if(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode == DETAILSHIGHLIGHTMODE_ENVLV)
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.EnvLv,
|
pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight, pAtmoCtx->AtmoConfig.DtsHiLit.len);
|
|
//get Current DetailsLowLight
|
int DetailsLowLight_mode = (int)pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode;
|
if (pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_FOCUSLUMA)
|
{
|
#if 0
|
int focs = pAtmoCtx->CurrAfResult.CurrAfTargetPos;
|
int focs_width = pAtmoCtx->CurrAfResult.CurrAfTargetWidth / (pAtmoCtx->width / 15);
|
int focs_height = pAtmoCtx->CurrAfResult.CurrAfTargetHeight / (pAtmoCtx->height / 15);
|
float focs_luma = 0;
|
for(int i = 0; i < focs_height; i++)
|
for(int j = 0; j < focs_width; j++)
|
focs_luma += pAtmoCtx->CurrAeResult.BlockLumaL[focs + i + 15 * j];
|
focs_luma = focs_luma / (focs_width * focs_height);
|
pAtmoCtx->CurrData.CtrlData.FocusLuma = focs_luma / 15;
|
pAtmoCtx->CurrData.CtrlData.FocusLuma = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.FocusLuma, FOCUSLUMAMAX, FOCUSLUMAMIN);
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.FocusLuma,
|
pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight, pAtmoCtx->AtmoConfig.DtsLoLit.len);
|
|
#endif
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight = pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[0];
|
|
}
|
else if (pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_DARKPDF)
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.DarkPdf,
|
pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight, pAtmoCtx->AtmoConfig.DtsLoLit.len);
|
else if (pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_ISO)
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.ISO,
|
pAtmoCtx->AtmoConfig.DtsLoLit.ISO, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight, pAtmoCtx->AtmoConfig.DtsLoLit.len);
|
|
//get Current tmo TmoDamp
|
pAtmoCtx->CurrData.CtrlData.TmoDamp = pAtmoCtx->AtmoConfig.damp;
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* AtmoTranferData2Api()
|
*
|
*****************************************************************************/
|
void AtmoTranferData2Api
|
(
|
AtmoHandle_t pAtmoCtx
|
)
|
{
|
LOG1_ATMO("%s:enter!\n", __FUNCTION__);
|
|
//transfer control data to api
|
pAtmoCtx->tmoAttr.CtlInfo.GlobalLumaMode = pAtmoCtx->AtmoConfig.Luma.globalLumaMode;
|
pAtmoCtx->tmoAttr.CtlInfo.DetailsHighLightMode = pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode;
|
pAtmoCtx->tmoAttr.CtlInfo.DetailsLowLightMode = pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode;
|
pAtmoCtx->tmoAttr.CtlInfo.GlobalTmoMode = pAtmoCtx->AtmoConfig.global.mode;
|
pAtmoCtx->tmoAttr.CtlInfo.LocalTMOMode = pAtmoCtx->AtmoConfig.local.localtmoMode;
|
pAtmoCtx->tmoAttr.CtlInfo.Envlv = pAtmoCtx->CurrData.CtrlData.EnvLv;
|
pAtmoCtx->tmoAttr.CtlInfo.ISO = pAtmoCtx->CurrData.CtrlData.ISO;
|
pAtmoCtx->tmoAttr.CtlInfo.OEPdf = pAtmoCtx->CurrData.CtrlData.OEPdf;
|
pAtmoCtx->tmoAttr.CtlInfo.DarkPdf = pAtmoCtx->CurrData.CtrlData.DarkPdf;
|
pAtmoCtx->tmoAttr.CtlInfo.FocusLuma = pAtmoCtx->CurrData.CtrlData.FocusLuma;
|
pAtmoCtx->tmoAttr.CtlInfo.DynamicRange = pAtmoCtx->CurrData.CtrlData.DynamicRange;
|
|
//transfer register data to api
|
pAtmoCtx->tmoAttr.RegInfo.GlobalLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma / GLOBELUMAMAX;
|
pAtmoCtx->tmoAttr.RegInfo.DetailsLowlight = pAtmoCtx->CurrData.HandleData.DetailsLowLight / DETAILSLOWLIGHTMIN;
|
pAtmoCtx->tmoAttr.RegInfo.DetailsHighlight = pAtmoCtx->CurrData.HandleData.DetailsHighLight / DETAILSHIGHLIGHTMAX;
|
pAtmoCtx->tmoAttr.RegInfo.LocalTmoStrength = pAtmoCtx->CurrData.HandleData.LocalTmoStrength / TMOCONTRASTMAX;
|
pAtmoCtx->tmoAttr.RegInfo.GlobaltmoStrength = pAtmoCtx->CurrData.HandleData.GlobalTmoStrength;
|
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* AtmoApiAutoUpdate()
|
*
|
*****************************************************************************/
|
void AtmoApiAutoUpdate
|
(
|
AtmoHandle_t pAtmoCtx
|
)
|
{
|
LOG1_ATMO("%s:enter!\n", __FUNCTION__);
|
|
//update tmo data in Auto mode
|
if (pAtmoCtx->tmoAttr.stAuto.bUpdateTmo == true)
|
{
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight =
|
LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stMin,
|
pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stMin);
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight *= IQDETAILSLOWLIGHTMIN;
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsLowLight
|
, IQDETAILSLOWLIGHTMAX, IQDETAILSLOWLIGHTMIN);
|
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight =
|
LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stMin,
|
pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stMin);
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight *= DETAILSHIGHLIGHTMAX;
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsHighLight
|
, DETAILSHIGHLIGHTMAX, DETAILSHIGHLIGHTMIN);
|
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength =
|
LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stMin,
|
pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stMin);
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength *= TMOCONTRASTMAX;
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.LocalTmoStrength
|
, TMOCONTRASTMAX, TMOCONTRASTMIN);
|
|
pAtmoCtx->CurrData.HandleData.GlobeLuma =
|
LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stMin,
|
pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stMin);
|
pAtmoCtx->CurrData.HandleData.GlobeLuma *= GLOBELUMAMAX;
|
pAtmoCtx->CurrData.HandleData.GlobeLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeLuma
|
, GLOBELUMAMAX, GLOBELUMAMIN);
|
|
float GlobeLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma;
|
pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = MAXLUMAK * GlobeLuma + MAXLUMAB;
|
pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
|
GLOBEMAXLUMAMAX, GLOBEMAXLUMAMIN);
|
|
if(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.en)
|
{
|
float strength = LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stMin,
|
pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stMin);
|
pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = strength;
|
}
|
else
|
pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = 0.5;
|
|
}
|
else
|
ApiOffProcess(pAtmoCtx);
|
|
//paras after updating
|
LOGD_ATMO("%s: Current GlobeLuma:%f GlobeMaxLuma:%f DetailsHighLight:%f DetailsLowLight:%f GlobalTmoStrength:%f LocalTmoStrength:%f\n", __FUNCTION__,
|
pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight, pAtmoCtx->CurrData.HandleData.DetailsLowLight,
|
pAtmoCtx->CurrData.HandleData.GlobalTmoStrength, pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* AtmoApiManualUpdate()
|
*
|
*****************************************************************************/
|
void AtmoApiManualUpdate
|
(
|
AtmoHandle_t pAtmoCtx
|
)
|
{
|
LOG1_ATMO("%s:enter!\n", __FUNCTION__);
|
|
//update tmo data in manual mode
|
if (pAtmoCtx->tmoAttr.stManual.bUpdateTmo == true)
|
{
|
pAtmoCtx->AtmoConfig.bTmoEn = pAtmoCtx->tmoAttr.stManual.stTmoManual.Enable;
|
pAtmoCtx->AtmoConfig.isLinearTmo = pAtmoCtx->AtmoConfig.bTmoEn && pAtmoCtx->FrameNumber == 1;
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight = pAtmoCtx->tmoAttr.stManual.stTmoManual.stDtlsLL * DETAILSLOWLIGHTMIN ;
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsLowLight
|
, DETAILSLOWLIGHTMAX, DETAILSLOWLIGHTMIN);
|
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight = pAtmoCtx->tmoAttr.stManual.stTmoManual.stDtlsHL * DETAILSHIGHLIGHTMAX ;
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsHighLight
|
, DETAILSHIGHLIGHTMAX, DETAILSHIGHLIGHTMIN);
|
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength = pAtmoCtx->tmoAttr.stManual.stTmoManual.stLocalTMOStrength * TMOCONTRASTMAX;
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.LocalTmoStrength
|
, TMOCONTRASTMAX, TMOCONTRASTMIN);
|
|
pAtmoCtx->CurrData.HandleData.GlobeLuma = pAtmoCtx->tmoAttr.stManual.stTmoManual.stGlobeLuma * GLOBELUMAMAX;
|
pAtmoCtx->CurrData.HandleData.GlobeLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeLuma
|
, GLOBELUMAMAX, GLOBELUMAMIN);
|
|
float GlobeLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma;
|
pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = MAXLUMAK * GlobeLuma + MAXLUMAB;
|
pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
|
GLOBEMAXLUMAMAX, GLOBEMAXLUMAMIN);
|
|
pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = LIMIT_VALUE(pAtmoCtx->tmoAttr.stManual.stTmoManual.stGlobalTMOStrength,
|
1, 0);
|
|
pAtmoCtx->CurrData.CtrlData.TmoDamp = pAtmoCtx->tmoAttr.stManual.stTmoManual.damp;
|
|
}
|
else
|
ApiOffProcess(pAtmoCtx);
|
|
//paras after updating
|
LOGD_ATMO("%s: Current GlobeLuma:%f GlobeMaxLuma:%f DetailsHighLight:%f DetailsLowLight:%f GlobalTmoStrength:%f LocalTmoStrength:%f\n", __FUNCTION__,
|
pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight, pAtmoCtx->CurrData.HandleData.DetailsLowLight,
|
pAtmoCtx->CurrData.HandleData.GlobalTmoStrength, pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* newMalloc()
|
***************************************************************************/
|
void newMalloc
|
(
|
AtmoConfig_t* pAtmoConfig,
|
CalibDbV2_tmo_t* pCalibDb
|
) {
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
// initial checks
|
DCT_ASSERT(pAtmoConfig != NULL);
|
DCT_ASSERT(pCalibDb != NULL);
|
|
if(pAtmoConfig->Luma.len != pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len) {
|
free(pAtmoConfig->Luma.EnvLv);
|
free(pAtmoConfig->Luma.ISO);
|
free(pAtmoConfig->Luma.GlobeLuma);
|
pAtmoConfig->Luma.len = pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
|
pAtmoConfig->Luma.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len));
|
pAtmoConfig->Luma.ISO = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO_len));
|
pAtmoConfig->Luma.GlobeLuma = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength_len));
|
}
|
if(pAtmoConfig->DtsHiLit.len != pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len) {
|
free(pAtmoConfig->DtsHiLit.OEPdf);
|
free(pAtmoConfig->DtsHiLit.EnvLv);
|
free(pAtmoConfig->DtsHiLit.DetailsHighLight);
|
pAtmoConfig->DtsHiLit.len = pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len;
|
pAtmoConfig->DtsHiLit.OEPdf = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len));
|
pAtmoConfig->DtsHiLit.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv_len));
|
pAtmoConfig->DtsHiLit.DetailsHighLight = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.Strength_len));
|
}
|
if(pAtmoConfig->DtsLoLit.len != pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len) {
|
free(pAtmoConfig->DtsLoLit.FocusLuma);
|
free(pAtmoConfig->DtsLoLit.DarkPdf);
|
free(pAtmoConfig->DtsLoLit.ISO);
|
free(pAtmoConfig->DtsLoLit.DetailsLowLight);
|
pAtmoConfig->DtsLoLit.len = pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len;
|
pAtmoConfig->DtsLoLit.FocusLuma = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len));
|
pAtmoConfig->DtsLoLit.DarkPdf = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf_len));
|
pAtmoConfig->DtsLoLit.ISO = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.ISO_len));
|
pAtmoConfig->DtsLoLit.DetailsLowLight = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.Strength_len));
|
}
|
if(pAtmoConfig->local.len != pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len) {
|
free(pAtmoConfig->local.DynamicRange);
|
free(pAtmoConfig->local.EnvLv);
|
free(pAtmoConfig->local.LocalTmoStrength);
|
pAtmoConfig->local.len = pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len;
|
pAtmoConfig->local.DynamicRange = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len));
|
pAtmoConfig->local.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv_len));
|
pAtmoConfig->local.LocalTmoStrength = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.Strength_len));
|
|
}
|
if(pAtmoConfig->global.len != pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len) {
|
free(pAtmoConfig->global.DynamicRange);
|
free(pAtmoConfig->global.EnvLv);
|
free(pAtmoConfig->global.GlobalTmoStrength);
|
pAtmoConfig->global.len = pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len;
|
pAtmoConfig->global.DynamicRange = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len));
|
pAtmoConfig->global.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv_len));
|
pAtmoConfig->global.GlobalTmoStrength = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength_len));
|
}
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* AtmoUpdateConfig()
|
*transfer html parameter into handle
|
***************************************************************************/
|
void AtmoUpdateConfig
|
(
|
AtmoHandle_t pAtmoCtx,
|
CalibDbV2_tmo_t* pCalibDb
|
) {
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
// initial checks
|
DCT_ASSERT(pAtmoCtx != NULL);
|
DCT_ASSERT(pCalibDb != NULL);
|
|
pAtmoCtx->AtmoConfig.Luma.globalLumaMode = pCalibDb->TmoTuningPara.GlobalLuma.Mode;
|
pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode = pCalibDb->TmoTuningPara.DetailsLowLight.Mode;
|
pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode = pCalibDb->TmoTuningPara.DetailsHighLight.Mode;
|
pAtmoCtx->AtmoConfig.local.localtmoMode = pCalibDb->TmoTuningPara.LocalTMO.Mode;
|
pAtmoCtx->AtmoConfig.damp = LIMIT_VALUE(pCalibDb->TmoTuningPara.damp, DAMPMAX, DAMPMIN);
|
pAtmoCtx->AtmoConfig.Luma.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobalLuma.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
|
pAtmoCtx->AtmoConfig.DtsHiLit.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsHighLight.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
|
pAtmoCtx->AtmoConfig.DtsLoLit.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
|
pAtmoCtx->AtmoConfig.local.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.LocalTMO.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.Luma.len; i++) {
|
pAtmoCtx->AtmoConfig.Luma.EnvLv[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv[i], ENVLVMAX, ENVLVMIN);
|
pAtmoCtx->AtmoConfig.Luma.ISO[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO[i], ISOMAX, ISOMIN);
|
pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength[i], IQPARAMAX, IQPARAMIN) ;
|
}
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsHiLit.len; i++) {
|
pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf[i], OEPDFMAX, OEPDFMIN) ;
|
pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv[i], ENVLVMAX, ENVLVMIN);
|
pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.Strength[i], IQPARAMAX, IQPARAMIN) ;
|
}
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsLoLit.len; i++) {
|
pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma[i], FOCUSLUMAMAX, FOCUSLUMAMIN) ;
|
pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf[i], DARKPDFMAX, DARKPDFMIN) ;
|
pAtmoCtx->AtmoConfig.DtsLoLit.ISO[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.ISO[i], ISOMAX, ISOMIN) ;
|
pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.Strength[i], IQDETAILSLOWLIGHTMAX, IQDETAILSLOWLIGHTMIN) ;
|
}
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.local.len; i++) {
|
pAtmoCtx->AtmoConfig.local.DynamicRange[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange[i], DYNAMICRANGEMAX, DYNAMICRANGEMIN) ;
|
pAtmoCtx->AtmoConfig.local.EnvLv[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv[i], ENVLVMAX, ENVLVMIN) ;
|
pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.Strength[i], IQPARAMAX, IQPARAMIN) ;
|
}
|
|
//Global Tmo
|
pAtmoCtx->AtmoConfig.global.isHdrGlobalTmo = pCalibDb->TmoTuningPara.GlobaTMO.Enable;
|
pAtmoCtx->AtmoConfig.global.mode = pCalibDb->TmoTuningPara.GlobaTMO.Mode;
|
pAtmoCtx->AtmoConfig.global.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.global.len; i++) {
|
pAtmoCtx->AtmoConfig.global.DynamicRange[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange[i], DYNAMICRANGEMAX, DYNAMICRANGEMIN) ;
|
pAtmoCtx->AtmoConfig.global.EnvLv[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv[i], ENVLVMAX, ENVLVMIN) ;
|
pAtmoCtx->AtmoConfig.global.GlobalTmoStrength[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength[i], IQPARAMAX, IQPARAMIN) ;
|
}
|
pAtmoCtx->AtmoConfig.global.iir = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.IIR, IIRMAX, IIRMIN);
|
|
//tmo En
|
if(pAtmoCtx->FrameNumber == 2 || pAtmoCtx->FrameNumber == 3) {
|
pAtmoCtx->AtmoConfig.bTmoEn = true;
|
pAtmoCtx->AtmoConfig.isLinearTmo = false;
|
}
|
else if(pAtmoCtx->FrameNumber == 1)
|
{
|
pAtmoCtx->AtmoConfig.bTmoEn = pCalibDb->TmoTuningPara.Enable;
|
pAtmoCtx->AtmoConfig.isLinearTmo = pAtmoCtx->AtmoConfig.bTmoEn;
|
}
|
|
|
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.Luma.len; i++)
|
LOG1_ATMO("%s: mode:%d Globalluma[%d]:%f EnvLv[%d]:%f ISO[%d]:%f Tolerance:%f\n", __FUNCTION__,
|
pAtmoCtx->AtmoConfig.Luma.globalLumaMode, i, pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i],
|
i, pAtmoCtx->AtmoConfig.Luma.EnvLv[i], i, pAtmoCtx->AtmoConfig.Luma.ISO[i], pAtmoCtx->AtmoConfig.Luma.Tolerance);
|
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsHiLit.len; i++)
|
LOG1_ATMO("%s: mode:%d DetailsHighLight[%d]:%f OEPdf[%d]:%f EnvLv[%d]:%f Tolerance:%f\n", __FUNCTION__,
|
pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode, i, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i],
|
i, pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf[i], i, pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv[i], pAtmoCtx->AtmoConfig.DtsHiLit.Tolerance);
|
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsLoLit.len; i++)
|
LOG1_ATMO("%s: mode:%d DetailsLowLight[%d]:%f FocusLuma[%d]:%f DarkPdf[%d]:%f ISO[%d]:%f Tolerance:%f\n", __FUNCTION__,
|
pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode, i, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i],
|
i, pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma[i], i, pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf[i],
|
i, pAtmoCtx->AtmoConfig.DtsLoLit.ISO[i], pAtmoCtx->AtmoConfig.DtsLoLit.Tolerance);
|
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.local.len; i++)
|
LOG1_ATMO("%s: mode:%d LocalTmoStrength[%d]:%f DynamicRange[%d]:%f EnvLv[%d]:%f Tolerance:%f\n", __FUNCTION__,
|
pAtmoCtx->AtmoConfig.local.localtmoMode, i, pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i],
|
i, pAtmoCtx->AtmoConfig.local.DynamicRange[i], i, pAtmoCtx->AtmoConfig.local.EnvLv[i], pAtmoCtx->AtmoConfig.local.Tolerance);
|
|
LOGD_ATMO("%s: Tmo En:%d linear Tmo en:%d\n", __FUNCTION__, pAtmoCtx->AtmoConfig.bTmoEn, pAtmoCtx->AtmoConfig.isLinearTmo);
|
LOG1_ATMO("%s: GlobalTmo En:%d IIR:%f\n", __FUNCTION__, pCalibDb->TmoTuningPara.GlobaTMO.Enable, pAtmoCtx->AtmoConfig.global.iir);
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.global.len; i++)
|
LOG1_ATMO("%s: mode:%d GlobalTmoStrength[%d]:%f DynamicRange[%d]:%f EnvLv[%d]:%f Tolerance:%f\n", __FUNCTION__,
|
pAtmoCtx->AtmoConfig.global.mode, i, pAtmoCtx->AtmoConfig.global.GlobalTmoStrength[i],
|
i, pAtmoCtx->AtmoConfig.global.DynamicRange[i], i, pAtmoCtx->AtmoConfig.global.EnvLv[i], pAtmoCtx->AtmoConfig.global.Tolerance);
|
|
//turn the IQ paras into algo paras
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.Luma.len; i++) {
|
pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i] = pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i] * GLOBELUMAMAX;
|
pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i] = LIMIT_VALUE(pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i], GLOBELUMAMAX, GLOBELUMAMIN) ;
|
}
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsHiLit.len; i++) {
|
pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i] = pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i] * DETAILSHIGHLIGHTMAX;
|
pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i] = LIMIT_VALUE(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i], DETAILSHIGHLIGHTMAX, DETAILSHIGHLIGHTMIN) ;
|
}
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsLoLit.len; i++) {
|
pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i] = pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i] * DETAILSLOWLIGHTMIN;
|
pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i] = LIMIT_VALUE(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i], DETAILSLOWLIGHTMAX, DETAILSLOWLIGHTMIN) ;
|
}
|
for(int i = 0; i < pAtmoCtx->AtmoConfig.local.len; i++) {
|
pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i] = pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i] * TMOCONTRASTMAX;
|
pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i] = LIMIT_VALUE(pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i], TMOCONTRASTMAX, TMOCONTRASTMIN) ;
|
}
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* GetSetLgmean()
|
*****************************************************************************/
|
unsigned short GetSetLgmean(AtmoHandle_t pAtmoCtx)
|
{
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
float value = 0;
|
float value_default = 20000;
|
unsigned short returnValue;
|
int iir_frame = 0;
|
|
if(pAtmoCtx->AtmoConfig.global.iir < IIRMAX) {
|
iir_frame = (int)(pAtmoCtx->AtmoConfig.global.iir);
|
int iir_frame_real = MIN(pAtmoCtx->frameCnt + 1, iir_frame);
|
|
float PrevLgMean = pAtmoCtx->PrevData.ro_hdrtmo_lgmean / 2048.0;
|
float CurrLgMean = pAtmoCtx->CurrData.CtrlData.LgMean;
|
|
CurrLgMean *= 1 + 0.5 - pAtmoCtx->CurrData.HandleData.GlobalTmoStrength;
|
value_default *= 1 + 0.5 - pAtmoCtx->CurrData.HandleData.GlobalTmoStrength;
|
|
value = pAtmoCtx->frameCnt == 0 ? value_default :
|
(iir_frame_real - 1) * PrevLgMean / iir_frame_real + CurrLgMean / iir_frame_real;
|
returnValue = (int)SHIFT11BIT(value) ;
|
}
|
else
|
returnValue = value_default;
|
|
LOG1_ATMO( "%s: frameCnt:%d iir_frame:%d set_lgmean_float:%f set_lgmean_return:%d\n", __FUNCTION__,
|
pAtmoCtx->frameCnt, iir_frame, value, returnValue);
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
|
return returnValue;
|
}
|
/******************************************************************************
|
* GetSetLgAvgMax()
|
*****************************************************************************/
|
unsigned short GetSetLgAvgMax(AtmoHandle_t pAtmoCtx, float set_lgmin, float set_lgmax)
|
{
|
LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
|
float WeightKey = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_weightkey / 256.0;
|
float value = 0.0;
|
float set_lgmean = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean / 2048.0;
|
float lgrange1 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange1 / 2048.0;
|
unsigned short returnValue;
|
|
value = WeightKey * set_lgmax + (1 - WeightKey) * set_lgmean;
|
value = MIN(value, lgrange1);
|
returnValue = (int)SHIFT11BIT(value);
|
|
LOG1_ATMO( "%s: set_lgmin:%f set_lgmax:%f set_lgmean:%f lgrange1:%f value:%f returnValue:%d\n", __FUNCTION__, set_lgmin, set_lgmax, set_lgmean, lgrange1, value, returnValue);
|
|
return returnValue;
|
LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
|
|
}
|
/******************************************************************************
|
* GetSetLgRange0()
|
*****************************************************************************/
|
unsigned short GetSetLgRange0(AtmoHandle_t pAtmoCtx, float set_lgmin, float set_lgmax)
|
{
|
LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
|
float value = 0.0;
|
float clipratio0 = (float)(pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio0) / 256.0;
|
float clipgap0 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap0 / 4.0;
|
unsigned short returnValue;
|
|
|
value = set_lgmin * (1 - clipratio0) + set_lgmax * clipratio0;
|
value = MIN(value, (set_lgmin + clipgap0));
|
returnValue = (int)SHIFT11BIT(value);
|
|
LOG1_ATMO( "%s: set_lgmin:%f set_lgmax:%f clipratio0:%f clipgap0:%f value:%f returnValue:%d\n", __FUNCTION__, set_lgmin, set_lgmax, clipratio0, clipgap0, value, returnValue);
|
|
return returnValue;
|
LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
|
|
}
|
/******************************************************************************
|
* GetSetLgRange1()
|
*****************************************************************************/
|
unsigned short GetSetLgRange1(AtmoHandle_t pAtmoCtx, float set_lgmin, float set_lgmax)
|
{
|
LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
|
float value = 0.0;
|
float clipratio1 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio1 / 256.0;
|
float clipgap1 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap1 / 4.0;
|
unsigned short returnValue;
|
|
value = set_lgmin * (1 - clipratio1) + set_lgmax * clipratio1;
|
value = MAX(value, (set_lgmax - clipgap1));
|
returnValue = (int)SHIFT11BIT(value);
|
|
LOG1_ATMO( "%s: set_lgmin:%f set_lgmax:%f clipratio1:%f clipgap1:%f value:%f returnValue:%d\n", __FUNCTION__, set_lgmin, set_lgmax, clipratio1, clipgap1, value, returnValue);
|
|
return returnValue;
|
LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
|
|
}
|
/******************************************************************************
|
* GetSetPalhpa()
|
*****************************************************************************/
|
unsigned short GetSetPalhpa(AtmoHandle_t pAtmoCtx, float set_lgmin, float set_lgmax)
|
{
|
LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
|
|
float index = 0.0;
|
float value = 0.0;
|
float set_lgmean = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean / 2048.0;
|
float palpha_0p18 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_0p18 / 1024.0;
|
int value_int = 0;
|
unsigned short returnValue;
|
|
index = 2 * set_lgmean - set_lgmin - set_lgmax;
|
index = index / (set_lgmax - set_lgmin);
|
value = palpha_0p18 * pow(4, index);
|
value_int = (int)SHIFT10BIT(value);
|
value_int = MIN(value_int, pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxpalpha);
|
returnValue = value_int;
|
|
LOG1_ATMO( "%s: set_lgmin:%f set_lgmax:%f set_lgmean:%f palpha_0p18:%f value:%f returnValue:%d\n", __FUNCTION__, set_lgmin, set_lgmax, set_lgmean, palpha_0p18, value, returnValue);
|
|
return returnValue;
|
LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
|
|
}
|
|
/******************************************************************************
|
* GetCurrIOData()
|
*****************************************************************************/
|
void TmoGetCurrIOData
|
(
|
AtmoHandle_t pAtmoCtx
|
)
|
{
|
LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
|
|
//default IO data
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio0 = 64;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio1 = 166;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap0 = 12;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap1 = 12;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_ratiol = 32;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_high = (int)(pAtmoCtx->height * pAtmoCtx->width * 0.01 / 16);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_min = 0;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_low = 0;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_0p3 = 0;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_shift = 3;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_gain_ld_off1 = 10;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_gain_ld_off2 = 5;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_newhist_en = 1;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_mode = 1;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_vsize = (int)(pAtmoCtx->height - 256);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_cfg_alpha = 255;
|
|
//IO data from IQ
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxpalpha = (int)(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma + 0.5);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_0p18 = (int)(pAtmoCtx->CurrData.HandleData.GlobeLuma + 0.5);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_lw0p5 = (int)(pAtmoCtx->CurrData.HandleData.DetailsHighLight + 0.5);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_weightkey = (int)(pAtmoCtx->CurrData.HandleData.LocalTmoStrength + 0.5);
|
|
float lwscl = pAtmoCtx->CurrData.HandleData.DetailsLowLight;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_lwscl = (int)(lwscl + 0.5);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxgain = (int)(SHIFT12BIT(lwscl / 16) + 0.5);
|
|
|
//calc other IO data
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_big_en = pAtmoCtx->width > BIGMODE ? 1 : 0;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_nobig_en = (int)(1 - pAtmoCtx->ProcRes.Res.sw_hdrtmo_big_en);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_expl_lgratio = (int)SHIFT11BIT(log(pAtmoCtx->PrevData.CtrlData.LExpo / pAtmoCtx->CurrData.CtrlData.LExpo) / log(2));
|
if(pAtmoCtx->AtmoConfig.isLinearTmo)
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_ratio = 128;
|
else
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_ratio = (int)SHIFT7BIT(log(pAtmoCtx->CurrData.CtrlData.L2S_Ratio) / log(pAtmoCtx->PrevData.CtrlData.L2S_ratio));
|
float lgmax = 12 + log(pAtmoCtx->CurrData.CtrlData.L2S_Ratio) / log(2);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgmax = (int)SHIFT11BIT(lgmax);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl = (int)SHIFT12BIT(16 / lgmax);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_inv = (int)SHIFT12BIT(lgmax / 16);
|
float set_lgmin = 0;
|
float set_lgmax = lgmax;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmin = (int)SHIFT11BIT(set_lgmin) ;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmax = pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgmax;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_gainoff = pow(2, set_lgmin);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean = GetSetLgmean(pAtmoCtx);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange0 = GetSetLgRange0(pAtmoCtx, set_lgmin, set_lgmax);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange1 = GetSetLgRange1(pAtmoCtx, set_lgmin, set_lgmax);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgavgmax = GetSetLgAvgMax(pAtmoCtx, set_lgmin, set_lgmax);
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_palpha = GetSetPalhpa(pAtmoCtx, set_lgmin, set_lgmax);
|
|
|
//for avoid tmo flicker
|
pAtmoCtx->ProcRes.TmoFlicker.cnt_mode = pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_mode;
|
pAtmoCtx->ProcRes.TmoFlicker.cnt_vsize = pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_vsize;
|
if(pAtmoCtx->CurrData.HandleData.GlobalTmoStrength > 0.5)
|
pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrengthDown = false;
|
else
|
pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrengthDown = true;
|
pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength = pAtmoCtx->CurrData.HandleData.GlobalTmoStrength - 0.5;
|
pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength = pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength < 0 ? (1 - pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength)
|
: (1 + pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength);
|
pAtmoCtx->ProcRes.TmoFlicker.iir = (int)(pAtmoCtx->AtmoConfig.global.iir) +
|
3 * pAtmoCtx->CurrAeResult.AecDelayframe;
|
pAtmoCtx->ProcRes.TmoFlicker.iirmax = IIRMAX;
|
pAtmoCtx->ProcRes.TmoFlicker.height = pAtmoCtx->height;
|
pAtmoCtx->ProcRes.TmoFlicker.width = pAtmoCtx->width;
|
pAtmoCtx->ProcRes.TmoFlicker.PredictK.correction_factor = 1.05;
|
pAtmoCtx->ProcRes.TmoFlicker.PredictK.correction_offset = 0;
|
pAtmoCtx->ProcRes.TmoFlicker.PredictK.Hdr3xLongPercent = 0.5;
|
pAtmoCtx->ProcRes.TmoFlicker.PredictK.UseLongLowTh = 1.02;
|
pAtmoCtx->ProcRes.TmoFlicker.PredictK.UseLongUpTh = 0.98;
|
if(pAtmoCtx->FrameNumber == 1)
|
pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[0] = pAtmoCtx->CurrAeResult.LumaDeviationLinear;
|
else if(pAtmoCtx->FrameNumber == 2) {
|
pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[0] = pAtmoCtx->CurrAeResult.LumaDeviationS;
|
pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[1] = pAtmoCtx->CurrAeResult.LumaDeviationL;
|
}
|
else if(pAtmoCtx->FrameNumber == 3) {
|
pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[0] = pAtmoCtx->CurrAeResult.LumaDeviationS;
|
pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[1] = pAtmoCtx->CurrAeResult.LumaDeviationM;
|
pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[2] = pAtmoCtx->CurrAeResult.LumaDeviationL;
|
}
|
pAtmoCtx->ProcRes.TmoFlicker.StableThr = 0.1;
|
|
LOGV_ATMO("%s: Tmo set IOdata to register:\n", __FUNCTION__);
|
LOGV_ATMO("%s: float lgmax:%f\n", __FUNCTION__, lgmax);
|
LOGV_ATMO("%s: sw_hdrtmo_lgmax:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgmax);
|
LOGV_ATMO("%s: sw_hdrtmo_lgscl:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl);
|
LOGV_ATMO("%s: sw_hdrtmo_lgscl_inv:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_inv);
|
LOGV_ATMO("%s: sw_hdrtmo_clipratio0:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio0);
|
LOGV_ATMO("%s: sw_hdrtmo_clipratio1:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio1);
|
LOGV_ATMO("%s: sw_hdrtmo_clipgap0:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap0);
|
LOGV_ATMO("%s: sw_hdrtmo_clipgap:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap1);
|
LOGV_ATMO("%s: sw_hdrtmo_ratiol:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_ratiol);
|
LOGV_ATMO("%s: sw_hdrtmo_hist_min:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_min);
|
LOGV_ATMO("%s: sw_hdrtmo_hist_low:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_low);
|
LOGV_ATMO("%s: sw_hdrtmo_hist_high:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_high);
|
LOGV_ATMO("%s: sw_hdrtmo_hist_0p3:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_0p3);
|
LOGV_ATMO("%s: sw_hdrtmo_hist_shift:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_shift);
|
LOGV_ATMO("%s: sw_hdrtmo_palpha_0p18:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_0p18);
|
LOGV_ATMO("%s: sw_hdrtmo_palpha_lw0p5:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_lw0p5);
|
LOGV_ATMO("%s: sw_hdrtmo_palpha_lwscl:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_lwscl);
|
LOGV_ATMO("%s: sw_hdrtmo_maxpalpha:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxpalpha);
|
LOGV_ATMO("%s: sw_hdrtmo_maxgain:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxgain);
|
LOGV_ATMO("%s: sw_hdrtmo_cfg_alpha:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_cfg_alpha);
|
LOGV_ATMO("%s: sw_hdrtmo_set_gainoff:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_gainoff);
|
LOGV_ATMO("%s: sw_hdrtmo_set_lgmin:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmin);
|
LOGV_ATMO("%s: sw_hdrtmo_set_lgmax:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmax);
|
LOGV_ATMO("%s: sw_hdrtmo_set_lgmean:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean);
|
LOGV_ATMO("%s: sw_hdrtmo_set_weightkey:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_weightkey);
|
LOGV_ATMO("%s: sw_hdrtmo_set_lgrange0:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange0);
|
LOGV_ATMO("%s: sw_hdrtmo_set_lgrange1:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange1);
|
LOGV_ATMO("%s: sw_hdrtmo_set_lgavgmax:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgavgmax);
|
LOGV_ATMO("%s: sw_hdrtmo_set_palpha:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_palpha);
|
LOGV_ATMO("%s: sw_hdrtmo_big_en:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_big_en);
|
LOGV_ATMO("%s: sw_hdrtmo_nobig_en:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_nobig_en);
|
LOGV_ATMO("%s: sw_hdrtmo_newhist_en:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_newhist_en);
|
LOGV_ATMO("%s: sw_hdrtmo_cnt_mode:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_mode);
|
LOGV_ATMO("%s: sw_hdrtmo_cnt_vsize:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_vsize);
|
LOGV_ATMO("%s: sw_hdrtmo_expl_lgratio:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_expl_lgratio);
|
LOGV_ATMO("%s: sw_hdrtmo_lgscl_ratio:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_ratio);
|
LOGV_ATMO("%s: sw_hdrtmo_gain_ld_off1:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_gain_ld_off1);
|
LOGV_ATMO("%s: sw_hdrtmo_gain_ld_off2:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_gain_ld_off2);
|
LOGV_ATMO("%s: LumaDeviation:%f %f %f\n", __FUNCTION__, pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[0],
|
pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[1], pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[2]);
|
|
LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* TmoDamp()
|
*****************************************************************************/
|
void TmoDamp
|
(
|
AtmoHandle_t pAtmoCtx
|
)
|
{
|
LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
|
float tmo_damp = pAtmoCtx->CurrData.CtrlData.TmoDamp;
|
|
bool enDampLuma;
|
bool enDampDtlsHighLgt;
|
bool enDampDtlslowLgt;
|
bool enDampLocal;
|
bool enDampGlobal;
|
bool ifHDRModeChange = pAtmoCtx->CurrData.CtrlData.FrameCnt == pAtmoCtx->PrevData.CtrlData.FrameCnt ? false : true;
|
|
if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_API_OFF && pAtmoCtx->frameCnt != 0 && !ifHDRModeChange)
|
{
|
float diff = 0;
|
|
if(pAtmoCtx->AtmoConfig.Luma.globalLumaMode == GLOBALLUMAMODE_ENVLV)
|
{
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.EnvLv - pAtmoCtx->PrevData.CtrlData.EnvLv);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.EnvLv;
|
}
|
else if(pAtmoCtx->AtmoConfig.Luma.globalLumaMode == GLOBALLUMAMODE_ISO)
|
{
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.ISO - pAtmoCtx->PrevData.CtrlData.ISO);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.ISO;
|
}
|
if (diff < pAtmoCtx->AtmoConfig.Luma.Tolerance)
|
enDampLuma = false;
|
else
|
enDampLuma = true;
|
|
if(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode == DETAILSHIGHLIGHTMODE_OEPDF)
|
{
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.OEPdf - pAtmoCtx->PrevData.CtrlData.OEPdf);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.OEPdf;
|
}
|
else if(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode == DETAILSHIGHLIGHTMODE_ENVLV)
|
{
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.EnvLv - pAtmoCtx->PrevData.CtrlData.EnvLv);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.EnvLv;
|
}
|
if (diff < pAtmoCtx->AtmoConfig.DtsHiLit.Tolerance)
|
enDampDtlsHighLgt = false;
|
else
|
enDampDtlsHighLgt = true;
|
|
if(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_FOCUSLUMA)
|
{
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.FocusLuma - pAtmoCtx->PrevData.CtrlData.FocusLuma);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.FocusLuma;
|
}
|
else if(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_DARKPDF)
|
{
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.DarkPdf - pAtmoCtx->PrevData.CtrlData.DarkPdf);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.DarkPdf;
|
}
|
else if(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_ISO)
|
{
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.ISO - pAtmoCtx->PrevData.CtrlData.ISO);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.ISO;
|
}
|
if (diff < pAtmoCtx->AtmoConfig.DtsLoLit.Tolerance)
|
enDampDtlslowLgt = false;
|
else
|
enDampDtlslowLgt = true;
|
|
if(pAtmoCtx->AtmoConfig.local.localtmoMode == TMOTYPEMODE_DYNAMICRANGE) {
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.DynamicRange - pAtmoCtx->PrevData.CtrlData.DynamicRange);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.DynamicRange;
|
}
|
else if(pAtmoCtx->AtmoConfig.local.localtmoMode == TMOTYPEMODE_ENVLV)
|
{
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.EnvLv - pAtmoCtx->PrevData.CtrlData.EnvLv);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.EnvLv;
|
}
|
if (diff < pAtmoCtx->AtmoConfig.local.Tolerance)
|
enDampLocal = false;
|
else
|
enDampLocal = true;
|
|
if(pAtmoCtx->AtmoConfig.global.mode == TMOTYPEMODE_DYNAMICRANGE) {
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.DynamicRange - pAtmoCtx->PrevData.CtrlData.DynamicRange);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.DynamicRange;
|
}
|
else if(pAtmoCtx->AtmoConfig.global.mode == TMOTYPEMODE_ENVLV)
|
{
|
diff = ABS(pAtmoCtx->CurrData.CtrlData.EnvLv - pAtmoCtx->PrevData.CtrlData.EnvLv);
|
diff = diff / pAtmoCtx->PrevData.CtrlData.EnvLv;
|
}
|
if (diff < pAtmoCtx->AtmoConfig.global.Tolerance)
|
enDampGlobal = false;
|
else
|
enDampGlobal = true;
|
|
|
//get finnal cfg data by damp
|
if (enDampLuma == true)
|
{
|
pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = tmo_damp * pAtmoCtx->CurrData.HandleData.GlobeMaxLuma
|
+ (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.GlobeMaxLuma;
|
pAtmoCtx->CurrData.HandleData.GlobeLuma = tmo_damp * pAtmoCtx->CurrData.HandleData.GlobeLuma
|
+ (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.GlobeLuma;
|
}
|
|
if (enDampDtlsHighLgt == true)
|
pAtmoCtx->CurrData.HandleData.DetailsHighLight = tmo_damp * pAtmoCtx->CurrData.HandleData.DetailsHighLight
|
+ (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.DetailsHighLight;
|
|
if (enDampDtlslowLgt == true)
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight = tmo_damp * pAtmoCtx->CurrData.HandleData.DetailsLowLight
|
+ (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.DetailsLowLight;
|
|
if (enDampLocal == true)
|
pAtmoCtx->CurrData.HandleData.LocalTmoStrength = tmo_damp * pAtmoCtx->CurrData.HandleData.LocalTmoStrength
|
+ (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.LocalTmoStrength;
|
|
if (enDampGlobal == true)
|
pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = tmo_damp * pAtmoCtx->CurrData.HandleData.GlobalTmoStrength
|
+ (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.GlobalTmoStrength;
|
|
}
|
|
LOGD_ATMO("%s:Current damp GlobeLuma:%f GlobeMaxLuma:%f DetailsHighLight:%f DetailsLowLight:%f LocalTmoStrength:%f GlobalTmoStrength:%f\n", __FUNCTION__, pAtmoCtx->CurrData.HandleData.GlobeLuma
|
, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma, pAtmoCtx->CurrData.HandleData.DetailsHighLight, pAtmoCtx->CurrData.HandleData.DetailsLowLight
|
, pAtmoCtx->CurrData.HandleData.LocalTmoStrength, pAtmoCtx->CurrData.HandleData.GlobalTmoStrength);
|
|
LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
|
}
|
/******************************************************************************
|
* SetGlobalTMO()
|
*****************************************************************************/
|
bool SetGlobalTMO
|
(
|
AtmoHandle_t pAtmoCtx
|
) {
|
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
bool returnValue = false;
|
|
if(pAtmoCtx->AtmoConfig.global.isHdrGlobalTmo == true) {
|
returnValue = true;
|
pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_weightkey = 0;
|
}
|
|
else
|
returnValue = false;
|
|
LOGD_ATMO("%s: set GlobalTMO:%d\n", __FUNCTION__, returnValue);
|
|
return returnValue;
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* AhdrGetProcRes()
|
*****************************************************************************/
|
void AtmoGetProcRes
|
(
|
AtmoHandle_t pAtmoCtx
|
) {
|
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
|
//tmo para damp
|
TmoDamp(pAtmoCtx);
|
|
//tmo enable
|
pAtmoCtx->ProcRes.bTmoEn = pAtmoCtx->AtmoConfig.bTmoEn;
|
pAtmoCtx->ProcRes.isLinearTmo = pAtmoCtx->AtmoConfig.isLinearTmo;
|
|
//get tmo proc res
|
TmoGetCurrIOData(pAtmoCtx);
|
|
// Set Global TMO
|
pAtmoCtx->ProcRes.isHdrGlobalTmo = SetGlobalTMO(pAtmoCtx);
|
|
// store current handle data to pre data for next loop
|
pAtmoCtx->PrevData.HandleData.MergeMode = pAtmoCtx->CurrData.HandleData.MergeMode;
|
pAtmoCtx->PrevData.ro_hdrtmo_lgmean = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean;
|
pAtmoCtx->PrevData.CtrlData.L2S_ratio = pAtmoCtx->CurrData.CtrlData.L2S_Ratio;
|
pAtmoCtx->PrevData.CtrlData.LExpo = pAtmoCtx->CurrData.CtrlData.LExpo;
|
pAtmoCtx->PrevData.CtrlData.EnvLv = pAtmoCtx->CurrData.CtrlData.EnvLv;
|
pAtmoCtx->PrevData.CtrlData.OEPdf = pAtmoCtx->CurrData.CtrlData.OEPdf;
|
pAtmoCtx->PrevData.CtrlData.FocusLuma = pAtmoCtx->CurrData.CtrlData.FocusLuma;
|
pAtmoCtx->PrevData.CtrlData.DarkPdf = pAtmoCtx->CurrData.CtrlData.DarkPdf;
|
pAtmoCtx->PrevData.CtrlData.ISO = pAtmoCtx->CurrData.CtrlData.ISO;
|
pAtmoCtx->PrevData.CtrlData.DynamicRange = pAtmoCtx->CurrData.CtrlData.DynamicRange;
|
memcpy(&pAtmoCtx->PrevData.HandleData, &pAtmoCtx->CurrData.HandleData, sizeof(TmoHandleData_s));
|
++pAtmoCtx->frameCnt;
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* AtmoProcessing()
|
*get handle para by config and current variate
|
*****************************************************************************/
|
void AtmoProcessing
|
(
|
AtmoHandle_t pAtmoCtx,
|
AecPreResult_t AecHdrPreResult,
|
af_preprocess_result_t AfPreResult
|
)
|
{
|
LOG1_ATMO("%s:enter!\n", __FUNCTION__);
|
LOGD_ATMO("%s: Atmo Current frame cnt:%d:\n", __FUNCTION__, pAtmoCtx->frameCnt);
|
pAtmoCtx->CurrData.CtrlData.FrameCnt = pAtmoCtx->frameCnt;
|
|
//get current ae data from AecPreRes
|
AtmoGetAeResult(pAtmoCtx, AecHdrPreResult);
|
|
//transfer ae data to CurrHandle
|
pAtmoCtx->CurrData.CtrlData.EnvLv = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.EnvLv, ENVLVMAX, ENVLVMIN);
|
|
pAtmoCtx->CurrData.CtrlData.ISO = pAtmoCtx->CurrAeResult.ISO;
|
pAtmoCtx->CurrData.CtrlData.ISO = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.ISO, ISOMAX, ISOMIN);
|
|
pAtmoCtx->CurrData.CtrlData.OEPdf = pAtmoCtx->CurrAeResult.OEPdf;
|
pAtmoCtx->CurrData.CtrlData.OEPdf = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.OEPdf, OEPDFMAX, OEPDFMIN);
|
|
pAtmoCtx->CurrData.CtrlData.FocusLuma = 1;
|
pAtmoCtx->CurrData.CtrlData.FocusLuma = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.FocusLuma, FOCUSLUMAMAX, FOCUSLUMAMIN);
|
|
pAtmoCtx->CurrData.CtrlData.DarkPdf = pAtmoCtx->CurrAeResult.DarkPdf;
|
pAtmoCtx->CurrData.CtrlData.DarkPdf = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.DarkPdf, DARKPDFTHMAX, DARKPDFTHMIN);
|
|
pAtmoCtx->CurrData.CtrlData.DynamicRange = pAtmoCtx->CurrAeResult.DynamicRange;
|
pAtmoCtx->CurrData.CtrlData.DynamicRange = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.DynamicRange, DYNAMICRANGEMAX, DYNAMICRANGEMIN);
|
|
if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_API_OFF) {
|
LOGD_ATMO("%s: Atmo api OFF!! Current Handle data:\n", __FUNCTION__);
|
|
ApiOffProcess(pAtmoCtx);
|
|
//log after updating
|
LOGD_ATMO("%s: GlobalLumaMode:%f CtrlData.EnvLv:%f CtrlData.ISO:%f GlobeLuma:%f GlobeMaxLuma:%f \n", __FUNCTION__, pAtmoCtx->AtmoConfig.Luma.globalLumaMode,
|
pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma);
|
LOGD_ATMO("%s: DetailsHighLightMode:%f CtrlData.OEPdf:%f CtrlData.EnvLv:%f DetailsHighLight:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode, pAtmoCtx->CurrData.CtrlData.OEPdf
|
, pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.DetailsHighLight);
|
LOGD_ATMO("%s: DetailsLowLightMode:%f CtrlData.FocusLuma:%f CtrlData.DarkPdf:%f CtrlData.ISO:%f DetailsLowLight:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode,
|
pAtmoCtx->CurrData.CtrlData.FocusLuma, pAtmoCtx->CurrData.CtrlData.DarkPdf, pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.DetailsLowLight);
|
LOGD_ATMO("%s: localtmoMode:%f CtrlData.DynamicRange:%f CtrlData.EnvLv:%f LocalTmoStrength:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.local.localtmoMode, pAtmoCtx->CurrData.CtrlData.DynamicRange,
|
pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
|
LOGD_ATMO("%s: GlobalTMO en:%d mode:%f CtrlData.DynamicRange:%f CtrlData.EnvLv:%f Strength:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.global.isHdrGlobalTmo, pAtmoCtx->AtmoConfig.global.mode, pAtmoCtx->CurrData.CtrlData.DynamicRange,
|
pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.GlobalTmoStrength);
|
|
}
|
else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_AUTO) {
|
LOGD_ATMO("%s: Atmo api Auto!! Current Handle data:\n", __FUNCTION__);
|
AtmoApiAutoUpdate(pAtmoCtx);
|
}
|
else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_MANU) {
|
LOGD_ATMO("%s: Atmo api Manual!! Current Handle data:\n", __FUNCTION__);
|
AtmoApiManualUpdate(pAtmoCtx);
|
}
|
else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_SET_LEVEL) {
|
LOGD_ATMO("%s: Atmo api set level!! Current Handle data:\n", __FUNCTION__);
|
|
ApiOffProcess(pAtmoCtx);
|
AtmoApiSetLevel(pAtmoCtx);
|
}
|
else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_DARKAREA) {
|
LOGD_ATMO("%s: Atmo api DarkArea!! Current Handle data:\n", __FUNCTION__);
|
ApiOffProcess(pAtmoCtx);
|
|
pAtmoCtx->AtmoConfig.bTmoEn = true;
|
pAtmoCtx->AtmoConfig.isLinearTmo = pAtmoCtx->FrameNumber == 1 ? true : false;
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight *= 1 + (float)(pAtmoCtx->tmoAttr.stDarkArea.level) * 0.4;
|
pAtmoCtx->CurrData.HandleData.DetailsLowLight =
|
LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsLowLight, DETAILSLOWLIGHTMAX, DETAILSLOWLIGHTMIN);
|
LOGD_ATMO("%s: Linear TMO en:%d DetailsLowLightMode:%f CtrlData.FocusLuma:%f CtrlData.DarkPdf:%f CtrlData.ISO:%f DetailsLowLight:%f\n", __FUNCTION__, pAtmoCtx->ProcRes.isLinearTmo,
|
pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode, pAtmoCtx->CurrData.CtrlData.FocusLuma, pAtmoCtx->CurrData.CtrlData.DarkPdf,
|
pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.DetailsLowLight);
|
}
|
else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_TOOL) {
|
LOGD_ATMO("%s: Atmo api Tool!! Current Handle data:\n", __FUNCTION__);
|
ApiOffProcess(pAtmoCtx);
|
|
//tmo en
|
pAtmoCtx->AtmoConfig.bTmoEn = pAtmoCtx->AtmoConfig.bTmoEn;
|
pAtmoCtx->AtmoConfig.isLinearTmo = pAtmoCtx->AtmoConfig.bTmoEn && pAtmoCtx->FrameNumber == 1;
|
|
//log after updating
|
LOGD_ATMO("%s: GlobalLumaMode:%f CtrlData.EnvLv:%f CtrlData.ISO:%f GlobeLuma:%f GlobeMaxLuma:%f \n", __FUNCTION__, pAtmoCtx->AtmoConfig.Luma.globalLumaMode,
|
pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma);
|
LOGD_ATMO("%s: DetailsHighLightMode:%f CtrlData.OEPdf:%f CtrlData.EnvLv:%f DetailsHighLight:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode, pAtmoCtx->CurrData.CtrlData.OEPdf
|
, pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.DetailsHighLight);
|
LOGD_ATMO("%s: DetailsLowLightMode:%f CtrlData.FocusLuma:%f CtrlData.DarkPdf:%f CtrlData.ISO:%f DetailsLowLight:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode,
|
pAtmoCtx->CurrData.CtrlData.FocusLuma, pAtmoCtx->CurrData.CtrlData.DarkPdf, pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.DetailsLowLight);
|
LOGD_ATMO("%s: localtmoMode:%f CtrlData.DynamicRange:%f CtrlData.EnvLv:%f LocalTmoStrength:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.local.localtmoMode, pAtmoCtx->CurrData.CtrlData.DynamicRange,
|
pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
|
LOGD_ATMO("%s: GlobalTMO en:%d mode:%f CtrlData.DynamicRange:%f CtrlData.EnvLv:%f Strength:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.global.isHdrGlobalTmo, pAtmoCtx->AtmoConfig.global.mode, pAtmoCtx->CurrData.CtrlData.DynamicRange,
|
pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.GlobalTmoStrength);
|
}
|
else
|
LOGE_ATMO("%s: Atmo wrong mode!!!\n", __FUNCTION__);
|
|
//transfer data to api
|
AtmoTranferData2Api(pAtmoCtx);
|
|
//read current rodata
|
pAtmoCtx->CurrData.CtrlData.LgMean = pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmean / 2048.0;
|
|
//calc the current merge luma
|
float MergeLuma = (float)pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmean;
|
MergeLuma = MergeLuma / 2048.0;
|
float lgmean = MergeLuma;
|
MergeLuma = pow(2, MergeLuma);
|
MergeLuma = MergeLuma / 16;
|
|
//get pre frame tmo mean luma
|
unsigned long tmo_mean = 0;
|
for(int i = 0; i < 225; i++) {
|
tmo_mean += pAtmoCtx->CurrStatsData.other_stats.tmo_luma[i];
|
}
|
tmo_mean = tmo_mean / 225;
|
tmo_mean = tmo_mean / 16;
|
|
//calc short middle long frame mean luma
|
unsigned long short_mean = 0, middle_mean = 0, long_mean = 0;
|
for (int i = 0; i < 225; i++) {
|
short_mean += pAtmoCtx->CurrAeResult.BlockLumaS[i];
|
long_mean += pAtmoCtx->CurrAeResult.BlockLumaL[i];
|
}
|
short_mean = short_mean / 225;
|
long_mean = long_mean / 225;
|
short_mean = short_mean / 16;
|
long_mean = long_mean / 16;
|
|
for(int i = 0; i < 25; i++)
|
middle_mean += pAtmoCtx->CurrAeResult.BlockLumaM[i];
|
middle_mean = middle_mean / 25;
|
middle_mean = middle_mean / 16;
|
|
LOGD_ATMO("%s: preFrame lgMergeLuma:%f MergeLuma(8bit):%f TmoLuma(8bit):%d\n", __FUNCTION__, lgmean, MergeLuma, tmo_mean);
|
LOGD_ATMO("%s: preFrame SLuma(8bit):%d MLuma(8bit):%d LLuma(8bit):%d\n", __FUNCTION__, short_mean, middle_mean, long_mean);
|
|
//get tmo proc res
|
AtmoGetProcRes(pAtmoCtx);
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
}
|
|
/******************************************************************************
|
* AtmoInit()
|
*****************************************************************************/
|
RESULT AtmoInit
|
(
|
AtmoInstanceConfig_t* pInstConfig,
|
CamCalibDbV2Context_t* pCalibV2
|
) {
|
|
AtmoContext_s *pAtmoCtx;
|
|
LOG1_ATMO("%s:enter!\n", __FUNCTION__);
|
|
RESULT result = ATMO_RET_SUCCESS;
|
|
// initial checks
|
if (pInstConfig == NULL)
|
return (ATMO_RET_INVALID_PARM);
|
|
// allocate ATMO control context
|
pAtmoCtx = (AtmoContext_s*)malloc(sizeof(AtmoContext_s));
|
if (NULL == pAtmoCtx) {
|
LOGE_ATMO( "%s: Can't allocate ATMO context\n", __FUNCTION__);
|
return (ATMO_RET_OUTOFMEM);
|
}
|
|
CalibDbV2_tmo_t* calibv2_atmo_calib =
|
(CalibDbV2_tmo_t*)(CALIBDBV2_GET_MODULE_PTR(pCalibV2, atmo_calib));
|
|
// pre-initialize context
|
memset(pAtmoCtx, 0x00, sizeof(*pAtmoCtx));
|
pAtmoCtx->AtmoConfig.Luma.len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
|
pAtmoCtx->AtmoConfig.Luma.EnvLv = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len));
|
pAtmoCtx->AtmoConfig.Luma.ISO = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO_len));
|
pAtmoCtx->AtmoConfig.Luma.GlobeLuma = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength_len));
|
pAtmoCtx->AtmoConfig.DtsHiLit.len = calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len;
|
pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len));
|
pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv_len));
|
pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.Strength_len));
|
pAtmoCtx->AtmoConfig.DtsLoLit.len = calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len;
|
pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len));
|
pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf_len));
|
pAtmoCtx->AtmoConfig.DtsLoLit.ISO = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.ISO_len));
|
pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.Strength_len));
|
pAtmoCtx->AtmoConfig.local.len = calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len;
|
pAtmoCtx->AtmoConfig.local.DynamicRange = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len));
|
pAtmoCtx->AtmoConfig.local.EnvLv = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv_len));
|
pAtmoCtx->AtmoConfig.local.LocalTmoStrength = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.Strength_len));
|
pAtmoCtx->AtmoConfig.global.len = calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len;
|
pAtmoCtx->AtmoConfig.global.DynamicRange = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len));
|
pAtmoCtx->AtmoConfig.global.EnvLv = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv_len));
|
pAtmoCtx->AtmoConfig.global.GlobalTmoStrength = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength_len));
|
pAtmoCtx->state = ATMO_STATE_INITIALIZED;
|
pAtmoCtx->tmoAttr.opMode = TMO_OPMODE_API_OFF;
|
AtmoConfig(pAtmoCtx); //set default para
|
memcpy(&pAtmoCtx->pCalibDB, calibv2_atmo_calib, sizeof(CalibDbV2_tmo_t));//load iq paras
|
memcpy(&pAtmoCtx->tmoAttr.stTool, calibv2_atmo_calib, sizeof(CalibDbV2_tmo_t));//load iq paras to stTool
|
pInstConfig->hAtmo = (AtmoHandle_t)pAtmoCtx;
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
return (ATMO_RET_SUCCESS);
|
}
|
/******************************************************************************
|
* AtmoRelease()
|
*****************************************************************************/
|
RESULT AtmoRelease
|
(
|
AtmoHandle_t pAtmoCtx
|
) {
|
|
LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
|
RESULT result = ATMO_RET_SUCCESS;
|
|
// initial checks
|
if (NULL == pAtmoCtx) {
|
return (ATMO_RET_WRONG_HANDLE);
|
}
|
|
result = AtmoStop(pAtmoCtx);
|
if (result != ATMO_RET_SUCCESS) {
|
LOGE_ATMO( "%s: AHDRStop() failed!\n", __FUNCTION__);
|
return (result);
|
}
|
|
// check state
|
if ((ATMO_STATE_RUNNING == pAtmoCtx->state)
|
|| (ATMO_STATE_LOCKED == pAtmoCtx->state)) {
|
return (ATMO_RET_BUSY);
|
}
|
|
free(pAtmoCtx->AtmoConfig.Luma.EnvLv);
|
free(pAtmoCtx->AtmoConfig.Luma.ISO);
|
free(pAtmoCtx->AtmoConfig.Luma.GlobeLuma);
|
free(pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf);
|
free(pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv);
|
free(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight);
|
free(pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma);
|
free(pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf);
|
free(pAtmoCtx->AtmoConfig.DtsLoLit.ISO);
|
free(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight);
|
free(pAtmoCtx->AtmoConfig.local.DynamicRange);
|
free(pAtmoCtx->AtmoConfig.local.EnvLv);
|
free(pAtmoCtx->AtmoConfig.local.LocalTmoStrength);
|
free(pAtmoCtx->AtmoConfig.global.DynamicRange);
|
free(pAtmoCtx->AtmoConfig.global.EnvLv);
|
free(pAtmoCtx->AtmoConfig.global.GlobalTmoStrength);
|
memset(pAtmoCtx, 0, sizeof(AtmoContext_s));
|
free(pAtmoCtx);
|
pAtmoCtx = NULL;
|
|
LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
|
return (ATMO_RET_SUCCESS);
|
}
|
