xref: /OK3568_Linux_fs/external/camera_engine_rkaiq/rkaiq/aiq_core/algo_handlers/RkAiqAtmoHandle.cpp (revision 4882a59341e53eb6f0b4789bf948001014eff981) 
1 /*
2  * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #include "RkAiqAtmoHandle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAtmoHandleInt);
23 
init()24 void RkAiqAtmoHandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAtmo());
29     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAtmo());
30     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAtmo());
31 
32     EXIT_ANALYZER_FUNCTION();
33 }
updateConfig(bool needSync)34 XCamReturn RkAiqAtmoHandleInt::updateConfig(bool needSync) {
35     ENTER_ANALYZER_FUNCTION();
36 
37     XCamReturn ret = XCAM_RETURN_NO_ERROR;
38 #ifndef DISABLE_HANDLE_ATTRIB
39     if (needSync) mCfgMutex.lock();
40     // if something changed
41     if (updateAtt) {
42         mCurAtt   = mNewAtt;
43         updateAtt = false;
44         rk_aiq_uapi_atmo_SetAttrib(mAlgoCtx, mCurAtt, true);
45         sendSignal();
46     }
47     if (needSync) mCfgMutex.unlock();
48 #endif
49 
50     EXIT_ANALYZER_FUNCTION();
51     return ret;
52 }
53 
setAttrib(atmo_attrib_t att)54 XCamReturn RkAiqAtmoHandleInt::setAttrib(atmo_attrib_t att) {
55     ENTER_ANALYZER_FUNCTION();
56 
57     XCamReturn ret = XCAM_RETURN_NO_ERROR;
58     mCfgMutex.lock();
59 #ifdef DISABLE_HANDLE_ATTRIB
60     ret = rk_aiq_uapi_atmo_SetAttrib(mAlgoCtx, att, false);
61 #else
62     // TODO
63     // check if there is different between att & mCurAtt
64     // if something changed, set att to mNewAtt, and
65     // the new params will be effective later when updateConfig
66     // called by RkAiqCore
67 
68     // if something changed
69     if (0 != memcmp(&mCurAtt, &att, sizeof(atmo_attrib_t))) {
70         mNewAtt   = att;
71         updateAtt = true;
72         waitSignal();
73     }
74     mCfgMutex.unlock();
75 #endif
76 
77     EXIT_ANALYZER_FUNCTION();
78     return ret;
79 }
getAttrib(atmo_attrib_t * att)80 XCamReturn RkAiqAtmoHandleInt::getAttrib(atmo_attrib_t* att) {
81     ENTER_ANALYZER_FUNCTION();
82 
83     XCamReturn ret = XCAM_RETURN_NO_ERROR;
84 
85     rk_aiq_uapi_atmo_GetAttrib(mAlgoCtx, att);
86 
87     EXIT_ANALYZER_FUNCTION();
88     return ret;
89 }
90 
prepare()91 XCamReturn RkAiqAtmoHandleInt::prepare() {
92     ENTER_ANALYZER_FUNCTION();
93 
94     XCamReturn ret = XCAM_RETURN_NO_ERROR;
95 
96     ret = RkAiqHandle::prepare();
97     RKAIQCORE_CHECK_RET(ret, "atmo handle prepare failed");
98 
99     RkAiqAlgoConfigAtmo* atmo_config_int = (RkAiqAlgoConfigAtmo*)mConfig;
100     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
101         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
102     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
103 
104     // TODO
105     atmo_config_int->rawHeight    = sharedCom->snsDes.isp_acq_height;
106     atmo_config_int->rawWidth     = sharedCom->snsDes.isp_acq_width;
107     atmo_config_int->working_mode = sharedCom->working_mode;
108 
109     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
110     ret                       = des->prepare(mConfig);
111     RKAIQCORE_CHECK_RET(ret, "atmo algo prepare failed");
112 
113     EXIT_ANALYZER_FUNCTION();
114     return XCAM_RETURN_NO_ERROR;
115 }
116 
preProcess()117 XCamReturn RkAiqAtmoHandleInt::preProcess() {
118     ENTER_ANALYZER_FUNCTION();
119 
120     XCamReturn ret = XCAM_RETURN_NO_ERROR;
121 
122     RkAiqAlgoPreAtmo* atmo_pre_int        = (RkAiqAlgoPreAtmo*)mPreInParam;
123     RkAiqAlgoPreResAtmo* atmo_pre_res_int = (RkAiqAlgoPreResAtmo*)mPreOutParam;
124     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
125         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
126     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
127 
128     ret = RkAiqHandle::preProcess();
129     if (ret) {
130         RKAIQCORE_CHECK_RET(ret, "atmo handle preProcess failed");
131     }
132 
133     RkAiqIspStats* xIspStats = nullptr;
134     if (shared->ispStats) {
135         xIspStats = (RkAiqIspStats*)shared->ispStats->map(shared->ispStats);
136         if (!xIspStats) LOGE_AEC("isp stats is null");
137     } else {
138         LOGW_ADEHAZE("the xcamvideobuffer of isp stats is null");
139     }
140 
141     if (!xIspStats || !xIspStats->atmo_stats_valid || !sharedCom->init) {
142         LOGD("no atmo stats, ignore!");
143         // TODO: keep last result ?
144         //
145         return XCAM_RETURN_BYPASS;
146     }
147 
148     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
149     ret                       = des->pre_process(mPreInParam, mPreOutParam);
150     RKAIQCORE_CHECK_RET(ret, "ahdr algo pre_process failed");
151 
152     EXIT_ANALYZER_FUNCTION();
153     return XCAM_RETURN_NO_ERROR;
154 }
155 
processing()156 XCamReturn RkAiqAtmoHandleInt::processing() {
157     ENTER_ANALYZER_FUNCTION();
158 
159     XCamReturn ret = XCAM_RETURN_NO_ERROR;
160 
161     RkAiqAlgoProcAtmo* atmo_proc_int        = (RkAiqAlgoProcAtmo*)mProcInParam;
162     RkAiqAlgoProcResAtmo* atmo_proc_res_int = (RkAiqAlgoProcResAtmo*)mProcOutParam;
163     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
164         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
165     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
166 
167     ret = RkAiqHandle::processing();
168     if (ret) {
169         RKAIQCORE_CHECK_RET(ret, "atmo handle processing failed");
170     }
171 
172     RkAiqIspStats* xIspStats = nullptr;
173     if (shared->ispStats) {
174         xIspStats = (RkAiqIspStats*)shared->ispStats->map(shared->ispStats);
175         if (!xIspStats) LOGE_ATMO("isp stats is null");
176     } else {
177         LOGW_ATMO("the xcamvideobuffer of isp stats is null");
178     }
179 
180     if (!xIspStats || !xIspStats->atmo_stats_valid || !sharedCom->init) {
181         LOGD("no atmo stats, ignore!");
182         // TODO: keep last result ?
183         //
184         return XCAM_RETURN_BYPASS;
185     } else {
186         memcpy(&atmo_proc_int->ispAtmoStats.tmo_stats,
187                &xIspStats->AtmoStatsProxy->data()->atmo_stats.tmo_stats, sizeof(hdrtmo_stats_t));
188         memcpy(atmo_proc_int->ispAtmoStats.other_stats.tmo_luma,
189                xIspStats->AecStatsProxy->data()->aec_stats.ae_data.extra.rawae_big.channelg_xy,
190                sizeof(atmo_proc_int->ispAtmoStats.other_stats.tmo_luma));
191 
192         if (sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
193             sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
194             memcpy(atmo_proc_int->ispAtmoStats.other_stats.short_luma,
195                    xIspStats->AecStatsProxy->data()->aec_stats.ae_data.chn[0].rawae_big.channelg_xy,
196                    sizeof(atmo_proc_int->ispAtmoStats.other_stats.short_luma));
197             memcpy(
198                 atmo_proc_int->ispAtmoStats.other_stats.middle_luma,
199                 xIspStats->AecStatsProxy->data()->aec_stats.ae_data.chn[1].rawae_lite.channelg_xy,
200                 sizeof(atmo_proc_int->ispAtmoStats.other_stats.middle_luma));
201             memcpy(atmo_proc_int->ispAtmoStats.other_stats.long_luma,
202                    xIspStats->AecStatsProxy->data()->aec_stats.ae_data.chn[2].rawae_big.channelg_xy,
203                    sizeof(atmo_proc_int->ispAtmoStats.other_stats.long_luma));
204         } else if (sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
205                    sharedCom->working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
206             memcpy(atmo_proc_int->ispAtmoStats.other_stats.short_luma,
207                    xIspStats->AecStatsProxy->data()->aec_stats.ae_data.chn[0].rawae_big.channelg_xy,
208                    sizeof(atmo_proc_int->ispAtmoStats.other_stats.short_luma));
209             memcpy(atmo_proc_int->ispAtmoStats.other_stats.long_luma,
210                    xIspStats->AecStatsProxy->data()->aec_stats.ae_data.chn[1].rawae_big.channelg_xy,
211                    sizeof(atmo_proc_int->ispAtmoStats.other_stats.long_luma));
212         } else
213             LOGD("Wrong working mode!!!");
214     }
215 
216 #ifdef DISABLE_HANDLE_ATTRIB
217     mCfgMutex.lock();
218 #endif
219     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
220     ret                       = des->processing(mProcInParam, mProcOutParam);
221 #ifdef DISABLE_HANDLE_ATTRIB
222     mCfgMutex.unlock();
223 #endif
224     RKAIQCORE_CHECK_RET(ret, "atmo algo processing failed");
225 
226     EXIT_ANALYZER_FUNCTION();
227     return ret;
228 }
229 
postProcess()230 XCamReturn RkAiqAtmoHandleInt::postProcess() {
231     ENTER_ANALYZER_FUNCTION();
232 
233     XCamReturn ret = XCAM_RETURN_NO_ERROR;
234 
235     RkAiqAlgoPostAtmo* atmo_post_int        = (RkAiqAlgoPostAtmo*)mPostInParam;
236     RkAiqAlgoPostResAtmo* atmo_post_res_int = (RkAiqAlgoPostResAtmo*)mPostOutParam;
237     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
238         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
239     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
240 
241     ret = RkAiqHandle::postProcess();
242     if (ret) {
243         RKAIQCORE_CHECK_RET(ret, "ahdr handle postProcess failed");
244         return ret;
245     }
246 
247     RkAiqIspStats* xIspStats = nullptr;
248     if (shared->ispStats) {
249         xIspStats = (RkAiqIspStats*)shared->ispStats->map(shared->ispStats);
250         if (!xIspStats) LOGE_ATMO("isp stats is null");
251     } else {
252         LOGW_ATMO("the xcamvideobuffer of isp stats is null");
253     }
254 
255     if (!xIspStats || !xIspStats->atmo_stats_valid || !sharedCom->init) {
256         LOGD("no atmo stats, ignore!");
257         // TODO: keep last result ?
258         //
259         return XCAM_RETURN_BYPASS;
260     }
261 
262     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
263     ret                       = des->post_process(mPostInParam, mPostOutParam);
264     RKAIQCORE_CHECK_RET(ret, "atmo algo post_process failed");
265 
266     EXIT_ANALYZER_FUNCTION();
267     return ret;
268 }
269 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)270 XCamReturn RkAiqAtmoHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
271     ENTER_ANALYZER_FUNCTION();
272 
273     XCamReturn ret = XCAM_RETURN_NO_ERROR;
274     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
275         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
276     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
277     RkAiqAlgoProcResAtmo* atmo_com              = (RkAiqAlgoProcResAtmo*)mProcOutParam;
278 
279     rk_aiq_isp_tmo_params_v20_t* tmo_param = params->mTmoParams->data().ptr();
280 
281     if (!atmo_com) {
282         LOGD_ANALYZER("no atmo result");
283         return XCAM_RETURN_NO_ERROR;
284     }
285 
286     if (!this->getAlgoId()) {
287         RkAiqAlgoProcResAtmo* atmo_rk = (RkAiqAlgoProcResAtmo*)atmo_com;
288 
289         if (sharedCom->init) {
290             tmo_param->frame_id = 0;
291         } else {
292             tmo_param->frame_id = shared->frameId;
293         }
294 
295         tmo_param->result.Res.sw_hdrtmo_lgmax      = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_lgmax;
296         tmo_param->result.Res.sw_hdrtmo_lgscl      = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_lgscl;
297         tmo_param->result.Res.sw_hdrtmo_lgscl_inv  = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_lgscl_inv;
298         tmo_param->result.Res.sw_hdrtmo_clipratio0 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_clipratio0;
299         tmo_param->result.Res.sw_hdrtmo_clipratio1 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_clipratio1;
300         tmo_param->result.Res.sw_hdrtmo_clipgap0   = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_clipgap0;
301         tmo_param->result.Res.sw_hdrtmo_clipgap1   = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_clipgap1;
302         tmo_param->result.Res.sw_hdrtmo_ratiol     = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_ratiol;
303         tmo_param->result.Res.sw_hdrtmo_hist_min   = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_min;
304         tmo_param->result.Res.sw_hdrtmo_hist_low   = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_low;
305         tmo_param->result.Res.sw_hdrtmo_hist_high  = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_high;
306         tmo_param->result.Res.sw_hdrtmo_hist_0p3   = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_0p3;
307         tmo_param->result.Res.sw_hdrtmo_hist_shift = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_shift;
308         tmo_param->result.Res.sw_hdrtmo_palpha_0p18 =
309             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_palpha_0p18;
310         tmo_param->result.Res.sw_hdrtmo_palpha_lw0p5 =
311             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_palpha_lw0p5;
312         tmo_param->result.Res.sw_hdrtmo_palpha_lwscl =
313             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_palpha_lwscl;
314         tmo_param->result.Res.sw_hdrtmo_maxpalpha = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_maxpalpha;
315         tmo_param->result.Res.sw_hdrtmo_maxgain   = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_maxgain;
316         tmo_param->result.Res.sw_hdrtmo_cfg_alpha = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_cfg_alpha;
317         tmo_param->result.Res.sw_hdrtmo_set_gainoff =
318             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_gainoff;
319         tmo_param->result.Res.sw_hdrtmo_set_lgmin  = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgmin;
320         tmo_param->result.Res.sw_hdrtmo_set_lgmax  = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgmax;
321         tmo_param->result.Res.sw_hdrtmo_set_lgmean = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgmean;
322         tmo_param->result.Res.sw_hdrtmo_set_weightkey =
323             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_weightkey;
324         tmo_param->result.Res.sw_hdrtmo_set_lgrange0 =
325             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgrange0;
326         tmo_param->result.Res.sw_hdrtmo_set_lgrange1 =
327             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgrange1;
328         tmo_param->result.Res.sw_hdrtmo_set_lgavgmax =
329             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgavgmax;
330         tmo_param->result.Res.sw_hdrtmo_set_palpha = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_palpha;
331         tmo_param->result.Res.sw_hdrtmo_gain_ld_off1 =
332             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_gain_ld_off1;
333         tmo_param->result.Res.sw_hdrtmo_gain_ld_off2 =
334             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_gain_ld_off2;
335         tmo_param->result.Res.sw_hdrtmo_cnt_vsize  = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_cnt_vsize;
336         tmo_param->result.Res.sw_hdrtmo_big_en     = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_big_en;
337         tmo_param->result.Res.sw_hdrtmo_nobig_en   = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_nobig_en;
338         tmo_param->result.Res.sw_hdrtmo_newhist_en = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_newhist_en;
339         tmo_param->result.Res.sw_hdrtmo_cnt_mode   = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_cnt_mode;
340         tmo_param->result.Res.sw_hdrtmo_expl_lgratio =
341             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_expl_lgratio;
342         tmo_param->result.Res.sw_hdrtmo_lgscl_ratio =
343             atmo_rk->AtmoProcRes.Res.sw_hdrtmo_lgscl_ratio;
344 
345         tmo_param->result.LongFrameMode = atmo_rk->AtmoProcRes.LongFrameMode;
346 
347         tmo_param->result.isHdrGlobalTmo = atmo_rk->AtmoProcRes.isHdrGlobalTmo;
348 
349         tmo_param->result.bTmoEn = atmo_rk->AtmoProcRes.bTmoEn;
350 
351         tmo_param->result.isLinearTmo = atmo_rk->AtmoProcRes.isLinearTmo;
352 
353         tmo_param->result.TmoFlicker.GlobalTmoStrengthDown =
354             atmo_rk->AtmoProcRes.TmoFlicker.GlobalTmoStrengthDown;
355         tmo_param->result.TmoFlicker.GlobalTmoStrength =
356             atmo_rk->AtmoProcRes.TmoFlicker.GlobalTmoStrength;
357         tmo_param->result.TmoFlicker.iir    = atmo_rk->AtmoProcRes.TmoFlicker.iir;
358         tmo_param->result.TmoFlicker.iirmax = atmo_rk->AtmoProcRes.TmoFlicker.iirmax;
359         tmo_param->result.TmoFlicker.height = atmo_rk->AtmoProcRes.TmoFlicker.height;
360         tmo_param->result.TmoFlicker.width  = atmo_rk->AtmoProcRes.TmoFlicker.width;
361 
362         tmo_param->result.TmoFlicker.PredictK.correction_factor =
363             atmo_rk->AtmoProcRes.TmoFlicker.PredictK.correction_factor;
364         tmo_param->result.TmoFlicker.PredictK.correction_offset =
365             atmo_rk->AtmoProcRes.TmoFlicker.PredictK.correction_offset;
366         tmo_param->result.TmoFlicker.PredictK.Hdr3xLongPercent =
367             atmo_rk->AtmoProcRes.TmoFlicker.PredictK.Hdr3xLongPercent;
368         tmo_param->result.TmoFlicker.PredictK.UseLongUpTh =
369             atmo_rk->AtmoProcRes.TmoFlicker.PredictK.UseLongUpTh;
370         tmo_param->result.TmoFlicker.PredictK.UseLongLowTh =
371             atmo_rk->AtmoProcRes.TmoFlicker.PredictK.UseLongLowTh;
372         for (int i = 0; i < 3; i++)
373             tmo_param->result.TmoFlicker.LumaDeviation[i] =
374                 atmo_rk->AtmoProcRes.TmoFlicker.LumaDeviation[i];
375         tmo_param->result.TmoFlicker.StableThr = atmo_rk->AtmoProcRes.TmoFlicker.StableThr;
376     }
377 
378     cur_params->mTmoParams = params->mTmoParams;
379 
380     EXIT_ANALYZER_FUNCTION();
381 
382     return ret;
383 }
384 
385 }  // namespace RkCam
386