1 /******************************************************************************
2 *
3 * Copyright 2019, Fuzhou Rockchip Electronics Co.Ltd. All rights reserved.
4 * No part of this work may be reproduced, modified, distributed, transmitted,
5 * transcribed, or translated into any language or computer format, in any form
6 * or by any means without written permission of:
7 * Fuzhou Rockchip Electronics Co.Ltd .
8 *
9 *
10 *****************************************************************************/
11 /**
12 * @file ahdr.cpp
13 *
14 * @brief
15 * ADD_DESCRIPTION_HERE
16 *
17 *****************************************************************************/
18 #include "math.h"
19 #include "rk_aiq_types_atmo_algo_int.h"
20 #include "rk_aiq_types_atmo_algo_prvt.h"
21 #include "xcam_log.h"
22
23 /******************************************************************************
24 * AtmoStart()
25 *****************************************************************************/
AtmoStart(AtmoHandle_t pAtmoCtx)26 RESULT AtmoStart
27 (
28 AtmoHandle_t pAtmoCtx
29 ) {
30
31 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
32
33 // initial checks
34 if (pAtmoCtx == NULL) {
35 return (ATMO_RET_WRONG_HANDLE);
36 }
37
38 if ((ATMO_STATE_RUNNING == pAtmoCtx->state)
39 || (ATMO_STATE_LOCKED == pAtmoCtx->state)) {
40 return (ATMO_RET_WRONG_STATE);
41 }
42
43 pAtmoCtx->state = ATMO_STATE_RUNNING;
44
45 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
46 return (ATMO_RET_SUCCESS);
47 }
48 /******************************************************************************
49 * AtmoStop()
50 *****************************************************************************/
AtmoStop(AtmoHandle_t pAtmoCtx)51 RESULT AtmoStop
52 (
53 AtmoHandle_t pAtmoCtx
54 ) {
55
56 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
57
58 // initial checks
59 if (pAtmoCtx == NULL) {
60 return (ATMO_RET_WRONG_HANDLE);
61 }
62
63 // before stopping, unlock the Atmo if locked
64 if (ATMO_STATE_LOCKED == pAtmoCtx->state) {
65 return (ATMO_RET_WRONG_STATE);
66 }
67
68 pAtmoCtx->state = ATMO_STATE_STOPPED;
69
70 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
71
72 return (ATMO_RET_SUCCESS);
73 }
74 /******************************************************************************
75 * TmoGetCurrPara()
76 *****************************************************************************/
TmoGetCurrPara(float inPara,float * inMatrixX,float * inMatrixY,int Max_Knots)77 float TmoGetCurrPara
78 (
79 float inPara,
80 float* inMatrixX,
81 float* inMatrixY,
82 int Max_Knots
83 ) {
84 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
85 float x1 = 0.0f;
86 float x2 = 0.0f;
87 float value1 = 0.0f;
88 float value2 = 0.0f;
89 float outPara = 0.0f;
90
91 if(inPara < inMatrixX[0])
92 outPara = inMatrixY[0];
93 else if (inPara >= inMatrixX[Max_Knots - 1])
94 outPara = inMatrixY[Max_Knots - 1];
95 else
96 for(int i = 0; i < Max_Knots - 1; i++)
97 {
98 if(inPara >= inMatrixX[i] && inPara < inMatrixX[i + 1])
99 {
100 x1 = inMatrixX[i];
101 x2 = inMatrixX[i + 1];
102 value1 = inMatrixY[i];
103 value2 = inMatrixY[i + 1];
104 outPara = value1 + (inPara - x1) * (value1 - value2) / (x1 - x2);
105 break;
106 }
107 else
108 continue;
109 }
110
111 return outPara;
112 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
113 }
114 /******************************************************************************
115 * AtmoConfig()
116 *set default AtmoConfig data
117 *****************************************************************************/
AtmoConfig(AtmoHandle_t pAtmoCtx)118 void AtmoConfig
119 (
120 AtmoHandle_t pAtmoCtx
121 ) {
122 LOG1_ATMO("%s:enter!\n", __FUNCTION__);
123
124 // initial checks
125 DCT_ASSERT(pAtmoCtx != NULL);
126
127 //config default PrevData data
128 pAtmoCtx->PrevData.CtrlData.FrameCnt = 0;
129 pAtmoCtx->PrevData.ro_hdrtmo_lgmean = 20000;
130 pAtmoCtx->PrevData.HandleData.GlobeLuma = 0.18;
131 pAtmoCtx->PrevData.HandleData.GlobeMaxLuma = 0.3;
132 pAtmoCtx->PrevData.HandleData.DetailsHighLight = 0.5;
133 pAtmoCtx->PrevData.HandleData.DetailsLowLight = 1;
134 pAtmoCtx->PrevData.HandleData.LocalTmoStrength = 0.3;
135 pAtmoCtx->PrevData.HandleData.GlobalTmoStrength = 0.5;
136
137 //set default ctrl info
138 pAtmoCtx->tmoAttr.CtlInfo.GlobalLumaMode = GLOBALLUMAMODE_ENVLV;
139 pAtmoCtx->tmoAttr.CtlInfo.DetailsHighLightMode = DETAILSHIGHLIGHTMODE_ENVLV;
140 pAtmoCtx->tmoAttr.CtlInfo.DetailsLowLightMode = DETAILSLOWLIGHTMODE_ISO;
141 pAtmoCtx->tmoAttr.CtlInfo.GlobalTmoMode = TMOTYPEMODE_DYNAMICRANGE;
142 pAtmoCtx->tmoAttr.CtlInfo.LocalTMOMode = TMOTYPEMODE_DYNAMICRANGE;
143
144 pAtmoCtx->tmoAttr.CtlInfo.Envlv = 1.0;
145 pAtmoCtx->tmoAttr.CtlInfo.ISO = 1.0;
146 pAtmoCtx->tmoAttr.CtlInfo.OEPdf = 1.0;
147 pAtmoCtx->tmoAttr.CtlInfo.FocusLuma = 1.0;
148 pAtmoCtx->tmoAttr.CtlInfo.DarkPdf = 1.0;
149 pAtmoCtx->tmoAttr.CtlInfo.DynamicRange = 1.0;
150
151 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
152 }
153
AtmoGetStats(AtmoHandle_t pAtmoCtx,rkisp_atmo_stats_t * ROData)154 void AtmoGetStats
155 (
156 AtmoHandle_t pAtmoCtx,
157 rkisp_atmo_stats_t* ROData
158 ) {
159 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
160
161 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lglow = ROData->tmo_stats.ro_hdrtmo_lglow;
162 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmin = ROData->tmo_stats.ro_hdrtmo_lgmin;
163 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmax = ROData->tmo_stats.ro_hdrtmo_lgmax;
164 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lghigh = ROData->tmo_stats.ro_hdrtmo_lghigh;
165 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmean = ROData->tmo_stats.ro_hdrtmo_lgmean;
166 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_weightkey = ROData->tmo_stats.ro_hdrtmo_weightkey;
167 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgrange0 = ROData->tmo_stats.ro_hdrtmo_lgrange0;
168 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgrange1 = ROData->tmo_stats.ro_hdrtmo_lgrange1;
169 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgavgmax = ROData->tmo_stats.ro_hdrtmo_lgavgmax;
170 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_palpha = ROData->tmo_stats.ro_hdrtmo_palpha;
171 pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_linecnt = ROData->tmo_stats.ro_hdrtmo_linecnt;
172 for(int i = 0; i < 32; i++)
173 pAtmoCtx->CurrStatsData.tmo_stats.ro_array_min_max[i] = ROData->tmo_stats.ro_array_min_max[i];
174
175 //get other stats from stats
176 for(int i = 0; i < 225; i++)
177 {
178 pAtmoCtx->CurrStatsData.other_stats.short_luma[i] = ROData->other_stats.short_luma[i];
179 pAtmoCtx->CurrStatsData.other_stats.long_luma[i] = ROData->other_stats.long_luma[i];
180 pAtmoCtx->CurrStatsData.other_stats.tmo_luma[i] = ROData->other_stats.tmo_luma[i];
181 }
182
183 if(pAtmoCtx->FrameNumber == HDR_3X_NUM)
184 {
185 for(int i = 0; i < 25; i++)
186 pAtmoCtx->CurrStatsData.other_stats.middle_luma[i] = ROData->other_stats.middle_luma[i];
187 }
188
189 LOGV_ATMO("%s: Ahdr RO data from register:\n", __FUNCTION__);
190 LOGV_ATMO("%s: ro_hdrtmo_lglow:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lglow);
191 LOGV_ATMO("%s: ro_hdrtmo_lgmin:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmin);
192 LOGV_ATMO("%s: ro_hdrtmo_lgmax:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmax);
193 LOGV_ATMO("%s: ro_hdrtmo_lghigh:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lghigh);
194 LOGV_ATMO("%s: ro_hdrtmo_weightkey:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_weightkey);
195 LOGV_ATMO("%s: ro_hdrtmo_lgmean:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmean);
196 LOGV_ATMO("%s: ro_hdrtmo_lgrange0:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgrange0);
197 LOGV_ATMO("%s: ro_hdrtmo_lgrange1:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgrange1);
198 LOGV_ATMO("%s: ro_hdrtmo_lgavgmax:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgavgmax);
199 LOGV_ATMO("%s: ro_hdrtmo_palpha:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_palpha);
200 LOGV_ATMO("%s: ro_hdrtmo_linecnt:%d:\n", __FUNCTION__, pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_linecnt);
201 for(int i = 0; i < 32; i++)
202 LOGV_ATMO("%s: ro_array_min_max[%d]:%d:\n", __FUNCTION__, i, pAtmoCtx->CurrStatsData.tmo_stats.ro_array_min_max[i]);
203
204 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
205 }
206
AtmoGetAeResult(AtmoHandle_t pAtmoCtx,AecPreResult_t AecHdrPreResult)207 void AtmoGetAeResult
208 (
209 AtmoHandle_t pAtmoCtx,
210 AecPreResult_t AecHdrPreResult
211 ) {
212 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
213
214 //get Ae Pre Result
215 pAtmoCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[AecHdrPreResult.NormalIndex];
216 //pAtmoCtx->CurrAeResult.M2S_Ratio = AecHdrPreResult.M2S_ExpRatio;
217 //pAtmoCtx->CurrAeResult.M2S_Ratio = pAtmoCtx->CurrAeResult.M2S_Ratio < 1 ? 1 : pAtmoCtx->CurrAeResult.M2S_Ratio;
218 //pAtmoCtx->CurrAeResult.L2M_Ratio = AecHdrPreResult.L2M_ExpRatio;
219 //pAtmoCtx->CurrAeResult.L2M_Ratio = pAtmoCtx->CurrAeResult.L2M_Ratio < 1 ? 1 : pAtmoCtx->CurrAeResult.L2M_Ratio;
220 pAtmoCtx->CurrAeResult.DynamicRange = AecHdrPreResult.DynamicRange;
221 pAtmoCtx->CurrAeResult.OEPdf = AecHdrPreResult.OverExpROIPdf[1];
222 pAtmoCtx->CurrAeResult.DarkPdf = AecHdrPreResult.LowLightROIPdf[1];
223 for(int i = 0; i < 225; i++)
224 {
225 pAtmoCtx->CurrAeResult.BlockLumaS[i] = pAtmoCtx->CurrStatsData.other_stats.short_luma[i];
226 pAtmoCtx->CurrAeResult.BlockLumaL[i] = pAtmoCtx->CurrStatsData.other_stats.long_luma[i];
227 }
228 if(pAtmoCtx->FrameNumber == HDR_3X_NUM)
229 for(int i = 0; i < 25; i++)
230 pAtmoCtx->CurrAeResult.BlockLumaM[i] = pAtmoCtx->CurrStatsData.other_stats.middle_luma[i];
231 else
232 for(int i = 0; i < 25; i++)
233 pAtmoCtx->CurrAeResult.BlockLumaM[i] = 0;
234
235 //transfer CurrAeResult data into AhdrHandle
236 switch (pAtmoCtx->FrameNumber)
237 {
238 case LINEAR_NUM:
239 pAtmoCtx->CurrData.CtrlData.LExpo = AecHdrPreResult.LinearExp.exp_real_params.analog_gain * AecHdrPreResult.LinearExp.exp_real_params.integration_time;
240 pAtmoCtx->CurrData.CtrlData.L2S_Ratio = 1;
241 pAtmoCtx->CurrData.CtrlData.L2M_Ratio = 1;
242 pAtmoCtx->CurrData.CtrlData.L2L_Ratio = 1;
243 pAtmoCtx->CurrAeResult.ISO = AecHdrPreResult.LinearExp.exp_real_params.analog_gain * 50.0;
244 pAtmoCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[0];
245 pAtmoCtx->CurrAeResult.OEPdf = AecHdrPreResult.OverExpROIPdf[0];
246 pAtmoCtx->CurrAeResult.DarkPdf = AecHdrPreResult.LowLightROIPdf[0];
247 break;
248 case HDR_2X_NUM:
249 pAtmoCtx->CurrData.CtrlData.L2S_Ratio = pAtmoCtx->CurrAeResult.M2S_Ratio;
250 pAtmoCtx->CurrData.CtrlData.L2M_Ratio = 1;
251 pAtmoCtx->CurrData.CtrlData.L2L_Ratio = 1;
252 pAtmoCtx->CurrData.CtrlData.LExpo = AecHdrPreResult.HdrExp[1].exp_real_params.analog_gain * AecHdrPreResult.HdrExp[1].exp_real_params.integration_time;
253 pAtmoCtx->CurrAeResult.ISO = AecHdrPreResult.HdrExp[1].exp_real_params.analog_gain * 50.0;
254 pAtmoCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[1];
255 pAtmoCtx->CurrAeResult.OEPdf = AecHdrPreResult.OverExpROIPdf[1];
256 pAtmoCtx->CurrAeResult.DarkPdf = AecHdrPreResult.LowLightROIPdf[1];
257 break;
258 case HDR_3X_NUM:
259 pAtmoCtx->CurrData.CtrlData.L2S_Ratio = pAtmoCtx->CurrAeResult.L2M_Ratio * pAtmoCtx->CurrAeResult.M2S_Ratio;
260 pAtmoCtx->CurrData.CtrlData.L2M_Ratio = pAtmoCtx->CurrAeResult.L2M_Ratio;
261 pAtmoCtx->CurrData.CtrlData.L2L_Ratio = 1;
262 pAtmoCtx->CurrData.CtrlData.LExpo = AecHdrPreResult.HdrExp[2].exp_real_params.analog_gain * AecHdrPreResult.HdrExp[2].exp_real_params.integration_time;
263 pAtmoCtx->CurrAeResult.ISO = AecHdrPreResult.HdrExp[2].exp_real_params.analog_gain * 50.0;
264 pAtmoCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[2];
265 pAtmoCtx->CurrAeResult.OEPdf = AecHdrPreResult.OverExpROIPdf[1];
266 pAtmoCtx->CurrAeResult.DarkPdf = AecHdrPreResult.LowLightROIPdf[1];
267 break;
268 default:
269 LOGE_ATMO("%s: Wrong frame number in TMO mode!!!\n", __FUNCTION__);
270 break;
271 }
272
273 //Normalize the current envLv for AEC
274 float maxEnvLuma = 65 / 10;
275 float minEnvLuma = 0;
276 pAtmoCtx->CurrData.CtrlData.EnvLv = (pAtmoCtx->CurrAeResult.GlobalEnvLv - minEnvLuma) / (maxEnvLuma - minEnvLuma);
277 pAtmoCtx->CurrData.CtrlData.EnvLv = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.EnvLv, ENVLVMAX, ENVLVMIN);
278
279 LOGD_ATMO("%s: Current L2S_Ratio:%f L2M_Ratio:%f L2L_Ratio:%f\n", __FUNCTION__, pAtmoCtx->CurrData.CtrlData.L2S_Ratio,
280 pAtmoCtx->CurrData.CtrlData.L2M_Ratio, pAtmoCtx->CurrData.CtrlData.L2L_Ratio);
281
282 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
283 }
284
AtmoGetSensorInfo(AtmoHandle_t pAtmoCtx,AecProcResult_t AecHdrProcResult)285 void AtmoGetSensorInfo
286 (
287 AtmoHandle_t pAtmoCtx,
288 AecProcResult_t AecHdrProcResult
289 ) {
290 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
291
292 pAtmoCtx->SensorInfo.LongFrmMode = AecHdrProcResult.LongFrmMode && (pAtmoCtx->FrameNumber != LINEAR_NUM);
293
294 for(int i = 0; i < 3; i++)
295 {
296 pAtmoCtx->SensorInfo.HdrMinGain[i] = AecHdrProcResult.HdrMinGain[i];
297 pAtmoCtx->SensorInfo.HdrMaxGain[i] = AecHdrProcResult.HdrMaxGain[i];
298 pAtmoCtx->SensorInfo.HdrMinIntegrationTime[i] = AecHdrProcResult.HdrMinIntegrationTime[i];
299 pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[i] = AecHdrProcResult.HdrMaxIntegrationTime[i];
300 }
301
302 if(pAtmoCtx->FrameNumber == LINEAR_NUM)
303 {
304 //pAtmoCtx->SensorInfo.MaxExpoL = pAtmoCtx->SensorInfo.HdrMaxGain[1] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[1];
305 //pAtmoCtx->SensorInfo.MinExpoL = pAtmoCtx->SensorInfo.HdrMinGain[1] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[1];
306 //pAtmoCtx->SensorInfo.MaxExpoM = 0;
307 //pAtmoCtx->SensorInfo.MinExpoM = 0;
308
309 pAtmoCtx->CurrAeResult.LumaDeviationLinear = AecHdrProcResult.LumaDeviation;
310 pAtmoCtx->CurrAeResult.LumaDeviationLinear = abs(pAtmoCtx->CurrAeResult.LumaDeviationLinear);
311 }
312 else if(pAtmoCtx->FrameNumber == HDR_2X_NUM)
313 {
314 pAtmoCtx->SensorInfo.MaxExpoL = pAtmoCtx->SensorInfo.HdrMaxGain[1] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[1];
315 pAtmoCtx->SensorInfo.MinExpoL = pAtmoCtx->SensorInfo.HdrMinGain[1] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[1];
316 pAtmoCtx->SensorInfo.MaxExpoM = 0;
317 pAtmoCtx->SensorInfo.MinExpoM = 0;
318
319 pAtmoCtx->CurrAeResult.LumaDeviationL = AecHdrProcResult.HdrLumaDeviation[1];
320 pAtmoCtx->CurrAeResult.LumaDeviationL = abs(pAtmoCtx->CurrAeResult.LumaDeviationL);
321 pAtmoCtx->CurrAeResult.LumaDeviationS = AecHdrProcResult.HdrLumaDeviation[0];
322 pAtmoCtx->CurrAeResult.LumaDeviationS = abs(pAtmoCtx->CurrAeResult.LumaDeviationS);
323 }
324 else if(pAtmoCtx->FrameNumber == HDR_3X_NUM)
325 {
326 pAtmoCtx->SensorInfo.MaxExpoL = pAtmoCtx->SensorInfo.HdrMaxGain[2] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[2];
327 pAtmoCtx->SensorInfo.MinExpoL = pAtmoCtx->SensorInfo.HdrMinGain[2] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[2];
328 pAtmoCtx->SensorInfo.MaxExpoM = pAtmoCtx->SensorInfo.HdrMaxGain[1] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[1];
329 pAtmoCtx->SensorInfo.MinExpoM = pAtmoCtx->SensorInfo.HdrMinGain[1] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[1];
330
331 pAtmoCtx->CurrAeResult.LumaDeviationL = AecHdrProcResult.HdrLumaDeviation[2];
332 pAtmoCtx->CurrAeResult.LumaDeviationL = abs(pAtmoCtx->CurrAeResult.LumaDeviationL);
333 pAtmoCtx->CurrAeResult.LumaDeviationM = AecHdrProcResult.HdrLumaDeviation[1];
334 pAtmoCtx->CurrAeResult.LumaDeviationM = abs(pAtmoCtx->CurrAeResult.LumaDeviationM);
335 pAtmoCtx->CurrAeResult.LumaDeviationS = AecHdrProcResult.HdrLumaDeviation[0];
336 pAtmoCtx->CurrAeResult.LumaDeviationS = abs(pAtmoCtx->CurrAeResult.LumaDeviationS);
337 }
338
339 pAtmoCtx->SensorInfo.MaxExpoS = pAtmoCtx->SensorInfo.HdrMaxGain[0] * pAtmoCtx->SensorInfo.HdrMaxIntegrationTime[0];
340 pAtmoCtx->SensorInfo.MinExpoS = pAtmoCtx->SensorInfo.HdrMinGain[0] * pAtmoCtx->SensorInfo.HdrMinIntegrationTime[0];
341
342
343 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
344 }
345
346 /******************************************************************************
347 * AtmoApiSetLevel()
348 *
349 *****************************************************************************/
AtmoApiSetLevel(AtmoHandle_t pAtmoCtx)350 void AtmoApiSetLevel
351 (
352 AtmoHandle_t pAtmoCtx
353 )
354 {
355 LOG1_ATMO("%s:enter!\n", __FUNCTION__);
356
357 //tmo data
358 pAtmoCtx->tmoAttr.stSetLevel.level = LIMIT_VALUE(pAtmoCtx->tmoAttr.stSetLevel.level, FASTMODELEVELMAX, FASTMODELEVELMIN);
359
360 float level = ((float)(pAtmoCtx->tmoAttr.stSetLevel.level)) / FASTMODELEVELMAX;
361 float level_default = 0.5;
362 float level_diff = level - level_default;
363
364 pAtmoCtx->CurrData.HandleData.GlobeLuma *= 1 + level_diff;
365 float GlobeLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma;
366 pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = MAXLUMAK * GlobeLuma + MAXLUMAB;
367 pAtmoCtx->CurrData.HandleData.GlobeMaxLuma =
368 LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma, GLOBEMAXLUMAMAX, GLOBEMAXLUMAMIN);
369
370 pAtmoCtx->CurrData.HandleData.DetailsHighLight *= 1 + level_diff;
371 pAtmoCtx->CurrData.HandleData.DetailsHighLight =
372 LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsHighLight, DETAILSHIGHLIGHTMAX, DETAILSHIGHLIGHTMIN);
373
374 pAtmoCtx->CurrData.HandleData.DetailsLowLight *= 1 + level_diff;
375 pAtmoCtx->CurrData.HandleData.DetailsLowLight =
376 LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsLowLight, DETAILSLOWLIGHTMAX, DETAILSLOWLIGHTMIN);
377
378 pAtmoCtx->AtmoConfig.bTmoEn = true;
379 pAtmoCtx->ProcRes.isLinearTmo = pAtmoCtx->FrameNumber == LINEAR_NUM ;
380
381 /*
382 pAtmoCtx->CurrData.HandleData.TmoContrast *= 1 + level_diff;
383 pAtmoCtx->CurrData.HandleData.TmoContrast =
384 LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.LocalTmoStrength, TMOCONTRASTMAX, TMOCONTRASTMIN);
385 */
386 //paras after updating
387 LOGD_ATMO("%s: AHDR_OpMode_Fast set level:%d\n", __FUNCTION__, pAtmoCtx->tmoAttr.stSetLevel.level);
388 LOGD_ATMO("%s: After fast mode GlobeLuma:%f GlobeMaxLuma:%f DetailsHighLight:%f DetailsLowLight:%f LocalTmoStrength:%f \n", __FUNCTION__,
389 pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
390 pAtmoCtx->CurrData.HandleData.DetailsHighLight, pAtmoCtx->CurrData.HandleData.DetailsLowLight,
391 pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
392
393
394 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
395 }
396
397 /******************************************************************************
398 * ApiOffProcess()
399 *
400 *****************************************************************************/
ApiOffProcess(AtmoHandle_t pAtmoCtx)401 void ApiOffProcess(AtmoHandle_t pAtmoCtx)
402 {
403 LOG1_ATMO("%s:enter!\n", __FUNCTION__);
404
405 //get Current GlobeLuma GlobeMaxLuma
406 if(pAtmoCtx->AtmoConfig.Luma.globalLumaMode == GLOBALLUMAMODE_ENVLV)
407 pAtmoCtx->CurrData.HandleData.GlobeLuma = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.EnvLv,
408 pAtmoCtx->AtmoConfig.Luma.EnvLv, pAtmoCtx->AtmoConfig.Luma.GlobeLuma, pAtmoCtx->AtmoConfig.Luma.len);
409 else if(pAtmoCtx->AtmoConfig.Luma.globalLumaMode == GLOBALLUMAMODE_ISO)
410 pAtmoCtx->CurrData.HandleData.GlobeLuma = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.ISO,
411 pAtmoCtx->AtmoConfig.Luma.ISO, pAtmoCtx->AtmoConfig.Luma.GlobeLuma, pAtmoCtx->AtmoConfig.Luma.len);
412
413 float GlobeLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma;
414 pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = MAXLUMAK * GlobeLuma + MAXLUMAB;
415 pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma, GLOBEMAXLUMAMAX, GLOBEMAXLUMAMIN);
416
417 //get Current local tmo
418 if(pAtmoCtx->AtmoConfig.local.localtmoMode == TMOTYPEMODE_DYNAMICRANGE)
419 pAtmoCtx->CurrData.HandleData.LocalTmoStrength = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.DynamicRange,
420 pAtmoCtx->AtmoConfig.local.DynamicRange, pAtmoCtx->AtmoConfig.local.LocalTmoStrength, pAtmoCtx->AtmoConfig.local.len);
421 else if(pAtmoCtx->AtmoConfig.local.localtmoMode == TMOTYPEMODE_ENVLV)
422 pAtmoCtx->CurrData.HandleData.LocalTmoStrength = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.EnvLv,
423 pAtmoCtx->AtmoConfig.local.EnvLv, pAtmoCtx->AtmoConfig.local.LocalTmoStrength, pAtmoCtx->AtmoConfig.local.len);
424
425 if(pAtmoCtx->AtmoConfig.global.isHdrGlobalTmo)
426 pAtmoCtx->CurrData.HandleData.LocalTmoStrength = 0;
427
428 //get Current global tmo
429 if(pAtmoCtx->AtmoConfig.global.mode == TMOTYPEMODE_DYNAMICRANGE)
430 pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.DynamicRange,
431 pAtmoCtx->AtmoConfig.global.DynamicRange, pAtmoCtx->AtmoConfig.global.GlobalTmoStrength, pAtmoCtx->AtmoConfig.global.len);
432 else if(pAtmoCtx->AtmoConfig.global.mode == TMOTYPEMODE_ENVLV)
433 pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.EnvLv,
434 pAtmoCtx->AtmoConfig.global.EnvLv, pAtmoCtx->AtmoConfig.global.GlobalTmoStrength, pAtmoCtx->AtmoConfig.global.len);
435
436 //get Current DetailsHighLight
437 if(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode == DETAILSHIGHLIGHTMODE_OEPDF)
438 pAtmoCtx->CurrData.HandleData.DetailsHighLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.OEPdf,
439 pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight, pAtmoCtx->AtmoConfig.DtsHiLit.len);
440 else if(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode == DETAILSHIGHLIGHTMODE_ENVLV)
441 pAtmoCtx->CurrData.HandleData.DetailsHighLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.EnvLv,
442 pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight, pAtmoCtx->AtmoConfig.DtsHiLit.len);
443
444 //get Current DetailsLowLight
445 int DetailsLowLight_mode = (int)pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode;
446 if (pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_FOCUSLUMA)
447 {
448 #if 0
449 int focs = pAtmoCtx->CurrAfResult.CurrAfTargetPos;
450 int focs_width = pAtmoCtx->CurrAfResult.CurrAfTargetWidth / (pAtmoCtx->width / 15);
451 int focs_height = pAtmoCtx->CurrAfResult.CurrAfTargetHeight / (pAtmoCtx->height / 15);
452 float focs_luma = 0;
453 for(int i = 0; i < focs_height; i++)
454 for(int j = 0; j < focs_width; j++)
455 focs_luma += pAtmoCtx->CurrAeResult.BlockLumaL[focs + i + 15 * j];
456 focs_luma = focs_luma / (focs_width * focs_height);
457 pAtmoCtx->CurrData.CtrlData.FocusLuma = focs_luma / 15;
458 pAtmoCtx->CurrData.CtrlData.FocusLuma = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.FocusLuma, FOCUSLUMAMAX, FOCUSLUMAMIN);
459 pAtmoCtx->CurrData.HandleData.DetailsLowLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.FocusLuma,
460 pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight, pAtmoCtx->AtmoConfig.DtsLoLit.len);
461
462 #endif
463 pAtmoCtx->CurrData.HandleData.DetailsLowLight = pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[0];
464
465 }
466 else if (pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_DARKPDF)
467 pAtmoCtx->CurrData.HandleData.DetailsLowLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.DarkPdf,
468 pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight, pAtmoCtx->AtmoConfig.DtsLoLit.len);
469 else if (pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_ISO)
470 pAtmoCtx->CurrData.HandleData.DetailsLowLight = TmoGetCurrPara(pAtmoCtx->CurrData.CtrlData.ISO,
471 pAtmoCtx->AtmoConfig.DtsLoLit.ISO, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight, pAtmoCtx->AtmoConfig.DtsLoLit.len);
472
473 //get Current tmo TmoDamp
474 pAtmoCtx->CurrData.CtrlData.TmoDamp = pAtmoCtx->AtmoConfig.damp;
475
476 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
477 }
478
479 /******************************************************************************
480 * AtmoTranferData2Api()
481 *
482 *****************************************************************************/
AtmoTranferData2Api(AtmoHandle_t pAtmoCtx)483 void AtmoTranferData2Api
484 (
485 AtmoHandle_t pAtmoCtx
486 )
487 {
488 LOG1_ATMO("%s:enter!\n", __FUNCTION__);
489
490 //transfer control data to api
491 pAtmoCtx->tmoAttr.CtlInfo.GlobalLumaMode = pAtmoCtx->AtmoConfig.Luma.globalLumaMode;
492 pAtmoCtx->tmoAttr.CtlInfo.DetailsHighLightMode = pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode;
493 pAtmoCtx->tmoAttr.CtlInfo.DetailsLowLightMode = pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode;
494 pAtmoCtx->tmoAttr.CtlInfo.GlobalTmoMode = pAtmoCtx->AtmoConfig.global.mode;
495 pAtmoCtx->tmoAttr.CtlInfo.LocalTMOMode = pAtmoCtx->AtmoConfig.local.localtmoMode;
496 pAtmoCtx->tmoAttr.CtlInfo.Envlv = pAtmoCtx->CurrData.CtrlData.EnvLv;
497 pAtmoCtx->tmoAttr.CtlInfo.ISO = pAtmoCtx->CurrData.CtrlData.ISO;
498 pAtmoCtx->tmoAttr.CtlInfo.OEPdf = pAtmoCtx->CurrData.CtrlData.OEPdf;
499 pAtmoCtx->tmoAttr.CtlInfo.DarkPdf = pAtmoCtx->CurrData.CtrlData.DarkPdf;
500 pAtmoCtx->tmoAttr.CtlInfo.FocusLuma = pAtmoCtx->CurrData.CtrlData.FocusLuma;
501 pAtmoCtx->tmoAttr.CtlInfo.DynamicRange = pAtmoCtx->CurrData.CtrlData.DynamicRange;
502
503 //transfer register data to api
504 pAtmoCtx->tmoAttr.RegInfo.GlobalLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma / GLOBELUMAMAX;
505 pAtmoCtx->tmoAttr.RegInfo.DetailsLowlight = pAtmoCtx->CurrData.HandleData.DetailsLowLight / DETAILSLOWLIGHTMIN;
506 pAtmoCtx->tmoAttr.RegInfo.DetailsHighlight = pAtmoCtx->CurrData.HandleData.DetailsHighLight / DETAILSHIGHLIGHTMAX;
507 pAtmoCtx->tmoAttr.RegInfo.LocalTmoStrength = pAtmoCtx->CurrData.HandleData.LocalTmoStrength / TMOCONTRASTMAX;
508 pAtmoCtx->tmoAttr.RegInfo.GlobaltmoStrength = pAtmoCtx->CurrData.HandleData.GlobalTmoStrength;
509
510
511 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
512 }
513
514 /******************************************************************************
515 * AtmoApiAutoUpdate()
516 *
517 *****************************************************************************/
AtmoApiAutoUpdate(AtmoHandle_t pAtmoCtx)518 void AtmoApiAutoUpdate
519 (
520 AtmoHandle_t pAtmoCtx
521 )
522 {
523 LOG1_ATMO("%s:enter!\n", __FUNCTION__);
524
525 //update tmo data in Auto mode
526 if (pAtmoCtx->tmoAttr.stAuto.bUpdateTmo == true)
527 {
528 pAtmoCtx->CurrData.HandleData.DetailsLowLight =
529 LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stMin,
530 pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsLL.stMin);
531 pAtmoCtx->CurrData.HandleData.DetailsLowLight *= IQDETAILSLOWLIGHTMIN;
532 pAtmoCtx->CurrData.HandleData.DetailsLowLight = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsLowLight
533 , IQDETAILSLOWLIGHTMAX, IQDETAILSLOWLIGHTMIN);
534
535 pAtmoCtx->CurrData.HandleData.DetailsHighLight =
536 LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stMin,
537 pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stDtlsHL.stMin);
538 pAtmoCtx->CurrData.HandleData.DetailsHighLight *= DETAILSHIGHLIGHTMAX;
539 pAtmoCtx->CurrData.HandleData.DetailsHighLight = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsHighLight
540 , DETAILSHIGHLIGHTMAX, DETAILSHIGHLIGHTMIN);
541
542 pAtmoCtx->CurrData.HandleData.LocalTmoStrength =
543 LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stMin,
544 pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stLocalTMO.stMin);
545 pAtmoCtx->CurrData.HandleData.LocalTmoStrength *= TMOCONTRASTMAX;
546 pAtmoCtx->CurrData.HandleData.LocalTmoStrength = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.LocalTmoStrength
547 , TMOCONTRASTMAX, TMOCONTRASTMIN);
548
549 pAtmoCtx->CurrData.HandleData.GlobeLuma =
550 LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stMin,
551 pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobeLuma.stMin);
552 pAtmoCtx->CurrData.HandleData.GlobeLuma *= GLOBELUMAMAX;
553 pAtmoCtx->CurrData.HandleData.GlobeLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeLuma
554 , GLOBELUMAMAX, GLOBELUMAMIN);
555
556 float GlobeLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma;
557 pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = MAXLUMAK * GlobeLuma + MAXLUMAB;
558 pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
559 GLOBEMAXLUMAMAX, GLOBEMAXLUMAMIN);
560
561 if(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.en)
562 {
563 float strength = LIMIT_PARA(pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stCoef, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stMin,
564 pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stCoefMax, pAtmoCtx->tmoAttr.stAuto.stTmoAuto.stGlobalTMO.stMin);
565 pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = strength;
566 }
567 else
568 pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = 0.5;
569
570 }
571 else
572 ApiOffProcess(pAtmoCtx);
573
574 //paras after updating
575 LOGD_ATMO("%s: Current GlobeLuma:%f GlobeMaxLuma:%f DetailsHighLight:%f DetailsLowLight:%f GlobalTmoStrength:%f LocalTmoStrength:%f\n", __FUNCTION__,
576 pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
577 pAtmoCtx->CurrData.HandleData.DetailsHighLight, pAtmoCtx->CurrData.HandleData.DetailsLowLight,
578 pAtmoCtx->CurrData.HandleData.GlobalTmoStrength, pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
579
580 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
581 }
582
583 /******************************************************************************
584 * AtmoApiManualUpdate()
585 *
586 *****************************************************************************/
AtmoApiManualUpdate(AtmoHandle_t pAtmoCtx)587 void AtmoApiManualUpdate
588 (
589 AtmoHandle_t pAtmoCtx
590 )
591 {
592 LOG1_ATMO("%s:enter!\n", __FUNCTION__);
593
594 //update tmo data in manual mode
595 if (pAtmoCtx->tmoAttr.stManual.bUpdateTmo == true)
596 {
597 pAtmoCtx->AtmoConfig.bTmoEn = pAtmoCtx->tmoAttr.stManual.stTmoManual.Enable;
598 pAtmoCtx->AtmoConfig.isLinearTmo = pAtmoCtx->AtmoConfig.bTmoEn && pAtmoCtx->FrameNumber == LINEAR_NUM;
599 pAtmoCtx->CurrData.HandleData.DetailsLowLight = pAtmoCtx->tmoAttr.stManual.stTmoManual.stDtlsLL * DETAILSLOWLIGHTMIN ;
600 pAtmoCtx->CurrData.HandleData.DetailsLowLight = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsLowLight
601 , DETAILSLOWLIGHTMAX, DETAILSLOWLIGHTMIN);
602
603 pAtmoCtx->CurrData.HandleData.DetailsHighLight = pAtmoCtx->tmoAttr.stManual.stTmoManual.stDtlsHL * DETAILSHIGHLIGHTMAX ;
604 pAtmoCtx->CurrData.HandleData.DetailsHighLight = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsHighLight
605 , DETAILSHIGHLIGHTMAX, DETAILSHIGHLIGHTMIN);
606
607 pAtmoCtx->CurrData.HandleData.LocalTmoStrength = pAtmoCtx->tmoAttr.stManual.stTmoManual.stLocalTMOStrength * TMOCONTRASTMAX;
608 pAtmoCtx->CurrData.HandleData.LocalTmoStrength = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.LocalTmoStrength
609 , TMOCONTRASTMAX, TMOCONTRASTMIN);
610
611 pAtmoCtx->CurrData.HandleData.GlobeLuma = pAtmoCtx->tmoAttr.stManual.stTmoManual.stGlobeLuma * GLOBELUMAMAX;
612 pAtmoCtx->CurrData.HandleData.GlobeLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeLuma
613 , GLOBELUMAMAX, GLOBELUMAMIN);
614
615 float GlobeLuma = pAtmoCtx->CurrData.HandleData.GlobeLuma;
616 pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = MAXLUMAK * GlobeLuma + MAXLUMAB;
617 pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
618 GLOBEMAXLUMAMAX, GLOBEMAXLUMAMIN);
619
620 pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = LIMIT_VALUE(pAtmoCtx->tmoAttr.stManual.stTmoManual.stGlobalTMOStrength,
621 1, 0);
622
623 pAtmoCtx->CurrData.CtrlData.TmoDamp = pAtmoCtx->tmoAttr.stManual.stTmoManual.damp;
624
625 }
626 else
627 ApiOffProcess(pAtmoCtx);
628
629 //paras after updating
630 LOGD_ATMO("%s: Current GlobeLuma:%f GlobeMaxLuma:%f DetailsHighLight:%f DetailsLowLight:%f GlobalTmoStrength:%f LocalTmoStrength:%f\n", __FUNCTION__,
631 pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma,
632 pAtmoCtx->CurrData.HandleData.DetailsHighLight, pAtmoCtx->CurrData.HandleData.DetailsLowLight,
633 pAtmoCtx->CurrData.HandleData.GlobalTmoStrength, pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
634
635 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
636 }
637
638 /******************************************************************************
639 * newMalloc()
640 ***************************************************************************/
newMalloc(AtmoConfig_t * pAtmoConfig,CalibDbV2_tmo_t * pCalibDb)641 void newMalloc
642 (
643 AtmoConfig_t* pAtmoConfig,
644 CalibDbV2_tmo_t* pCalibDb
645 ) {
646 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
647
648 // initial checks
649 DCT_ASSERT(pAtmoConfig != NULL);
650 DCT_ASSERT(pCalibDb != NULL);
651
652 if(pAtmoConfig->Luma.len != pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len) {
653 free(pAtmoConfig->Luma.EnvLv);
654 free(pAtmoConfig->Luma.ISO);
655 free(pAtmoConfig->Luma.GlobeLuma);
656 pAtmoConfig->Luma.len = pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
657 pAtmoConfig->Luma.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len));
658 pAtmoConfig->Luma.ISO = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO_len));
659 pAtmoConfig->Luma.GlobeLuma = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength_len));
660 }
661 if(pAtmoConfig->DtsHiLit.len != pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len) {
662 free(pAtmoConfig->DtsHiLit.OEPdf);
663 free(pAtmoConfig->DtsHiLit.EnvLv);
664 free(pAtmoConfig->DtsHiLit.DetailsHighLight);
665 pAtmoConfig->DtsHiLit.len = pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len;
666 pAtmoConfig->DtsHiLit.OEPdf = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len));
667 pAtmoConfig->DtsHiLit.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv_len));
668 pAtmoConfig->DtsHiLit.DetailsHighLight = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.Strength_len));
669 }
670 if(pAtmoConfig->DtsLoLit.len != pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len) {
671 free(pAtmoConfig->DtsLoLit.FocusLuma);
672 free(pAtmoConfig->DtsLoLit.DarkPdf);
673 free(pAtmoConfig->DtsLoLit.ISO);
674 free(pAtmoConfig->DtsLoLit.DetailsLowLight);
675 pAtmoConfig->DtsLoLit.len = pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len;
676 pAtmoConfig->DtsLoLit.FocusLuma = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len));
677 pAtmoConfig->DtsLoLit.DarkPdf = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf_len));
678 pAtmoConfig->DtsLoLit.ISO = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.ISO_len));
679 pAtmoConfig->DtsLoLit.DetailsLowLight = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.Strength_len));
680 }
681 if(pAtmoConfig->local.len != pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len) {
682 free(pAtmoConfig->local.DynamicRange);
683 free(pAtmoConfig->local.EnvLv);
684 free(pAtmoConfig->local.LocalTmoStrength);
685 pAtmoConfig->local.len = pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len;
686 pAtmoConfig->local.DynamicRange = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len));
687 pAtmoConfig->local.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv_len));
688 pAtmoConfig->local.LocalTmoStrength = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.Strength_len));
689
690 }
691 if(pAtmoConfig->global.len != pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len) {
692 free(pAtmoConfig->global.DynamicRange);
693 free(pAtmoConfig->global.EnvLv);
694 free(pAtmoConfig->global.GlobalTmoStrength);
695 pAtmoConfig->global.len = pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len;
696 pAtmoConfig->global.DynamicRange = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len));
697 pAtmoConfig->global.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv_len));
698 pAtmoConfig->global.GlobalTmoStrength = (float*)malloc(sizeof(float) * (pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength_len));
699 }
700
701 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
702 }
703
704 /******************************************************************************
705 * AtmoUpdateConfig()
706 *transfer html parameter into handle
707 ***************************************************************************/
AtmoUpdateConfig(AtmoHandle_t pAtmoCtx,CalibDbV2_tmo_t * pCalibDb)708 void AtmoUpdateConfig
709 (
710 AtmoHandle_t pAtmoCtx,
711 CalibDbV2_tmo_t* pCalibDb
712 ) {
713 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
714
715 // initial checks
716 DCT_ASSERT(pAtmoCtx != NULL);
717 DCT_ASSERT(pCalibDb != NULL);
718
719 pAtmoCtx->AtmoConfig.Luma.globalLumaMode = pCalibDb->TmoTuningPara.GlobalLuma.Mode;
720 pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode = pCalibDb->TmoTuningPara.DetailsLowLight.Mode;
721 pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode = pCalibDb->TmoTuningPara.DetailsHighLight.Mode;
722 pAtmoCtx->AtmoConfig.local.localtmoMode = pCalibDb->TmoTuningPara.LocalTMO.Mode;
723 pAtmoCtx->AtmoConfig.damp = LIMIT_VALUE(pCalibDb->TmoTuningPara.damp, DAMPMAX, DAMPMIN);
724 pAtmoCtx->AtmoConfig.Luma.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobalLuma.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
725 pAtmoCtx->AtmoConfig.DtsHiLit.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsHighLight.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
726 pAtmoCtx->AtmoConfig.DtsLoLit.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
727 pAtmoCtx->AtmoConfig.local.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.LocalTMO.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
728 for(int i = 0; i < pAtmoCtx->AtmoConfig.Luma.len; i++) {
729 pAtmoCtx->AtmoConfig.Luma.EnvLv[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv[i], ENVLVMAX, ENVLVMIN);
730 pAtmoCtx->AtmoConfig.Luma.ISO[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO[i], ISOMAX, ISOMIN);
731 pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength[i], IQPARAMAX, IQPARAMIN) ;
732 }
733 for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsHiLit.len; i++) {
734 pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf[i], OEPDFMAX, OEPDFMIN) ;
735 pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv[i], ENVLVMAX, ENVLVMIN);
736 pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsHighLight.HighLightData.Strength[i], IQPARAMAX, IQPARAMIN) ;
737 }
738 for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsLoLit.len; i++) {
739 pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma[i], FOCUSLUMAMAX, FOCUSLUMAMIN) ;
740 pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf[i], DARKPDFMAX, DARKPDFMIN) ;
741 pAtmoCtx->AtmoConfig.DtsLoLit.ISO[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.ISO[i], ISOMAX, ISOMIN) ;
742 pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.DetailsLowLight.LowLightData.Strength[i], IQDETAILSLOWLIGHTMAX, IQDETAILSLOWLIGHTMIN) ;
743 }
744 for(int i = 0; i < pAtmoCtx->AtmoConfig.local.len; i++) {
745 pAtmoCtx->AtmoConfig.local.DynamicRange[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange[i], DYNAMICRANGEMAX, DYNAMICRANGEMIN) ;
746 pAtmoCtx->AtmoConfig.local.EnvLv[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv[i], ENVLVMAX, ENVLVMIN) ;
747 pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.LocalTMO.LocalTmoData.Strength[i], IQPARAMAX, IQPARAMIN) ;
748 }
749
750 //Global Tmo
751 pAtmoCtx->AtmoConfig.global.isHdrGlobalTmo = pCalibDb->TmoTuningPara.GlobaTMO.Enable;
752 pAtmoCtx->AtmoConfig.global.mode = pCalibDb->TmoTuningPara.GlobaTMO.Mode;
753 pAtmoCtx->AtmoConfig.global.Tolerance = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.Tolerance, TOLERANCEMAX, TOLERANCEMIN);
754 for(int i = 0; i < pAtmoCtx->AtmoConfig.global.len; i++) {
755 pAtmoCtx->AtmoConfig.global.DynamicRange[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange[i], DYNAMICRANGEMAX, DYNAMICRANGEMIN) ;
756 pAtmoCtx->AtmoConfig.global.EnvLv[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv[i], ENVLVMAX, ENVLVMIN) ;
757 pAtmoCtx->AtmoConfig.global.GlobalTmoStrength[i] = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength[i], IQPARAMAX, IQPARAMIN) ;
758 }
759 pAtmoCtx->AtmoConfig.global.iir = LIMIT_VALUE(pCalibDb->TmoTuningPara.GlobaTMO.IIR, IIRMAX, IIRMIN);
760
761 //tmo En
762 if(pAtmoCtx->FrameNumber == HDR_2X_NUM || pAtmoCtx->FrameNumber == HDR_3X_NUM) {
763 pAtmoCtx->AtmoConfig.bTmoEn = true;
764 pAtmoCtx->AtmoConfig.isLinearTmo = false;
765 }
766 else if(pAtmoCtx->FrameNumber == LINEAR_NUM)
767 {
768 pAtmoCtx->AtmoConfig.bTmoEn = pCalibDb->TmoTuningPara.Enable;
769 pAtmoCtx->AtmoConfig.isLinearTmo = pAtmoCtx->AtmoConfig.bTmoEn;
770 }
771
772 for(int i = 0; i < pAtmoCtx->AtmoConfig.Luma.len; i++)
773 LOG1_ATMO("%s: mode:%d Globalluma[%d]:%f EnvLv[%d]:%f ISO[%d]:%f Tolerance:%f\n", __FUNCTION__,
774 pAtmoCtx->AtmoConfig.Luma.globalLumaMode, i, pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i],
775 i, pAtmoCtx->AtmoConfig.Luma.EnvLv[i], i, pAtmoCtx->AtmoConfig.Luma.ISO[i], pAtmoCtx->AtmoConfig.Luma.Tolerance);
776
777 for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsHiLit.len; i++)
778 LOG1_ATMO("%s: mode:%d DetailsHighLight[%d]:%f OEPdf[%d]:%f EnvLv[%d]:%f Tolerance:%f\n", __FUNCTION__,
779 pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode, i, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i],
780 i, pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf[i], i, pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv[i], pAtmoCtx->AtmoConfig.DtsHiLit.Tolerance);
781
782 for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsLoLit.len; i++)
783 LOG1_ATMO("%s: mode:%d DetailsLowLight[%d]:%f FocusLuma[%d]:%f DarkPdf[%d]:%f ISO[%d]:%f Tolerance:%f\n", __FUNCTION__,
784 pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode, i, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i],
785 i, pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma[i], i, pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf[i],
786 i, pAtmoCtx->AtmoConfig.DtsLoLit.ISO[i], pAtmoCtx->AtmoConfig.DtsLoLit.Tolerance);
787
788 for(int i = 0; i < pAtmoCtx->AtmoConfig.local.len; i++)
789 LOG1_ATMO("%s: mode:%d LocalTmoStrength[%d]:%f DynamicRange[%d]:%f EnvLv[%d]:%f Tolerance:%f\n", __FUNCTION__,
790 pAtmoCtx->AtmoConfig.local.localtmoMode, i, pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i],
791 i, pAtmoCtx->AtmoConfig.local.DynamicRange[i], i, pAtmoCtx->AtmoConfig.local.EnvLv[i], pAtmoCtx->AtmoConfig.local.Tolerance);
792
793 LOGD_ATMO("%s: Tmo En:%d linear Tmo en:%d\n", __FUNCTION__, pAtmoCtx->AtmoConfig.bTmoEn, pAtmoCtx->AtmoConfig.isLinearTmo);
794 LOG1_ATMO("%s: GlobalTmo En:%d IIR:%f\n", __FUNCTION__, pCalibDb->TmoTuningPara.GlobaTMO.Enable, pAtmoCtx->AtmoConfig.global.iir);
795 for(int i = 0; i < pAtmoCtx->AtmoConfig.global.len; i++)
796 LOG1_ATMO("%s: mode:%d GlobalTmoStrength[%d]:%f DynamicRange[%d]:%f EnvLv[%d]:%f Tolerance:%f\n", __FUNCTION__,
797 pAtmoCtx->AtmoConfig.global.mode, i, pAtmoCtx->AtmoConfig.global.GlobalTmoStrength[i],
798 i, pAtmoCtx->AtmoConfig.global.DynamicRange[i], i, pAtmoCtx->AtmoConfig.global.EnvLv[i], pAtmoCtx->AtmoConfig.global.Tolerance);
799
800 //turn the IQ paras into algo paras
801 for(int i = 0; i < pAtmoCtx->AtmoConfig.Luma.len; i++) {
802 pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i] = pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i] * GLOBELUMAMAX;
803 pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i] = LIMIT_VALUE(pAtmoCtx->AtmoConfig.Luma.GlobeLuma[i], GLOBELUMAMAX, GLOBELUMAMIN) ;
804 }
805 for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsHiLit.len; i++) {
806 pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i] = pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i] * DETAILSHIGHLIGHTMAX;
807 pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i] = LIMIT_VALUE(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight[i], DETAILSHIGHLIGHTMAX, DETAILSHIGHLIGHTMIN) ;
808 }
809 for(int i = 0; i < pAtmoCtx->AtmoConfig.DtsLoLit.len; i++) {
810 pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i] = pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i] * DETAILSLOWLIGHTMIN;
811 pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i] = LIMIT_VALUE(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight[i], DETAILSLOWLIGHTMAX, DETAILSLOWLIGHTMIN) ;
812 }
813 for(int i = 0; i < pAtmoCtx->AtmoConfig.local.len; i++) {
814 pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i] = pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i] * TMOCONTRASTMAX;
815 pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i] = LIMIT_VALUE(pAtmoCtx->AtmoConfig.local.LocalTmoStrength[i], TMOCONTRASTMAX, TMOCONTRASTMIN) ;
816 }
817
818 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
819 }
820
821 /******************************************************************************
822 * GetSetLgmean()
823 *****************************************************************************/
GetSetLgmean(AtmoHandle_t pAtmoCtx)824 unsigned short GetSetLgmean(AtmoHandle_t pAtmoCtx)
825 {
826 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
827
828 float value = 0;
829 float value_default = 20000;
830 unsigned short returnValue;
831 int iir_frame = 0;
832
833 if(pAtmoCtx->AtmoConfig.global.iir < IIRMAX) {
834 iir_frame = (int)(pAtmoCtx->AtmoConfig.global.iir);
835 int iir_frame_real = MIN(pAtmoCtx->frameCnt + 1, iir_frame);
836
837 float PrevLgMean = pAtmoCtx->PrevData.ro_hdrtmo_lgmean / 2048.0;
838 float CurrLgMean = pAtmoCtx->CurrData.CtrlData.LgMean;
839
840 CurrLgMean *= 1 + 0.5 - pAtmoCtx->CurrData.HandleData.GlobalTmoStrength;
841 value_default *= 1 + 0.5 - pAtmoCtx->CurrData.HandleData.GlobalTmoStrength;
842
843 value = pAtmoCtx->frameCnt == 0 ? value_default :
844 (iir_frame_real - 1) * PrevLgMean / iir_frame_real + CurrLgMean / iir_frame_real;
845 returnValue = (int)SHIFT11BIT(value) ;
846 }
847 else
848 returnValue = value_default;
849
850 LOG1_ATMO( "%s: frameCnt:%d iir_frame:%d set_lgmean_float:%f set_lgmean_return:%d\n", __FUNCTION__,
851 pAtmoCtx->frameCnt, iir_frame, value, returnValue);
852
853 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
854
855 return returnValue;
856 }
857 /******************************************************************************
858 * GetSetLgAvgMax()
859 *****************************************************************************/
GetSetLgAvgMax(AtmoHandle_t pAtmoCtx,float set_lgmin,float set_lgmax)860 unsigned short GetSetLgAvgMax(AtmoHandle_t pAtmoCtx, float set_lgmin, float set_lgmax)
861 {
862 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
863 float WeightKey = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_weightkey / 256.0;
864 float value = 0.0;
865 float set_lgmean = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean / 2048.0;
866 float lgrange1 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange1 / 2048.0;
867 unsigned short returnValue;
868
869 value = WeightKey * set_lgmax + (1 - WeightKey) * set_lgmean;
870 value = MIN(value, lgrange1);
871 returnValue = (int)SHIFT11BIT(value);
872
873 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);
874
875 return returnValue;
876 LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
877
878 }
879 /******************************************************************************
880 * GetSetLgRange0()
881 *****************************************************************************/
GetSetLgRange0(AtmoHandle_t pAtmoCtx,float set_lgmin,float set_lgmax)882 unsigned short GetSetLgRange0(AtmoHandle_t pAtmoCtx, float set_lgmin, float set_lgmax)
883 {
884 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
885 float value = 0.0;
886 float clipratio0 = (float)(pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio0) / 256.0;
887 float clipgap0 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap0 / 4.0;
888 unsigned short returnValue;
889
890
891 value = set_lgmin * (1 - clipratio0) + set_lgmax * clipratio0;
892 value = MIN(value, (set_lgmin + clipgap0));
893 returnValue = (int)SHIFT11BIT(value);
894
895 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);
896
897 return returnValue;
898 LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
899
900 }
901 /******************************************************************************
902 * GetSetLgRange1()
903 *****************************************************************************/
GetSetLgRange1(AtmoHandle_t pAtmoCtx,float set_lgmin,float set_lgmax)904 unsigned short GetSetLgRange1(AtmoHandle_t pAtmoCtx, float set_lgmin, float set_lgmax)
905 {
906 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
907 float value = 0.0;
908 float clipratio1 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio1 / 256.0;
909 float clipgap1 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap1 / 4.0;
910 unsigned short returnValue;
911
912 value = set_lgmin * (1 - clipratio1) + set_lgmax * clipratio1;
913 value = MAX(value, (set_lgmax - clipgap1));
914 returnValue = (int)SHIFT11BIT(value);
915
916 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);
917
918 return returnValue;
919 LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
920
921 }
922 /******************************************************************************
923 * GetSetPalhpa()
924 *****************************************************************************/
GetSetPalhpa(AtmoHandle_t pAtmoCtx,float set_lgmin,float set_lgmax)925 unsigned short GetSetPalhpa(AtmoHandle_t pAtmoCtx, float set_lgmin, float set_lgmax)
926 {
927 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
928
929 float index = 0.0;
930 float value = 0.0;
931 float set_lgmean = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean / 2048.0;
932 float palpha_0p18 = pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_0p18 / 1024.0;
933 int value_int = 0;
934 unsigned short returnValue;
935
936 index = 2 * set_lgmean - set_lgmin - set_lgmax;
937 index = index / (set_lgmax - set_lgmin);
938 value = palpha_0p18 * pow(4, index);
939 value_int = (int)SHIFT10BIT(value);
940 value_int = MIN(value_int, pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxpalpha);
941 returnValue = value_int;
942
943 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);
944
945 return returnValue;
946 LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
947
948 }
949
950 /******************************************************************************
951 * GetCurrIOData()
952 *****************************************************************************/
TmoGetCurrIOData(AtmoHandle_t pAtmoCtx)953 void TmoGetCurrIOData
954 (
955 AtmoHandle_t pAtmoCtx
956 )
957 {
958 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
959
960 //default IO data
961 pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio0 = 64;
962 pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio1 = 166;
963 pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap0 = 12;
964 pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap1 = 12;
965 pAtmoCtx->ProcRes.Res.sw_hdrtmo_ratiol = 32;
966 pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_high = (int)(pAtmoCtx->height * pAtmoCtx->width * 0.01 / 16);
967 pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_min = 0;
968 pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_low = 0;
969 pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_0p3 = 0;
970 pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_shift = 3;
971 pAtmoCtx->ProcRes.Res.sw_hdrtmo_gain_ld_off1 = 10;
972 pAtmoCtx->ProcRes.Res.sw_hdrtmo_gain_ld_off2 = 5;
973 pAtmoCtx->ProcRes.Res.sw_hdrtmo_newhist_en = 1;
974 pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_mode = 1;
975 pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_vsize = (int)(pAtmoCtx->height - 256);
976 pAtmoCtx->ProcRes.Res.sw_hdrtmo_cfg_alpha = 255;
977
978 //IO data from IQ
979 pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxpalpha = (int)(pAtmoCtx->CurrData.HandleData.GlobeMaxLuma + 0.5);
980 pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_0p18 = (int)(pAtmoCtx->CurrData.HandleData.GlobeLuma + 0.5);
981 pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_lw0p5 = (int)(pAtmoCtx->CurrData.HandleData.DetailsHighLight + 0.5);
982 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_weightkey = (int)(pAtmoCtx->CurrData.HandleData.LocalTmoStrength + 0.5);
983
984 float lwscl = pAtmoCtx->CurrData.HandleData.DetailsLowLight;
985 pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_lwscl = (int)(lwscl + 0.5);
986 pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxgain = (int)(SHIFT12BIT(lwscl / 16) + 0.5);
987
988
989 //calc other IO data
990 pAtmoCtx->ProcRes.Res.sw_hdrtmo_big_en = pAtmoCtx->width > BIGMODE ? 1 : 0;
991 pAtmoCtx->ProcRes.Res.sw_hdrtmo_nobig_en = (int)(1 - pAtmoCtx->ProcRes.Res.sw_hdrtmo_big_en);
992 pAtmoCtx->ProcRes.Res.sw_hdrtmo_expl_lgratio = (int)SHIFT11BIT(log(pAtmoCtx->PrevData.CtrlData.LExpo / pAtmoCtx->CurrData.CtrlData.LExpo) / log(2));
993 if(pAtmoCtx->AtmoConfig.isLinearTmo)
994 pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_ratio = 128;
995 else
996 pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_ratio = (int)SHIFT7BIT(log(pAtmoCtx->CurrData.CtrlData.L2S_Ratio) / log(pAtmoCtx->PrevData.CtrlData.L2S_ratio));
997 float lgmax = 12 + log(pAtmoCtx->CurrData.CtrlData.L2S_Ratio) / log(2);
998 pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgmax = (int)SHIFT11BIT(lgmax);
999 pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl = (int)SHIFT12BIT(16 / lgmax);
1000 pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_inv = (int)SHIFT12BIT(lgmax / 16);
1001 float set_lgmin = 0;
1002 float set_lgmax = lgmax;
1003 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmin = (int)SHIFT11BIT(set_lgmin) ;
1004 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmax = pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgmax;
1005 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_gainoff = pow(2, set_lgmin);
1006 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean = GetSetLgmean(pAtmoCtx);
1007 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange0 = GetSetLgRange0(pAtmoCtx, set_lgmin, set_lgmax);
1008 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange1 = GetSetLgRange1(pAtmoCtx, set_lgmin, set_lgmax);
1009 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgavgmax = GetSetLgAvgMax(pAtmoCtx, set_lgmin, set_lgmax);
1010 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_palpha = GetSetPalhpa(pAtmoCtx, set_lgmin, set_lgmax);
1011
1012
1013 //for avoid tmo flicker
1014 pAtmoCtx->ProcRes.TmoFlicker.cnt_mode = pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_mode;
1015 pAtmoCtx->ProcRes.TmoFlicker.cnt_vsize = pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_vsize;
1016 if(pAtmoCtx->CurrData.HandleData.GlobalTmoStrength > 0.5)
1017 pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrengthDown = false;
1018 else
1019 pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrengthDown = true;
1020 pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength = pAtmoCtx->CurrData.HandleData.GlobalTmoStrength - 0.5;
1021 pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength = pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength < 0 ? (1 - pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength)
1022 : (1 + pAtmoCtx->ProcRes.TmoFlicker.GlobalTmoStrength);
1023 pAtmoCtx->ProcRes.TmoFlicker.iir = (int)(pAtmoCtx->AtmoConfig.global.iir) +
1024 3 * pAtmoCtx->CurrAeResult.AecDelayframe;
1025 pAtmoCtx->ProcRes.TmoFlicker.iirmax = IIRMAX;
1026 pAtmoCtx->ProcRes.TmoFlicker.height = pAtmoCtx->height;
1027 pAtmoCtx->ProcRes.TmoFlicker.width = pAtmoCtx->width;
1028 pAtmoCtx->ProcRes.TmoFlicker.PredictK.correction_factor = 1.05;
1029 pAtmoCtx->ProcRes.TmoFlicker.PredictK.correction_offset = 0;
1030 pAtmoCtx->ProcRes.TmoFlicker.PredictK.Hdr3xLongPercent = 0.5;
1031 pAtmoCtx->ProcRes.TmoFlicker.PredictK.UseLongLowTh = 1.02;
1032 pAtmoCtx->ProcRes.TmoFlicker.PredictK.UseLongUpTh = 0.98;
1033 if(pAtmoCtx->FrameNumber == LINEAR_NUM)
1034 pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[0] = pAtmoCtx->CurrAeResult.LumaDeviationLinear;
1035 else if(pAtmoCtx->FrameNumber == HDR_2X_NUM) {
1036 pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[0] = pAtmoCtx->CurrAeResult.LumaDeviationS;
1037 pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[1] = pAtmoCtx->CurrAeResult.LumaDeviationL;
1038 }
1039 else if(pAtmoCtx->FrameNumber == HDR_3X_NUM) {
1040 pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[0] = pAtmoCtx->CurrAeResult.LumaDeviationS;
1041 pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[1] = pAtmoCtx->CurrAeResult.LumaDeviationM;
1042 pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[2] = pAtmoCtx->CurrAeResult.LumaDeviationL;
1043 }
1044 pAtmoCtx->ProcRes.TmoFlicker.StableThr = 0.1;
1045
1046 LOGV_ATMO("%s: Tmo set IOdata to register:\n", __FUNCTION__);
1047 LOGV_ATMO("%s: float lgmax:%f\n", __FUNCTION__, lgmax);
1048 LOGV_ATMO("%s: sw_hdrtmo_lgmax:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgmax);
1049 LOGV_ATMO("%s: sw_hdrtmo_lgscl:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl);
1050 LOGV_ATMO("%s: sw_hdrtmo_lgscl_inv:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_inv);
1051 LOGV_ATMO("%s: sw_hdrtmo_clipratio0:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio0);
1052 LOGV_ATMO("%s: sw_hdrtmo_clipratio1:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipratio1);
1053 LOGV_ATMO("%s: sw_hdrtmo_clipgap0:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap0);
1054 LOGV_ATMO("%s: sw_hdrtmo_clipgap:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_clipgap1);
1055 LOGV_ATMO("%s: sw_hdrtmo_ratiol:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_ratiol);
1056 LOGV_ATMO("%s: sw_hdrtmo_hist_min:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_min);
1057 LOGV_ATMO("%s: sw_hdrtmo_hist_low:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_low);
1058 LOGV_ATMO("%s: sw_hdrtmo_hist_high:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_high);
1059 LOGV_ATMO("%s: sw_hdrtmo_hist_0p3:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_0p3);
1060 LOGV_ATMO("%s: sw_hdrtmo_hist_shift:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_hist_shift);
1061 LOGV_ATMO("%s: sw_hdrtmo_palpha_0p18:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_0p18);
1062 LOGV_ATMO("%s: sw_hdrtmo_palpha_lw0p5:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_lw0p5);
1063 LOGV_ATMO("%s: sw_hdrtmo_palpha_lwscl:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_palpha_lwscl);
1064 LOGV_ATMO("%s: sw_hdrtmo_maxpalpha:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxpalpha);
1065 LOGV_ATMO("%s: sw_hdrtmo_maxgain:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_maxgain);
1066 LOGV_ATMO("%s: sw_hdrtmo_cfg_alpha:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_cfg_alpha);
1067 LOGV_ATMO("%s: sw_hdrtmo_set_gainoff:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_gainoff);
1068 LOGV_ATMO("%s: sw_hdrtmo_set_lgmin:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmin);
1069 LOGV_ATMO("%s: sw_hdrtmo_set_lgmax:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmax);
1070 LOGV_ATMO("%s: sw_hdrtmo_set_lgmean:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean);
1071 LOGV_ATMO("%s: sw_hdrtmo_set_weightkey:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_weightkey);
1072 LOGV_ATMO("%s: sw_hdrtmo_set_lgrange0:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange0);
1073 LOGV_ATMO("%s: sw_hdrtmo_set_lgrange1:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgrange1);
1074 LOGV_ATMO("%s: sw_hdrtmo_set_lgavgmax:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgavgmax);
1075 LOGV_ATMO("%s: sw_hdrtmo_set_palpha:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_palpha);
1076 LOGV_ATMO("%s: sw_hdrtmo_big_en:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_big_en);
1077 LOGV_ATMO("%s: sw_hdrtmo_nobig_en:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_nobig_en);
1078 LOGV_ATMO("%s: sw_hdrtmo_newhist_en:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_newhist_en);
1079 LOGV_ATMO("%s: sw_hdrtmo_cnt_mode:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_mode);
1080 LOGV_ATMO("%s: sw_hdrtmo_cnt_vsize:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_cnt_vsize);
1081 LOGV_ATMO("%s: sw_hdrtmo_expl_lgratio:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_expl_lgratio);
1082 LOGV_ATMO("%s: sw_hdrtmo_lgscl_ratio:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_lgscl_ratio);
1083 LOGV_ATMO("%s: sw_hdrtmo_gain_ld_off1:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_gain_ld_off1);
1084 LOGV_ATMO("%s: sw_hdrtmo_gain_ld_off2:%d\n", __FUNCTION__, pAtmoCtx->ProcRes.Res.sw_hdrtmo_gain_ld_off2);
1085 LOGV_ATMO("%s: LumaDeviation:%f %f %f\n", __FUNCTION__, pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[0],
1086 pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[1], pAtmoCtx->ProcRes.TmoFlicker.LumaDeviation[2]);
1087
1088 LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
1089 }
1090
1091 /******************************************************************************
1092 * TmoDamp()
1093 *****************************************************************************/
TmoDamp(AtmoHandle_t pAtmoCtx)1094 void TmoDamp
1095 (
1096 AtmoHandle_t pAtmoCtx
1097 )
1098 {
1099 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
1100 float tmo_damp = pAtmoCtx->CurrData.CtrlData.TmoDamp;
1101
1102 bool enDampLuma;
1103 bool enDampDtlsHighLgt;
1104 bool enDampDtlslowLgt;
1105 bool enDampLocal;
1106 bool enDampGlobal;
1107 bool ifHDRModeChange = pAtmoCtx->CurrData.CtrlData.FrameCnt == pAtmoCtx->PrevData.CtrlData.FrameCnt ? false : true;
1108
1109 if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_API_OFF && pAtmoCtx->frameCnt != 0 && !ifHDRModeChange)
1110 {
1111 float diff = 0;
1112
1113 if(pAtmoCtx->AtmoConfig.Luma.globalLumaMode == GLOBALLUMAMODE_ENVLV)
1114 {
1115 diff = ABS(pAtmoCtx->CurrData.CtrlData.EnvLv - pAtmoCtx->PrevData.CtrlData.EnvLv);
1116 diff = diff / pAtmoCtx->PrevData.CtrlData.EnvLv;
1117 }
1118 else if(pAtmoCtx->AtmoConfig.Luma.globalLumaMode == GLOBALLUMAMODE_ISO)
1119 {
1120 diff = ABS(pAtmoCtx->CurrData.CtrlData.ISO - pAtmoCtx->PrevData.CtrlData.ISO);
1121 diff = diff / pAtmoCtx->PrevData.CtrlData.ISO;
1122 }
1123 if (diff < pAtmoCtx->AtmoConfig.Luma.Tolerance)
1124 enDampLuma = false;
1125 else
1126 enDampLuma = true;
1127
1128 if(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode == DETAILSHIGHLIGHTMODE_OEPDF)
1129 {
1130 diff = ABS(pAtmoCtx->CurrData.CtrlData.OEPdf - pAtmoCtx->PrevData.CtrlData.OEPdf);
1131 diff = diff / pAtmoCtx->PrevData.CtrlData.OEPdf;
1132 }
1133 else if(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode == DETAILSHIGHLIGHTMODE_ENVLV)
1134 {
1135 diff = ABS(pAtmoCtx->CurrData.CtrlData.EnvLv - pAtmoCtx->PrevData.CtrlData.EnvLv);
1136 diff = diff / pAtmoCtx->PrevData.CtrlData.EnvLv;
1137 }
1138 if (diff < pAtmoCtx->AtmoConfig.DtsHiLit.Tolerance)
1139 enDampDtlsHighLgt = false;
1140 else
1141 enDampDtlsHighLgt = true;
1142
1143 if(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_FOCUSLUMA)
1144 {
1145 diff = ABS(pAtmoCtx->CurrData.CtrlData.FocusLuma - pAtmoCtx->PrevData.CtrlData.FocusLuma);
1146 diff = diff / pAtmoCtx->PrevData.CtrlData.FocusLuma;
1147 }
1148 else if(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_DARKPDF)
1149 {
1150 diff = ABS(pAtmoCtx->CurrData.CtrlData.DarkPdf - pAtmoCtx->PrevData.CtrlData.DarkPdf);
1151 diff = diff / pAtmoCtx->PrevData.CtrlData.DarkPdf;
1152 }
1153 else if(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode == DETAILSLOWLIGHTMODE_ISO)
1154 {
1155 diff = ABS(pAtmoCtx->CurrData.CtrlData.ISO - pAtmoCtx->PrevData.CtrlData.ISO);
1156 diff = diff / pAtmoCtx->PrevData.CtrlData.ISO;
1157 }
1158 if (diff < pAtmoCtx->AtmoConfig.DtsLoLit.Tolerance)
1159 enDampDtlslowLgt = false;
1160 else
1161 enDampDtlslowLgt = true;
1162
1163 if(pAtmoCtx->AtmoConfig.local.localtmoMode == TMOTYPEMODE_DYNAMICRANGE) {
1164 diff = ABS(pAtmoCtx->CurrData.CtrlData.DynamicRange - pAtmoCtx->PrevData.CtrlData.DynamicRange);
1165 diff = diff / pAtmoCtx->PrevData.CtrlData.DynamicRange;
1166 }
1167 else if(pAtmoCtx->AtmoConfig.local.localtmoMode == TMOTYPEMODE_ENVLV)
1168 {
1169 diff = ABS(pAtmoCtx->CurrData.CtrlData.EnvLv - pAtmoCtx->PrevData.CtrlData.EnvLv);
1170 diff = diff / pAtmoCtx->PrevData.CtrlData.EnvLv;
1171 }
1172 if (diff < pAtmoCtx->AtmoConfig.local.Tolerance)
1173 enDampLocal = false;
1174 else
1175 enDampLocal = true;
1176
1177 if(pAtmoCtx->AtmoConfig.global.mode == TMOTYPEMODE_DYNAMICRANGE) {
1178 diff = ABS(pAtmoCtx->CurrData.CtrlData.DynamicRange - pAtmoCtx->PrevData.CtrlData.DynamicRange);
1179 diff = diff / pAtmoCtx->PrevData.CtrlData.DynamicRange;
1180 }
1181 else if(pAtmoCtx->AtmoConfig.global.mode == TMOTYPEMODE_ENVLV)
1182 {
1183 diff = ABS(pAtmoCtx->CurrData.CtrlData.EnvLv - pAtmoCtx->PrevData.CtrlData.EnvLv);
1184 diff = diff / pAtmoCtx->PrevData.CtrlData.EnvLv;
1185 }
1186 if (diff < pAtmoCtx->AtmoConfig.global.Tolerance)
1187 enDampGlobal = false;
1188 else
1189 enDampGlobal = true;
1190
1191
1192 //get finnal cfg data by damp
1193 if (enDampLuma == true)
1194 {
1195 pAtmoCtx->CurrData.HandleData.GlobeMaxLuma = tmo_damp * pAtmoCtx->CurrData.HandleData.GlobeMaxLuma
1196 + (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.GlobeMaxLuma;
1197 pAtmoCtx->CurrData.HandleData.GlobeLuma = tmo_damp * pAtmoCtx->CurrData.HandleData.GlobeLuma
1198 + (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.GlobeLuma;
1199 }
1200
1201 if (enDampDtlsHighLgt == true)
1202 pAtmoCtx->CurrData.HandleData.DetailsHighLight = tmo_damp * pAtmoCtx->CurrData.HandleData.DetailsHighLight
1203 + (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.DetailsHighLight;
1204
1205 if (enDampDtlslowLgt == true)
1206 pAtmoCtx->CurrData.HandleData.DetailsLowLight = tmo_damp * pAtmoCtx->CurrData.HandleData.DetailsLowLight
1207 + (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.DetailsLowLight;
1208
1209 if (enDampLocal == true)
1210 pAtmoCtx->CurrData.HandleData.LocalTmoStrength = tmo_damp * pAtmoCtx->CurrData.HandleData.LocalTmoStrength
1211 + (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.LocalTmoStrength;
1212
1213 if (enDampGlobal == true)
1214 pAtmoCtx->CurrData.HandleData.GlobalTmoStrength = tmo_damp * pAtmoCtx->CurrData.HandleData.GlobalTmoStrength
1215 + (1 - tmo_damp) * pAtmoCtx->PrevData.HandleData.GlobalTmoStrength;
1216
1217 }
1218
1219 LOGD_ATMO("%s:Current damp GlobeLuma:%f GlobeMaxLuma:%f DetailsHighLight:%f DetailsLowLight:%f LocalTmoStrength:%f GlobalTmoStrength:%f\n", __FUNCTION__, pAtmoCtx->CurrData.HandleData.GlobeLuma
1220 , pAtmoCtx->CurrData.HandleData.GlobeMaxLuma, pAtmoCtx->CurrData.HandleData.DetailsHighLight, pAtmoCtx->CurrData.HandleData.DetailsLowLight
1221 , pAtmoCtx->CurrData.HandleData.LocalTmoStrength, pAtmoCtx->CurrData.HandleData.GlobalTmoStrength);
1222
1223 LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
1224 }
1225 /******************************************************************************
1226 * SetGlobalTMO()
1227 *****************************************************************************/
SetGlobalTMO(AtmoHandle_t pAtmoCtx)1228 bool SetGlobalTMO
1229 (
1230 AtmoHandle_t pAtmoCtx
1231 ) {
1232
1233 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
1234
1235 bool returnValue = false;
1236
1237 if(pAtmoCtx->AtmoConfig.global.isHdrGlobalTmo == true) {
1238 returnValue = true;
1239 pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_weightkey = 0;
1240 }
1241
1242 else
1243 returnValue = false;
1244
1245 LOGD_ATMO("%s: set GlobalTMO:%d\n", __FUNCTION__, returnValue);
1246
1247 return returnValue;
1248
1249 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
1250 }
1251
1252 /******************************************************************************
1253 * AhdrGetProcRes()
1254 *****************************************************************************/
AtmoGetProcRes(AtmoHandle_t pAtmoCtx)1255 void AtmoGetProcRes
1256 (
1257 AtmoHandle_t pAtmoCtx
1258 ) {
1259
1260 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
1261
1262 //tmo para damp
1263 TmoDamp(pAtmoCtx);
1264
1265 //tmo enable
1266 pAtmoCtx->ProcRes.bTmoEn = pAtmoCtx->AtmoConfig.bTmoEn;
1267 pAtmoCtx->ProcRes.isLinearTmo = pAtmoCtx->AtmoConfig.isLinearTmo;
1268
1269 //get tmo proc res
1270 TmoGetCurrIOData(pAtmoCtx);
1271
1272 // Set Global TMO
1273 pAtmoCtx->ProcRes.isHdrGlobalTmo = SetGlobalTMO(pAtmoCtx);
1274
1275 // store current handle data to pre data for next loop
1276 pAtmoCtx->PrevData.HandleData.MergeMode = pAtmoCtx->CurrData.HandleData.MergeMode;
1277 pAtmoCtx->PrevData.ro_hdrtmo_lgmean = pAtmoCtx->ProcRes.Res.sw_hdrtmo_set_lgmean;
1278 pAtmoCtx->PrevData.CtrlData.L2S_ratio = pAtmoCtx->CurrData.CtrlData.L2S_Ratio;
1279 pAtmoCtx->PrevData.CtrlData.LExpo = pAtmoCtx->CurrData.CtrlData.LExpo;
1280 pAtmoCtx->PrevData.CtrlData.EnvLv = pAtmoCtx->CurrData.CtrlData.EnvLv;
1281 pAtmoCtx->PrevData.CtrlData.OEPdf = pAtmoCtx->CurrData.CtrlData.OEPdf;
1282 pAtmoCtx->PrevData.CtrlData.FocusLuma = pAtmoCtx->CurrData.CtrlData.FocusLuma;
1283 pAtmoCtx->PrevData.CtrlData.DarkPdf = pAtmoCtx->CurrData.CtrlData.DarkPdf;
1284 pAtmoCtx->PrevData.CtrlData.ISO = pAtmoCtx->CurrData.CtrlData.ISO;
1285 pAtmoCtx->PrevData.CtrlData.DynamicRange = pAtmoCtx->CurrData.CtrlData.DynamicRange;
1286 memcpy(&pAtmoCtx->PrevData.HandleData, &pAtmoCtx->CurrData.HandleData, sizeof(TmoHandleData_s));
1287 ++pAtmoCtx->frameCnt;
1288
1289 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
1290 }
1291
1292 /******************************************************************************
1293 * AtmoProcessing()
1294 *get handle para by config and current variate
1295 *****************************************************************************/
AtmoProcessing(AtmoHandle_t pAtmoCtx,AecPreResult_t AecHdrPreResult,af_preprocess_result_t AfPreResult)1296 void AtmoProcessing
1297 (
1298 AtmoHandle_t pAtmoCtx,
1299 AecPreResult_t AecHdrPreResult,
1300 af_preprocess_result_t AfPreResult
1301 )
1302 {
1303 LOG1_ATMO("%s:enter!\n", __FUNCTION__);
1304 LOGD_ATMO("%s: Atmo Current frame cnt:%d:\n", __FUNCTION__, pAtmoCtx->frameCnt);
1305 pAtmoCtx->CurrData.CtrlData.FrameCnt = pAtmoCtx->frameCnt;
1306
1307 //get current ae data from AecPreRes
1308 AtmoGetAeResult(pAtmoCtx, AecHdrPreResult);
1309
1310 //transfer ae data to CurrHandle
1311 pAtmoCtx->CurrData.CtrlData.EnvLv = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.EnvLv, ENVLVMAX, ENVLVMIN);
1312
1313 pAtmoCtx->CurrData.CtrlData.ISO = pAtmoCtx->CurrAeResult.ISO;
1314 pAtmoCtx->CurrData.CtrlData.ISO = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.ISO, ISOMAX, ISOMIN);
1315
1316 pAtmoCtx->CurrData.CtrlData.OEPdf = pAtmoCtx->CurrAeResult.OEPdf;
1317 pAtmoCtx->CurrData.CtrlData.OEPdf = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.OEPdf, OEPDFMAX, OEPDFMIN);
1318
1319 pAtmoCtx->CurrData.CtrlData.FocusLuma = 1;
1320 pAtmoCtx->CurrData.CtrlData.FocusLuma = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.FocusLuma, FOCUSLUMAMAX, FOCUSLUMAMIN);
1321
1322 pAtmoCtx->CurrData.CtrlData.DarkPdf = pAtmoCtx->CurrAeResult.DarkPdf;
1323 pAtmoCtx->CurrData.CtrlData.DarkPdf = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.DarkPdf, DARKPDFTHMAX, DARKPDFTHMIN);
1324
1325 pAtmoCtx->CurrData.CtrlData.DynamicRange = pAtmoCtx->CurrAeResult.DynamicRange;
1326 pAtmoCtx->CurrData.CtrlData.DynamicRange = LIMIT_VALUE(pAtmoCtx->CurrData.CtrlData.DynamicRange, DYNAMICRANGEMAX, DYNAMICRANGEMIN);
1327
1328 if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_API_OFF) {
1329 LOGD_ATMO("%s: Atmo api OFF!! Current Handle data:\n", __FUNCTION__);
1330
1331 ApiOffProcess(pAtmoCtx);
1332
1333 //log after updating
1334 LOGD_ATMO("%s: GlobalLumaMode:%f CtrlData.EnvLv:%f CtrlData.ISO:%f GlobeLuma:%f GlobeMaxLuma:%f \n", __FUNCTION__, pAtmoCtx->AtmoConfig.Luma.globalLumaMode,
1335 pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma);
1336 LOGD_ATMO("%s: DetailsHighLightMode:%f CtrlData.OEPdf:%f CtrlData.EnvLv:%f DetailsHighLight:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode, pAtmoCtx->CurrData.CtrlData.OEPdf
1337 , pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.DetailsHighLight);
1338 LOGD_ATMO("%s: DetailsLowLightMode:%f CtrlData.FocusLuma:%f CtrlData.DarkPdf:%f CtrlData.ISO:%f DetailsLowLight:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode,
1339 pAtmoCtx->CurrData.CtrlData.FocusLuma, pAtmoCtx->CurrData.CtrlData.DarkPdf, pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.DetailsLowLight);
1340 LOGD_ATMO("%s: localtmoMode:%f CtrlData.DynamicRange:%f CtrlData.EnvLv:%f LocalTmoStrength:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.local.localtmoMode, pAtmoCtx->CurrData.CtrlData.DynamicRange,
1341 pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
1342 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,
1343 pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.GlobalTmoStrength);
1344
1345 }
1346 else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_AUTO) {
1347 LOGD_ATMO("%s: Atmo api Auto!! Current Handle data:\n", __FUNCTION__);
1348 AtmoApiAutoUpdate(pAtmoCtx);
1349 }
1350 else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_MANU) {
1351 LOGD_ATMO("%s: Atmo api Manual!! Current Handle data:\n", __FUNCTION__);
1352 AtmoApiManualUpdate(pAtmoCtx);
1353 }
1354 else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_SET_LEVEL) {
1355 LOGD_ATMO("%s: Atmo api set level!! Current Handle data:\n", __FUNCTION__);
1356
1357 ApiOffProcess(pAtmoCtx);
1358 AtmoApiSetLevel(pAtmoCtx);
1359 }
1360 else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_DARKAREA) {
1361 LOGD_ATMO("%s: Atmo api DarkArea!! Current Handle data:\n", __FUNCTION__);
1362 ApiOffProcess(pAtmoCtx);
1363
1364 pAtmoCtx->AtmoConfig.bTmoEn = true;
1365 pAtmoCtx->AtmoConfig.isLinearTmo = pAtmoCtx->FrameNumber == LINEAR_NUM;
1366 pAtmoCtx->CurrData.HandleData.DetailsLowLight *= 1 + (float)(pAtmoCtx->tmoAttr.stDarkArea.level) * 0.4;
1367 pAtmoCtx->CurrData.HandleData.DetailsLowLight =
1368 LIMIT_VALUE(pAtmoCtx->CurrData.HandleData.DetailsLowLight, DETAILSLOWLIGHTMAX, DETAILSLOWLIGHTMIN);
1369 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,
1370 pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode, pAtmoCtx->CurrData.CtrlData.FocusLuma, pAtmoCtx->CurrData.CtrlData.DarkPdf,
1371 pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.DetailsLowLight);
1372 }
1373 else if(pAtmoCtx->tmoAttr.opMode == TMO_OPMODE_TOOL) {
1374 LOGD_ATMO("%s: Atmo api Tool!! Current Handle data:\n", __FUNCTION__);
1375 ApiOffProcess(pAtmoCtx);
1376
1377 //tmo en
1378 pAtmoCtx->AtmoConfig.bTmoEn = pAtmoCtx->AtmoConfig.bTmoEn;
1379 pAtmoCtx->AtmoConfig.isLinearTmo = pAtmoCtx->AtmoConfig.bTmoEn && pAtmoCtx->FrameNumber == LINEAR_NUM;
1380
1381 //log after updating
1382 LOGD_ATMO("%s: GlobalLumaMode:%f CtrlData.EnvLv:%f CtrlData.ISO:%f GlobeLuma:%f GlobeMaxLuma:%f \n", __FUNCTION__, pAtmoCtx->AtmoConfig.Luma.globalLumaMode,
1383 pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.GlobeLuma, pAtmoCtx->CurrData.HandleData.GlobeMaxLuma);
1384 LOGD_ATMO("%s: DetailsHighLightMode:%f CtrlData.OEPdf:%f CtrlData.EnvLv:%f DetailsHighLight:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLightMode, pAtmoCtx->CurrData.CtrlData.OEPdf
1385 , pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.DetailsHighLight);
1386 LOGD_ATMO("%s: DetailsLowLightMode:%f CtrlData.FocusLuma:%f CtrlData.DarkPdf:%f CtrlData.ISO:%f DetailsLowLight:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLightMode,
1387 pAtmoCtx->CurrData.CtrlData.FocusLuma, pAtmoCtx->CurrData.CtrlData.DarkPdf, pAtmoCtx->CurrData.CtrlData.ISO, pAtmoCtx->CurrData.HandleData.DetailsLowLight);
1388 LOGD_ATMO("%s: localtmoMode:%f CtrlData.DynamicRange:%f CtrlData.EnvLv:%f LocalTmoStrength:%f\n", __FUNCTION__, pAtmoCtx->AtmoConfig.local.localtmoMode, pAtmoCtx->CurrData.CtrlData.DynamicRange,
1389 pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.LocalTmoStrength);
1390 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,
1391 pAtmoCtx->CurrData.CtrlData.EnvLv, pAtmoCtx->CurrData.HandleData.GlobalTmoStrength);
1392 }
1393 else
1394 LOGE_ATMO("%s: Atmo wrong mode!!!\n", __FUNCTION__);
1395
1396 //transfer data to api
1397 AtmoTranferData2Api(pAtmoCtx);
1398
1399 //read current rodata
1400 pAtmoCtx->CurrData.CtrlData.LgMean = pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmean / 2048.0;
1401
1402 //calc the current merge luma
1403 float MergeLuma = (float)pAtmoCtx->CurrStatsData.tmo_stats.ro_hdrtmo_lgmean;
1404 MergeLuma = MergeLuma / 2048.0;
1405 float lgmean = MergeLuma;
1406 MergeLuma = pow(2, MergeLuma);
1407 MergeLuma = MergeLuma / 16;
1408
1409 //get pre frame tmo mean luma
1410 unsigned long tmo_mean = 0;
1411 for(int i = 0; i < 225; i++) {
1412 tmo_mean += pAtmoCtx->CurrStatsData.other_stats.tmo_luma[i];
1413 }
1414 tmo_mean = tmo_mean / 225;
1415 tmo_mean = tmo_mean / 16;
1416
1417 //calc short middle long frame mean luma
1418 unsigned long short_mean = 0, middle_mean = 0, long_mean = 0;
1419 for (int i = 0; i < 225; i++) {
1420 short_mean += pAtmoCtx->CurrAeResult.BlockLumaS[i];
1421 long_mean += pAtmoCtx->CurrAeResult.BlockLumaL[i];
1422 }
1423 short_mean = short_mean / 225;
1424 long_mean = long_mean / 225;
1425 short_mean = short_mean / 16;
1426 long_mean = long_mean / 16;
1427
1428 for(int i = 0; i < 25; i++)
1429 middle_mean += pAtmoCtx->CurrAeResult.BlockLumaM[i];
1430 middle_mean = middle_mean / 25;
1431 middle_mean = middle_mean / 16;
1432
1433 LOGD_ATMO("%s: preFrame lgMergeLuma:%f MergeLuma(8bit):%f TmoLuma(8bit):%d\n", __FUNCTION__, lgmean, MergeLuma, tmo_mean);
1434 LOGD_ATMO("%s: preFrame SLuma(8bit):%d MLuma(8bit):%d LLuma(8bit):%d\n", __FUNCTION__, short_mean, middle_mean, long_mean);
1435
1436 //get tmo proc res
1437 AtmoGetProcRes(pAtmoCtx);
1438
1439 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
1440 }
1441
1442 /******************************************************************************
1443 * AtmoInit()
1444 *****************************************************************************/
AtmoInit(AtmoInstanceConfig_t * pInstConfig,CamCalibDbV2Context_t * pCalibV2)1445 RESULT AtmoInit
1446 (
1447 AtmoInstanceConfig_t* pInstConfig,
1448 CamCalibDbV2Context_t* pCalibV2
1449 ) {
1450
1451 AtmoContext_s *pAtmoCtx;
1452
1453 LOG1_ATMO("%s:enter!\n", __FUNCTION__);
1454
1455 RESULT result = ATMO_RET_SUCCESS;
1456
1457 // initial checks
1458 if (pInstConfig == NULL)
1459 return (ATMO_RET_INVALID_PARM);
1460
1461 // allocate ATMO control context
1462 pAtmoCtx = (AtmoContext_s*)malloc(sizeof(AtmoContext_s));
1463 if (NULL == pAtmoCtx) {
1464 LOGE_ATMO( "%s: Can't allocate ATMO context\n", __FUNCTION__);
1465 return (ATMO_RET_OUTOFMEM);
1466 }
1467
1468 CalibDbV2_tmo_t* calibv2_atmo_calib =
1469 (CalibDbV2_tmo_t*)(CALIBDBV2_GET_MODULE_PTR(pCalibV2, atmo_calib));
1470
1471 // pre-initialize context
1472 memset(pAtmoCtx, 0x00, sizeof(*pAtmoCtx));
1473 pAtmoCtx->AtmoConfig.Luma.len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
1474 pAtmoCtx->AtmoConfig.Luma.EnvLv = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len));
1475 pAtmoCtx->AtmoConfig.Luma.ISO = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO_len));
1476 pAtmoCtx->AtmoConfig.Luma.GlobeLuma = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength_len));
1477 pAtmoCtx->AtmoConfig.DtsHiLit.len = calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len;
1478 pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len));
1479 pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv_len));
1480 pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.Strength_len));
1481 pAtmoCtx->AtmoConfig.DtsLoLit.len = calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len;
1482 pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len));
1483 pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf_len));
1484 pAtmoCtx->AtmoConfig.DtsLoLit.ISO = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.ISO_len));
1485 pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.Strength_len));
1486 pAtmoCtx->AtmoConfig.local.len = calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len;
1487 pAtmoCtx->AtmoConfig.local.DynamicRange = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len));
1488 pAtmoCtx->AtmoConfig.local.EnvLv = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv_len));
1489 pAtmoCtx->AtmoConfig.local.LocalTmoStrength = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.Strength_len));
1490 pAtmoCtx->AtmoConfig.global.len = calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len;
1491 pAtmoCtx->AtmoConfig.global.DynamicRange = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len));
1492 pAtmoCtx->AtmoConfig.global.EnvLv = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv_len));
1493 pAtmoCtx->AtmoConfig.global.GlobalTmoStrength = (float*)malloc(sizeof(float) * (calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength_len));
1494 pAtmoCtx->state = ATMO_STATE_INITIALIZED;
1495 pAtmoCtx->tmoAttr.opMode = TMO_OPMODE_API_OFF;
1496 AtmoConfig(pAtmoCtx); //set default para
1497 memcpy(&pAtmoCtx->pCalibDB, calibv2_atmo_calib, sizeof(CalibDbV2_tmo_t));//load iq paras
1498 memcpy(&pAtmoCtx->tmoAttr.stTool, calibv2_atmo_calib, sizeof(CalibDbV2_tmo_t));//load iq paras to stTool
1499 pInstConfig->hAtmo = (AtmoHandle_t)pAtmoCtx;
1500
1501 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
1502 return (ATMO_RET_SUCCESS);
1503 }
1504 /******************************************************************************
1505 * AtmoRelease()
1506 *****************************************************************************/
AtmoRelease(AtmoHandle_t pAtmoCtx)1507 RESULT AtmoRelease
1508 (
1509 AtmoHandle_t pAtmoCtx
1510 ) {
1511
1512 LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
1513 RESULT result = ATMO_RET_SUCCESS;
1514
1515 // initial checks
1516 if (NULL == pAtmoCtx) {
1517 return (ATMO_RET_WRONG_HANDLE);
1518 }
1519
1520 result = AtmoStop(pAtmoCtx);
1521 if (result != ATMO_RET_SUCCESS) {
1522 LOGE_ATMO( "%s: AHDRStop() failed!\n", __FUNCTION__);
1523 return (result);
1524 }
1525
1526 // check state
1527 if ((ATMO_STATE_RUNNING == pAtmoCtx->state)
1528 || (ATMO_STATE_LOCKED == pAtmoCtx->state)) {
1529 return (ATMO_RET_BUSY);
1530 }
1531
1532 free(pAtmoCtx->AtmoConfig.Luma.EnvLv);
1533 free(pAtmoCtx->AtmoConfig.Luma.ISO);
1534 free(pAtmoCtx->AtmoConfig.Luma.GlobeLuma);
1535 free(pAtmoCtx->AtmoConfig.DtsHiLit.OEPdf);
1536 free(pAtmoCtx->AtmoConfig.DtsHiLit.EnvLv);
1537 free(pAtmoCtx->AtmoConfig.DtsHiLit.DetailsHighLight);
1538 free(pAtmoCtx->AtmoConfig.DtsLoLit.FocusLuma);
1539 free(pAtmoCtx->AtmoConfig.DtsLoLit.DarkPdf);
1540 free(pAtmoCtx->AtmoConfig.DtsLoLit.ISO);
1541 free(pAtmoCtx->AtmoConfig.DtsLoLit.DetailsLowLight);
1542 free(pAtmoCtx->AtmoConfig.local.DynamicRange);
1543 free(pAtmoCtx->AtmoConfig.local.EnvLv);
1544 free(pAtmoCtx->AtmoConfig.local.LocalTmoStrength);
1545 free(pAtmoCtx->AtmoConfig.global.DynamicRange);
1546 free(pAtmoCtx->AtmoConfig.global.EnvLv);
1547 free(pAtmoCtx->AtmoConfig.global.GlobalTmoStrength);
1548 memset(pAtmoCtx, 0, sizeof(AtmoContext_s));
1549 free(pAtmoCtx);
1550 pAtmoCtx = NULL;
1551
1552 LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
1553 return (ATMO_RET_SUCCESS);
1554 }
1555
1556