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 "RkAiqAdehazeHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAdehazeHandleInt);
23
init()24 void RkAiqAdehazeHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAdhaz());
29 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAdhaz());
30 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAdhaz());
31
32 EXIT_ANALYZER_FUNCTION();
33 }
34
prepare()35 XCamReturn RkAiqAdehazeHandleInt::prepare() {
36 ENTER_ANALYZER_FUNCTION();
37
38 XCamReturn ret = XCAM_RETURN_NO_ERROR;
39
40 ret = RkAiqHandle::prepare();
41 RKAIQCORE_CHECK_RET(ret, "adhaz handle prepare failed");
42
43 RkAiqAlgoConfigAdhaz* adhaz_config_int = (RkAiqAlgoConfigAdhaz*)mConfig;
44 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
45
46 #ifdef RKAIQ_ENABLE_PARSER_V1
47 adhaz_config_int->calib = sharedCom->calib;
48 #endif
49
50 adhaz_config_int->working_mode = sharedCom->working_mode;
51 adhaz_config_int->is_multi_isp_mode = sharedCom->is_multi_isp_mode;
52
53 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
54 ret = des->prepare(mConfig);
55 RKAIQCORE_CHECK_RET(ret, "adhaz algo prepare failed");
56
57 EXIT_ANALYZER_FUNCTION();
58 return XCAM_RETURN_NO_ERROR;
59 }
60
preProcess()61 XCamReturn RkAiqAdehazeHandleInt::preProcess() {
62 ENTER_ANALYZER_FUNCTION();
63
64 XCamReturn ret = XCAM_RETURN_NO_ERROR;
65 #if 0
66 RkAiqAlgoPreAdhaz* adhaz_pre_int = (RkAiqAlgoPreAdhaz*)mPreInParam;
67 RkAiqAlgoPreResAdhaz* adhaz_pre_res_int = (RkAiqAlgoPreResAdhaz*)mPreOutParam;
68 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
69 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
70 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
71
72 adhaz_pre_int->rawHeight = sharedCom->snsDes.isp_acq_height;
73 adhaz_pre_int->rawWidth = sharedCom->snsDes.isp_acq_width;
74
75 RkAiqAdehazeStats* xDehazeStats = nullptr;
76 if (shared->ispStats) {
77 xDehazeStats = (RkAiqAdehazeStats*)shared->ispStats->map(shared->ispStats);
78 if (!xDehazeStats) LOGE_ADEHAZE("isp stats is null");
79 } else {
80 LOGW_ADEHAZE("the xcamvideobuffer of isp stats is null");
81 }
82
83 if (!xDehazeStats || !xDehazeStats->adehaze_stats_valid || !sharedCom->init) {
84 #if RKAIQ_HAVE_DEHAZE_V11_DUO
85 LOGE("no adehaze stats, ignore!");
86 return XCAM_RETURN_BYPASS;
87 #endif
88 } else {
89 #if RKAIQ_HAVE_DEHAZE_V10
90 memcpy(&adhaz_pre_int->stats.dehaze_stats_v10,
91 &xDehazeStats->AdehazeStatsProxy->data()->adehaze_stats.dehaze_stats_v10,
92 sizeof(dehaze_stats_v10_t));
93 #endif
94 #if RKAIQ_HAVE_DEHAZE_V11
95 memcpy(&adhaz_pre_int->stats.dehaze_stats_v11,
96 &xDehazeStats->AdehazeStatsProxy->data()->adehaze_stats.dehaze_stats_v11,
97 sizeof(dehaze_stats_v11_t));
98 #endif
99 #if RKAIQ_HAVE_DEHAZE_V11_DUO
100 memcpy(&adhaz_pre_int->stats.dehaze_stats_v11_duo,
101 &xDehazeStats->AdehazeStatsProxy->data()->adehaze_stats.dehaze_stats_v11_duo,
102 sizeof(dehaze_stats_v11_duo_t));
103 #endif
104 #if RKAIQ_HAVE_DEHAZE_V12
105 memcpy(&adhaz_pre_int->stats.dehaze_stats_v12,
106 &xDehazeStats->AdehazeStatsProxy->data()->adehaze_stats.dehaze_stats_v12,
107 sizeof(dehaze_stats_v12_t));
108 #endif
109 }
110
111 ret = RkAiqHandle::preProcess();
112 if (ret) {
113 RKAIQCORE_CHECK_RET(ret, "adhaz handle preProcess failed");
114 }
115
116 #ifdef RK_SIMULATOR_HW
117 // nothing todo
118 #endif
119 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
120 ret = des->pre_process(mPreInParam, mPreOutParam);
121 RKAIQCORE_CHECK_RET(ret, "adhaz algo pre_process failed");
122
123 EXIT_ANALYZER_FUNCTION();
124 #endif
125 return XCAM_RETURN_NO_ERROR;
126 }
127
processing()128 XCamReturn RkAiqAdehazeHandleInt::processing() {
129 ENTER_ANALYZER_FUNCTION();
130
131 XCamReturn ret = XCAM_RETURN_NO_ERROR;
132
133 RkAiqAlgoProcAdhaz* adhaz_proc_int = (RkAiqAlgoProcAdhaz*)mProcInParam;
134 RkAiqAlgoProcResAdhaz* adhaz_proc_res_int = (RkAiqAlgoProcResAdhaz*)mProcOutParam;
135 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
136 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
137 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
138
139 RkAiqAdehazeStats* xDehazeStats = nullptr;
140 if (shared->adehazeStatsBuf) {
141 xDehazeStats = shared->adehazeStatsBuf;
142 if (!xDehazeStats) LOGE_ADEHAZE("dehaze stats is null");
143 } else {
144 LOGW_ADEHAZE("the xcamvideobuffer of isp stats is null");
145 }
146
147 if (!xDehazeStats || !xDehazeStats->adehaze_stats_valid) {
148 LOGW_ADEHAZE("no adehaze stats, ignore!");
149 adhaz_proc_int->stats_true = false;
150 } else {
151 adhaz_proc_int->stats_true = true;
152
153 #if RKAIQ_HAVE_DEHAZE_V10
154 adhaz_proc_int->dehaze_stats_v10 = &xDehazeStats->adehaze_stats.dehaze_stats_v10;
155 #endif
156 #if RKAIQ_HAVE_DEHAZE_V11
157 adhaz_proc_int->dehaze_stats_v11 = &xDehazeStats->adehaze_stats.dehaze_stats_v11;
158 #endif
159 #if RKAIQ_HAVE_DEHAZE_V11_DUO
160 adhaz_proc_int->dehaze_stats_v11_duo = &xDehazeStats->adehaze_stats.dehaze_stats_v11_duo;
161 #endif
162 #if RKAIQ_HAVE_DEHAZE_V12
163 adhaz_proc_int->dehaze_stats_v12 = &xDehazeStats->adehaze_stats.dehaze_stats_v12;
164 #endif
165 }
166 #if RKAIQ_HAVE_DEHAZE_V11_DUO
167 #if RKAIQ_HAVE_YNR_V3
168 if (shared->res_comb.aynrV22_proc_res) {
169 for (int i = 0; i < YNR_V3_ISO_CURVE_POINT_NUM; i++)
170 adhaz_proc_int->sigma_v3[i] = shared->res_comb.aynrV3_proc_res->stSelect->sigma[i];
171 }
172 #else
173 for (int i = 0; i < YNR_V3_ISO_CURVE_POINT_NUM; i++) adhaz_proc_int->sigma_v3[i] = 0.0f;
174 #endif
175 #endif
176 #if RKAIQ_HAVE_DEHAZE_V12
177 #if RKAIQ_HAVE_YNR_V22
178 if (shared->res_comb.aynrV22_proc_res) {
179 for (int i = 0; i < YNR_V22_ISO_CURVE_POINT_NUM; i++)
180 adhaz_proc_int->sigma_v22[i] = shared->res_comb.aynrV22_proc_res->stSelect->sigma[i];
181 }
182 #else
183 for (int i = 0; i < YNR_V22_ISO_CURVE_POINT_NUM; i++) adhaz_proc_int->sigma_v22[i] = 0.0f;
184 #endif
185 #if RKAIQ_HAVE_BLC_V32
186 adhaz_proc_int->OBResV12.blc_ob_enable = shared->res_comb.ablcV32_proc_res->blc_ob_enable;
187 adhaz_proc_int->OBResV12.isp_ob_predgain = shared->res_comb.ablcV32_proc_res->isp_ob_predgain;
188 #else
189 adhaz_proc_int->OBResV12.blc_ob_enable = false;
190 adhaz_proc_int->OBResV12.isp_ob_predgain = 1.0f;
191 #endif
192 #endif
193
194 adhaz_proc_res_int->AdehzeProcRes = &shared->fullParams->mDehazeParams->data()->result;
195
196 ret = RkAiqHandle::processing();
197 if (ret) {
198 RKAIQCORE_CHECK_RET(ret, "adhaz handle processing failed");
199 }
200
201 #ifdef RKAIQ_ENABLE_PARSER_V1
202 adhaz_proc_int->pCalibDehaze = sharedCom->calib;
203 #endif
204
205 #ifdef RK_SIMULATOR_HW
206 // nothing todo
207 #endif
208 #ifdef DISABLE_HANDLE_ATTRIB
209 mCfgMutex.lock();
210 #endif
211 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
212 ret = des->processing(mProcInParam, mProcOutParam);
213 #ifdef DISABLE_HANDLE_ATTRIB
214 mCfgMutex.unlock();
215 #endif
216 RKAIQCORE_CHECK_RET(ret, "adhaz algo processing failed");
217
218 EXIT_ANALYZER_FUNCTION();
219 return ret;
220 }
221
postProcess()222 XCamReturn RkAiqAdehazeHandleInt::postProcess() {
223 ENTER_ANALYZER_FUNCTION();
224
225 XCamReturn ret = XCAM_RETURN_NO_ERROR;
226 #if 0
227
228 RkAiqAlgoPostAdhaz* adhaz_post_int = (RkAiqAlgoPostAdhaz*)mPostInParam;
229 RkAiqAlgoPostResAdhaz* adhaz_post_res_int = (RkAiqAlgoPostResAdhaz*)mPostOutParam;
230 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
231 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
232 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
233
234 ret = RkAiqHandle::postProcess();
235 if (ret) {
236 RKAIQCORE_CHECK_RET(ret, "adhaz handle postProcess failed");
237 return ret;
238 }
239
240 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
241 ret = des->post_process(mPostInParam, mPostOutParam);
242 RKAIQCORE_CHECK_RET(ret, "adhaz algo post_process failed");
243
244 EXIT_ANALYZER_FUNCTION();
245 #endif
246 return ret;
247 }
248
updateConfig(bool needSync)249 XCamReturn RkAiqAdehazeHandleInt::updateConfig(bool needSync) {
250 ENTER_ANALYZER_FUNCTION();
251
252 XCamReturn ret = XCAM_RETURN_NO_ERROR;
253 #ifndef DISABLE_HANDLE_ATTRIB
254 if (needSync) mCfgMutex.lock();
255 // if something changed
256 if (updateAtt) {
257 #if RKAIQ_HAVE_DEHAZE_V10
258 mCurAttV10 = mNewAttV10;
259 rk_aiq_uapi_adehaze_v10_SetAttrib(mAlgoCtx, &mCurAttV10, false);
260 updateAtt = false;
261 sendSignal(mCurAttV10.sync.sync_mode);
262 #endif
263 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO
264 mCurAttV11 = mNewAttV11;
265 rk_aiq_uapi_adehaze_v11_SetAttrib(mAlgoCtx, &mCurAttV11, false);
266 updateAtt = false;
267 sendSignal(mCurAttV11.sync.sync_mode);
268 #endif
269 #if RKAIQ_HAVE_DEHAZE_V12
270 mCurAttV12 = mNewAttV12;
271 rk_aiq_uapi_adehaze_v12_SetAttrib(mAlgoCtx, &mCurAttV12, false);
272 updateAtt = false;
273 sendSignal(mCurAttV12.sync.sync_mode);
274 #endif
275 }
276
277 if (needSync) mCfgMutex.unlock();
278 #endif
279
280 EXIT_ANALYZER_FUNCTION();
281 return ret;
282 }
283
284 #if RKAIQ_HAVE_DEHAZE_V10
setSwAttribV10(const adehaze_sw_v10_t * att)285 XCamReturn RkAiqAdehazeHandleInt::setSwAttribV10(const adehaze_sw_v10_t* att) {
286 ENTER_ANALYZER_FUNCTION();
287
288 XCamReturn ret = XCAM_RETURN_NO_ERROR;
289 mCfgMutex.lock();
290
291 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
292 // if something changed, set att to mNewAtt, and
293 // the new params will be effective later when updateConfig
294 // called by RkAiqCore
295 #ifdef DISABLE_HANDLE_ATTRIB
296 ret = rk_aiq_uapi_adehaze_v10_SetAttrib(mAlgoCtx, const_cast<adehaze_sw_v10_t*>(att), false);
297 #else
298 bool isChanged = false;
299 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
300 memcmp(&mNewAttV10, att, sizeof(adehaze_sw_v10_t)))
301 isChanged = true;
302 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
303 memcmp(&mCurAttV10, att, sizeof(adehaze_sw_v10_t)))
304 isChanged = true;
305
306 // if something changed
307 if (isChanged) {
308 mNewAttV10 = *att;
309 updateAtt = true;
310 waitSignal(att->sync.sync_mode);
311 }
312 #endif
313
314 mCfgMutex.unlock();
315
316 EXIT_ANALYZER_FUNCTION();
317 return ret;
318 }
319
getSwAttribV10(adehaze_sw_v10_t * att)320 XCamReturn RkAiqAdehazeHandleInt::getSwAttribV10(adehaze_sw_v10_t* att) {
321 ENTER_ANALYZER_FUNCTION();
322
323 XCamReturn ret = XCAM_RETURN_NO_ERROR;
324
325 #ifdef DISABLE_HANDLE_ATTRIB
326 mCfgMutex.lock();
327 ret = rk_aiq_uapi_adehaze_v10_GetAttrib(mAlgoCtx, att);
328 mCfgMutex.unlock();
329 #else
330 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
331 mCfgMutex.lock();
332 rk_aiq_uapi_adehaze_v10_GetAttrib(mAlgoCtx, att);
333 att->sync.done = true;
334 mCfgMutex.unlock();
335 } else {
336 if (updateAtt) {
337 memcpy(att, &mNewAttV10, sizeof(adehaze_sw_v10_t));
338 att->sync.done = false;
339 } else {
340 rk_aiq_uapi_adehaze_v10_GetAttrib(mAlgoCtx, att);
341 att->sync.sync_mode = mNewAttV10.sync.sync_mode;
342 att->sync.done = true;
343 }
344 }
345 #endif
346
347 EXIT_ANALYZER_FUNCTION();
348 return ret;
349 }
350 #endif
351 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO
setSwAttribV11(const adehaze_sw_v11_t * att)352 XCamReturn RkAiqAdehazeHandleInt::setSwAttribV11(const adehaze_sw_v11_t* att) {
353 ENTER_ANALYZER_FUNCTION();
354
355 XCamReturn ret = XCAM_RETURN_NO_ERROR;
356 mCfgMutex.lock();
357
358 #ifdef DISABLE_HANDLE_ATTRIB
359 ret = rk_aiq_uapi_adehaze_v11_SetAttrib(mAlgoCtx, const_cast<adehaze_sw_v11_t*>(att), false);
360 #else
361 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
362 // if something changed, set att to mNewAtt, and
363 // the new params will be effective later when updateConfig
364 // called by RkAiqCore
365 bool isChanged = false;
366 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
367 memcmp(&mNewAttV11, att, sizeof(adehaze_sw_v11_t)))
368 isChanged = true;
369 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
370 memcmp(&mCurAttV11, att, sizeof(adehaze_sw_v11_t)))
371 isChanged = true;
372
373 // if something changed
374 if (isChanged) {
375 mNewAttV11 = *att;
376 updateAtt = true;
377 waitSignal(att->sync.sync_mode);
378 }
379 #endif
380
381 mCfgMutex.unlock();
382
383 EXIT_ANALYZER_FUNCTION();
384 return ret;
385 }
386
getSwAttribV11(adehaze_sw_v11_t * att)387 XCamReturn RkAiqAdehazeHandleInt::getSwAttribV11(adehaze_sw_v11_t* att) {
388 ENTER_ANALYZER_FUNCTION();
389
390 XCamReturn ret = XCAM_RETURN_NO_ERROR;
391
392 #ifdef DISABLE_HANDLE_ATTRIB
393 mCfgMutex.lock();
394 ret = rk_aiq_uapi_adehaze_v11_GetAttrib(mAlgoCtx, att);
395 mCfgMutex.unlock();
396 #else
397 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
398 mCfgMutex.lock();
399 rk_aiq_uapi_adehaze_v11_GetAttrib(mAlgoCtx, att);
400 att->sync.done = true;
401 mCfgMutex.unlock();
402 } else {
403 if (updateAtt) {
404 memcpy(att, &mNewAttV11, sizeof(adehaze_sw_v11_t));
405 att->sync.done = false;
406 } else {
407 rk_aiq_uapi_adehaze_v11_GetAttrib(mAlgoCtx, att);
408 att->sync.sync_mode = mNewAttV11.sync.sync_mode;
409 att->sync.done = true;
410 }
411 }
412 #endif
413
414 EXIT_ANALYZER_FUNCTION();
415 return ret;
416 }
417 #endif
418 #if RKAIQ_HAVE_DEHAZE_V12
setSwAttribV12(const adehaze_sw_v12_t * att)419 XCamReturn RkAiqAdehazeHandleInt::setSwAttribV12(const adehaze_sw_v12_t* att) {
420 ENTER_ANALYZER_FUNCTION();
421
422 XCamReturn ret = XCAM_RETURN_NO_ERROR;
423 mCfgMutex.lock();
424
425 #ifdef DISABLE_HANDLE_ATTRIB
426 ret = rk_aiq_uapi_adehaze_v12_SetAttrib(mAlgoCtx, const_cast<adehaze_sw_v12_t*>(att), false);
427 #else
428 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
429 // if something changed, set att to mNewAtt, and
430 // the new params will be effective later when updateConfig
431 // called by RkAiqCore
432 bool isChanged = false;
433 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
434 memcmp(&mNewAttV12, att, sizeof(adehaze_sw_v12_t)))
435 isChanged = true;
436 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
437 memcmp(&mCurAttV12, att, sizeof(adehaze_sw_v12_t)))
438 isChanged = true;
439
440 // if something changed
441 if (isChanged) {
442 mNewAttV12 = *att;
443 updateAtt = true;
444 waitSignal(att->sync.sync_mode);
445 }
446 #endif
447
448 mCfgMutex.unlock();
449
450 EXIT_ANALYZER_FUNCTION();
451 return ret;
452 }
453
getSwAttribV12(adehaze_sw_v12_t * att)454 XCamReturn RkAiqAdehazeHandleInt::getSwAttribV12(adehaze_sw_v12_t* att) {
455 ENTER_ANALYZER_FUNCTION();
456
457 XCamReturn ret = XCAM_RETURN_NO_ERROR;
458
459 #ifdef DISABLE_HANDLE_ATTRIB
460 mCfgMutex.lock();
461 ret = rk_aiq_uapi_adehaze_v12_GetAttrib(mAlgoCtx, att);
462 mCfgMutex.unlock();
463 #else
464 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
465 mCfgMutex.lock();
466 rk_aiq_uapi_adehaze_v12_GetAttrib(mAlgoCtx, att);
467 att->sync.done = true;
468 mCfgMutex.unlock();
469 } else {
470 if (updateAtt) {
471 memcpy(att, &mNewAttV12, sizeof(adehaze_sw_v12_t));
472 att->sync.done = false;
473 } else {
474 rk_aiq_uapi_adehaze_v12_GetAttrib(mAlgoCtx, att);
475 att->sync.sync_mode = mNewAttV12.sync.sync_mode;
476 att->sync.done = true;
477 }
478 }
479 #endif
480
481 EXIT_ANALYZER_FUNCTION();
482 return ret;
483 }
484 #endif
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)485 XCamReturn RkAiqAdehazeHandleInt::genIspResult(RkAiqFullParams* params,
486 RkAiqFullParams* cur_params) {
487 ENTER_ANALYZER_FUNCTION();
488
489 XCamReturn ret = XCAM_RETURN_NO_ERROR;
490 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
491 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
492 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
493 RkAiqAlgoProcResAdhaz* adhaz_com = (RkAiqAlgoProcResAdhaz*)mProcOutParam;
494 rk_aiq_isp_dehaze_params_v20_t* dehaze_param = params->mDehazeParams->data().ptr();
495
496 if (!adhaz_com) {
497 LOGD_ANALYZER("no adhaz result");
498 return XCAM_RETURN_NO_ERROR;
499 }
500
501 if (sharedCom->init) {
502 dehaze_param->frame_id = 0;
503 } else {
504 dehaze_param->frame_id = shared->frameId;
505 }
506
507 if (adhaz_com->res_com.cfg_update) {
508 mSyncFlag = shared->frameId;
509 dehaze_param->sync_flag = mSyncFlag;
510 // copy from algo result
511 // set as the latest result
512 cur_params->mDehazeParams = params->mDehazeParams;
513 dehaze_param->is_update = true;
514 LOGD_ADEHAZE("[%d] params from algo", mSyncFlag);
515 } else if (mSyncFlag != dehaze_param->sync_flag) {
516 dehaze_param->sync_flag = mSyncFlag;
517 // copy from latest result
518 if (cur_params->mDehazeParams.ptr()) {
519 dehaze_param->result = cur_params->mDehazeParams->data()->result;
520 dehaze_param->is_update = true;
521 } else {
522 LOGE_ADEHAZE("no latest params !");
523 dehaze_param->is_update = false;
524 }
525 LOGD_ADEHAZE("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
526 } else {
527 // do nothing, result in buf needn't update
528 dehaze_param->is_update = false;
529 LOGD_ADEHAZE("[%d] params needn't update", shared->frameId);
530 }
531
532 EXIT_ANALYZER_FUNCTION();
533
534 return ret;
535 }
536
537 } // namespace RkCam
538