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 "RkAiqAfHandle.h"
17
18 #include <fcntl.h>
19
20 #include "RkAiqAeHandle.h"
21 #include "RkAiqCore.h"
22
23 namespace RkCam {
24
25 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAfHandleInt);
26
init()27 void RkAiqAfHandleInt::init() {
28 ENTER_ANALYZER_FUNCTION();
29
30 RkAiqHandle::deInit();
31 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAf());
32 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAf());
33 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAf());
34
35 mLastZoomIndex = 0;
36
37 EXIT_ANALYZER_FUNCTION();
38 }
39
updateConfig(bool needSync)40 XCamReturn RkAiqAfHandleInt::updateConfig(bool needSync) {
41 ENTER_ANALYZER_FUNCTION();
42
43 XCamReturn ret = XCAM_RETURN_NO_ERROR;
44 #ifndef DISABLE_HANDLE_ATTRIB
45 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
46
47 {
48 if (needSync) mCfgMutex.lock();
49 // if something changed
50 if (updateAtt) {
51 rk_aiq_uapi_af_SetAttrib(mAlgoCtx, mNewAtt, false);
52 isUpdateAttDone = true;
53 }
54 if (needSync) mCfgMutex.unlock();
55 }
56 #endif
57
58 EXIT_ANALYZER_FUNCTION();
59 return ret;
60 }
61
setAttrib(rk_aiq_af_attrib_t * att)62 XCamReturn RkAiqAfHandleInt::setAttrib(rk_aiq_af_attrib_t* att) {
63 ENTER_ANALYZER_FUNCTION();
64
65 XCamReturn ret = XCAM_RETURN_NO_ERROR;
66 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
67
68 mCfgMutex.lock();
69 #ifdef DISABLE_HANDLE_ATTRIB
70 ret = rk_aiq_uapi_af_SetAttrib(mAlgoCtx, *att, false);
71 #else
72
73 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
74 // if something changed, set att to mNewAtt, and
75 // the new params will be effective later when updateConfig
76 // called by RkAiqCore
77 bool isChanged = false;
78 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
79 memcmp(&mNewAtt, att, sizeof(*att)))
80 isChanged = true;
81 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
82 memcmp(&mCurAtt, att, sizeof(*att)))
83 isChanged = true;
84
85 // if something changed
86 if (isChanged/* || (mCurAtt.AfMode == RKAIQ_AF_MODE_AUTO && sharedCom->snsDes.lens_des.focus_support)*/) {
87 mNewAtt = *att;
88 updateAtt = true;
89 isUpdateAttDone = false;
90 LOGI_AF("%s: AfMode %d, win: %d, %d, %d, %d",
91 __func__, att->AfMode, att->h_offs, att->v_offs, att->h_size, att->v_size);
92 waitSignal(att->sync.sync_mode);
93 }
94 #endif
95
96 mCfgMutex.unlock();
97
98 EXIT_ANALYZER_FUNCTION();
99 return ret;
100 }
101
getAttrib(rk_aiq_af_attrib_t * att)102 XCamReturn RkAiqAfHandleInt::getAttrib(rk_aiq_af_attrib_t* att) {
103 ENTER_ANALYZER_FUNCTION();
104
105 XCamReturn ret = XCAM_RETURN_NO_ERROR;
106
107 #ifdef DISABLE_HANDLE_ATTRIB
108 mCfgMutex.lock();
109 rk_aiq_uapi_af_GetAttrib(mAlgoCtx, att);
110 mCfgMutex.unlock();
111 #else
112 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
113 mCfgMutex.lock();
114 rk_aiq_uapi_af_GetAttrib(mAlgoCtx, att);
115 att->sync.done = true;
116 mCfgMutex.unlock();
117 } else {
118 if (updateAtt) {
119 memcpy(att, &mNewAtt, sizeof(mNewAtt));
120 att->sync.done = false;
121 } else {
122 rk_aiq_uapi_af_GetAttrib(mAlgoCtx, att);
123 att->sync.sync_mode = mNewAtt.sync.sync_mode;
124 att->sync.done = true;
125 }
126 }
127 #endif
128
129 EXIT_ANALYZER_FUNCTION();
130 return ret;
131 }
132
lock()133 XCamReturn RkAiqAfHandleInt::lock() {
134 ENTER_ANALYZER_FUNCTION();
135
136 XCamReturn ret = XCAM_RETURN_NO_ERROR;
137 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
138
139 if (sharedCom->snsDes.lens_des.focus_support) rk_aiq_uapi_af_Lock(mAlgoCtx);
140
141 EXIT_ANALYZER_FUNCTION();
142 return ret;
143 }
144
unlock()145 XCamReturn RkAiqAfHandleInt::unlock() {
146 ENTER_ANALYZER_FUNCTION();
147
148 XCamReturn ret = XCAM_RETURN_NO_ERROR;
149 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
150
151 if (sharedCom->snsDes.lens_des.focus_support) rk_aiq_uapi_af_Unlock(mAlgoCtx);
152
153 EXIT_ANALYZER_FUNCTION();
154 return ret;
155 }
156
Oneshot()157 XCamReturn RkAiqAfHandleInt::Oneshot() {
158 ENTER_ANALYZER_FUNCTION();
159
160 XCamReturn ret = XCAM_RETURN_NO_ERROR;
161 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
162
163 if (sharedCom->snsDes.lens_des.focus_support) rk_aiq_uapi_af_Oneshot(mAlgoCtx);
164
165 EXIT_ANALYZER_FUNCTION();
166 return ret;
167 }
168
ManualTriger()169 XCamReturn RkAiqAfHandleInt::ManualTriger() {
170 ENTER_ANALYZER_FUNCTION();
171
172 XCamReturn ret = XCAM_RETURN_NO_ERROR;
173 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
174
175 if (sharedCom->snsDes.lens_des.focus_support) rk_aiq_uapi_af_ManualTriger(mAlgoCtx);
176
177 EXIT_ANALYZER_FUNCTION();
178 return ret;
179 }
180
Tracking()181 XCamReturn RkAiqAfHandleInt::Tracking() {
182 ENTER_ANALYZER_FUNCTION();
183
184 XCamReturn ret = XCAM_RETURN_NO_ERROR;
185 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
186
187 if (sharedCom->snsDes.lens_des.focus_support) rk_aiq_uapi_af_Tracking(mAlgoCtx);
188
189 EXIT_ANALYZER_FUNCTION();
190 return ret;
191 }
192
setZoomIndex(int index)193 XCamReturn RkAiqAfHandleInt::setZoomIndex(int index) {
194 ENTER_ANALYZER_FUNCTION();
195
196 XCamReturn ret = XCAM_RETURN_NO_ERROR;
197 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
198
199 if (sharedCom->snsDes.lens_des.zoom_support) {
200 mCfgMutex.lock();
201 rk_aiq_uapi_af_setZoomIndex(mAlgoCtx, index);
202 isUpdateZoomPosDone = true;
203 waitSignal();
204 mCfgMutex.unlock();
205 }
206
207 EXIT_ANALYZER_FUNCTION();
208 return ret;
209 }
210
getZoomIndex(int * index)211 XCamReturn RkAiqAfHandleInt::getZoomIndex(int* index) {
212 ENTER_ANALYZER_FUNCTION();
213
214 XCamReturn ret = XCAM_RETURN_NO_ERROR;
215 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
216
217 if (sharedCom->snsDes.lens_des.zoom_support) {
218 rk_aiq_uapi_af_getZoomIndex(mAlgoCtx, index);
219 }
220
221 EXIT_ANALYZER_FUNCTION();
222 return ret;
223 }
224
endZoomChg()225 XCamReturn RkAiqAfHandleInt::endZoomChg() {
226 ENTER_ANALYZER_FUNCTION();
227
228 XCamReturn ret = XCAM_RETURN_NO_ERROR;
229 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
230
231 if (sharedCom->snsDes.lens_des.zoom_support) {
232 mCfgMutex.lock();
233 rk_aiq_uapi_af_endZoomChg(mAlgoCtx);
234 mCfgMutex.unlock();
235 }
236
237 EXIT_ANALYZER_FUNCTION();
238 return ret;
239 }
240
startZoomCalib()241 XCamReturn RkAiqAfHandleInt::startZoomCalib() {
242 ENTER_ANALYZER_FUNCTION();
243
244 XCamReturn ret = XCAM_RETURN_NO_ERROR;
245 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
246
247 if (sharedCom->snsDes.lens_des.zoom_support) {
248 mCfgMutex.lock();
249 rk_aiq_uapi_af_startZoomCalib(mAlgoCtx);
250 isUpdateZoomPosDone = true;
251 waitSignal();
252 mCfgMutex.unlock();
253 }
254
255 EXIT_ANALYZER_FUNCTION();
256 return ret;
257 }
258
resetZoom()259 XCamReturn RkAiqAfHandleInt::resetZoom() {
260 ENTER_ANALYZER_FUNCTION();
261
262 XCamReturn ret = XCAM_RETURN_NO_ERROR;
263 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
264
265 if (sharedCom->snsDes.lens_des.zoom_support) {
266 mCfgMutex.lock();
267 rk_aiq_uapi_af_resetZoom(mAlgoCtx);
268 isUpdateZoomPosDone = true;
269 waitSignal();
270 mCfgMutex.unlock();
271 }
272
273 EXIT_ANALYZER_FUNCTION();
274 return ret;
275 }
276
GetSearchPath(rk_aiq_af_sec_path_t * path)277 XCamReturn RkAiqAfHandleInt::GetSearchPath(rk_aiq_af_sec_path_t* path) {
278 ENTER_ANALYZER_FUNCTION();
279
280 XCamReturn ret = XCAM_RETURN_NO_ERROR;
281 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
282
283 if (sharedCom->snsDes.lens_des.focus_support) rk_aiq_uapi_af_getSearchPath(mAlgoCtx, path);
284
285 EXIT_ANALYZER_FUNCTION();
286 return ret;
287 }
288
GetSearchResult(rk_aiq_af_result_t * result)289 XCamReturn RkAiqAfHandleInt::GetSearchResult(rk_aiq_af_result_t* result) {
290 ENTER_ANALYZER_FUNCTION();
291
292 XCamReturn ret = XCAM_RETURN_NO_ERROR;
293 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
294
295 if (sharedCom->snsDes.lens_des.focus_support) rk_aiq_uapi_af_getSearchResult(mAlgoCtx, result);
296
297 EXIT_ANALYZER_FUNCTION();
298 return ret;
299 }
300
GetFocusRange(rk_aiq_af_focusrange * range)301 XCamReturn RkAiqAfHandleInt::GetFocusRange(rk_aiq_af_focusrange* range) {
302 ENTER_ANALYZER_FUNCTION();
303
304 XCamReturn ret = XCAM_RETURN_NO_ERROR;
305 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
306
307 if (sharedCom->snsDes.lens_des.focus_support) rk_aiq_uapi_af_getFocusRange(mAlgoCtx, range);
308
309 EXIT_ANALYZER_FUNCTION();
310 return ret;
311 }
312
setAeStable(bool ae_stable)313 XCamReturn RkAiqAfHandleInt::setAeStable(bool ae_stable) {
314 ENTER_ANALYZER_FUNCTION();
315
316 XCamReturn ret = XCAM_RETURN_NO_ERROR;
317 mAeStableMutex.lock();
318 mAeStable = ae_stable;
319 mAeStableMutex.unlock();
320
321 EXIT_ANALYZER_FUNCTION();
322 return ret;
323 }
324
prepare()325 XCamReturn RkAiqAfHandleInt::prepare() {
326 ENTER_ANALYZER_FUNCTION();
327
328 XCamReturn ret = XCAM_RETURN_NO_ERROR;
329
330 ret = RkAiqHandle::prepare();
331 RKAIQCORE_CHECK_RET(ret, "af handle prepare failed");
332
333 RkAiqAlgoConfigAf* af_config_int = (RkAiqAlgoConfigAf*)mConfig;
334 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
335
336 af_config_int->af_mode = 6;
337 af_config_int->win_h_offs = 0;
338 af_config_int->win_v_offs = 0;
339 af_config_int->win_h_size = 0;
340 af_config_int->win_v_size = 0;
341 af_config_int->lens_des = sharedCom->snsDes.lens_des;
342
343 // for otp
344 af_config_int->otp_af = sharedCom->snsDes.otp_af;
345 af_config_int->otp_pdaf = sharedCom->snsDes.otp_pdaf;
346
347 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
348 ret = des->prepare(mConfig);
349 RKAIQCORE_CHECK_RET(ret, "af algo prepare failed");
350
351 EXIT_ANALYZER_FUNCTION();
352 return XCAM_RETURN_NO_ERROR;
353 }
354
preProcess()355 XCamReturn RkAiqAfHandleInt::preProcess() {
356 return XCAM_RETURN_NO_ERROR;
357 }
358
getValueFromFile(const char * path,int * pos)359 bool RkAiqAfHandleInt::getValueFromFile(const char* path, int* pos) {
360 const char* delim = " ";
361 char buffer[16] = {0};
362 int fp;
363
364 fp = open(path, O_RDONLY | O_SYNC);
365 if (fp != -1) {
366 if (read(fp, buffer, sizeof(buffer)) <= 0) {
367 LOGE_AF("%s read %s failed!", __func__, path);
368 goto OUT;
369 } else {
370 char* p = nullptr;
371
372 p = strtok(buffer, delim);
373 if (p != nullptr) {
374 *pos = atoi(p);
375 }
376 }
377 close(fp);
378 return true;
379 }
380
381 OUT:
382 return false;
383 }
384
processing()385 XCamReturn RkAiqAfHandleInt::processing() {
386 ENTER_ANALYZER_FUNCTION();
387
388 XCamReturn ret = XCAM_RETURN_NO_ERROR;
389 RkAiqAlgoProcAf* af_proc_int = (RkAiqAlgoProcAf*)mProcInParam;
390
391 RkAiqAlgoProcResAf* af_proc_res_int = (RkAiqAlgoProcResAf*)mProcOutParam;
392
393 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
394 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
395 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
396
397 #if RKAIQ_HAVE_AF_V32_LITE || RKAIQ_ONLY_AF_STATS_V32_LITE
398 af_proc_res_int->af_isp_param_v32 = &shared->fullParams->mAfV32LiteParams->data()->result;
399 #endif
400 #if RKAIQ_HAVE_AF_V31 || RKAIQ_ONLY_AF_STATS_V31
401 af_proc_res_int->af_isp_param_v31 = &shared->fullParams->mAfV32Params->data()->result;
402 #endif
403 #if RKAIQ_HAVE_AF_V30 || RKAIQ_ONLY_AF_STATS_V30
404 af_proc_res_int->af_isp_param_v3x = &shared->fullParams->mAfV3xParams->data()->result;
405 #endif
406 #if RKAIQ_HAVE_AF_V20 || RKAIQ_ONLY_AF_STATS_V20
407 af_proc_res_int->af_isp_param = &shared->fullParams->mAfParams->data()->result;
408 #endif
409
410 af_proc_res_int->af_focus_param = &shared->fullParams->mFocusParams->data()->result;
411
412 //#define ZOOM_MOVE_DEBUG
413 #ifdef ZOOM_MOVE_DEBUG
414 int zoom_index = 0;
415
416 if (getValueFromFile("/data/.zoom_pos", &zoom_index) == true) {
417 if (mLastZoomIndex != zoom_index) {
418 setZoomIndex(zoom_index);
419 endZoomChg();
420 mLastZoomIndex = zoom_index;
421 }
422 }
423 #endif
424
425 ret = RkAiqHandle::processing();
426 if (ret < 0) {
427 LOGE_ANALYZER("af handle processing failed ret %d", ret);
428 return ret;
429 } else if (ret == XCAM_RETURN_BYPASS) {
430 LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
431 return ret;
432 }
433
434 RkAiqAfStats* xAfStats = nullptr;
435 if (shared->afStatsBuf) {
436 xAfStats = shared->afStatsBuf;
437 if (!xAfStats) LOGE("af stats is null");
438 } else {
439 LOGW("the xcamvideobuffer of af stats is null");
440 }
441
442 #if RKAIQ_HAVE_AF
443 if ((!xAfStats || !xAfStats->af_stats_valid) && !sharedCom->init) {
444 LOGW("no af stats, ignore!");
445 return XCAM_RETURN_BYPASS;
446 }
447
448 #if RKAIQ_HAVE_AF_V20
449 if (xAfStats) {
450 af_proc_int->xcam_af_stats = &xAfStats->af_stats;
451 af_proc_int->aecExpInfo = &xAfStats->aecExpInfo;
452 } else {
453 af_proc_int->xcam_af_stats = NULL;
454 af_proc_int->aecExpInfo = NULL;
455 }
456 #else
457 if (xAfStats) {
458 af_proc_int->xcam_af_stats_v3x = &xAfStats->af_stats_v3x;
459 af_proc_int->aecExpInfo = &xAfStats->aecExpInfo;
460 } else {
461 af_proc_int->xcam_af_stats_v3x = NULL;
462 af_proc_int->aecExpInfo = NULL;
463 }
464 #endif
465 if (shared->aecStatsBuf)
466 af_proc_int->xcam_aec_stats = &shared->aecStatsBuf->aec_stats;
467 else
468 af_proc_int->xcam_aec_stats = NULL;
469 if (shared->pdafStatsBuf)
470 af_proc_int->xcam_pdaf_stats = &shared->pdafStatsBuf->pdaf_stats;
471 else
472 af_proc_int->xcam_pdaf_stats = NULL;
473 mAeStableMutex.lock();
474 af_proc_int->ae_stable = mAeStable;
475 mAeStableMutex.unlock();
476 #endif
477
478 #ifdef DISABLE_HANDLE_ATTRIB
479 mCfgMutex.lock();
480 #endif
481 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
482 ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)af_proc_res_int);
483 #ifdef DISABLE_HANDLE_ATTRIB
484 mCfgMutex.unlock();
485 #endif
486 if (ret < 0) {
487 LOGE_ANALYZER("af algo processing failed ret %d", ret);
488 return ret;
489 } else if (ret == XCAM_RETURN_BYPASS) {
490 LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
491 return ret;
492 }
493
494 #ifndef DISABLE_HANDLE_ATTRIB
495 if (updateAtt && isUpdateAttDone) {
496 mCurAtt = mNewAtt;
497 updateAtt = false;
498 isUpdateAttDone = false;
499 sendSignal(mCurAtt.sync.sync_mode);
500 }
501 #endif
502
503 if (isUpdateZoomPosDone) {
504 isUpdateZoomPosDone = false;
505 sendSignal();
506 }
507
508 EXIT_ANALYZER_FUNCTION();
509 return ret;
510 }
511
postProcess()512 XCamReturn RkAiqAfHandleInt::postProcess() {
513 return XCAM_RETURN_NO_ERROR;
514 }
515
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)516 XCamReturn RkAiqAfHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
517 ENTER_ANALYZER_FUNCTION();
518
519 XCamReturn ret = XCAM_RETURN_NO_ERROR;
520 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
521 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
522 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
523
524 RkAiqAlgoProcResAf* af_com = (RkAiqAlgoProcResAf*)mProcOutParam ;
525 #if RKAIQ_HAVE_AF_V32_LITE || RKAIQ_ONLY_AF_STATS_V32_LITE
526 rk_aiq_isp_af_params_v32_lite_t* af_param = params->mAfV32LiteParams->data().ptr();
527 #endif
528 #if RKAIQ_HAVE_AF_V31 || RKAIQ_ONLY_AF_STATS_V31
529 rk_aiq_isp_af_params_v32_t* af_param = params->mAfV32Params->data().ptr();
530 #endif
531 #if RKAIQ_HAVE_AF_V30 || RKAIQ_ONLY_AF_STATS_V30
532 rk_aiq_isp_af_params_v3x_t* af_param = params->mAfV3xParams->data().ptr();
533 #endif
534 #if RKAIQ_HAVE_AF_V20 || RKAIQ_ONLY_AF_STATS_V20
535 rk_aiq_isp_af_params_v20_t* af_param = params->mAfParams->data().ptr();
536 #endif
537
538 SmartPtr<rk_aiq_focus_params_wrapper_t> focus_param = params->mFocusParams->data();
539
540 if (!this->getAlgoId()) {
541 RkAiqAlgoProcResAf* af_rk = (RkAiqAlgoProcResAf*)af_com;
542
543 if (sharedCom->init) {
544 af_param->frame_id = 0;
545 focus_param->frame_id = 0;
546 } else {
547 af_param->frame_id = shared->frameId;
548 focus_param->frame_id = shared->frameId;
549 }
550
551 SmartPtr<RkAiqHandle>* ae_handle = mAiqCore->getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AE);
552 int algo_id = (*ae_handle)->getAlgoId();
553
554 if (ae_handle) {
555 if (algo_id == 0) {
556 RkAiqAeHandleInt* ae_algo = dynamic_cast<RkAiqAeHandleInt*>(ae_handle->ptr());
557
558 if (af_rk->lockae_en)
559 ae_algo->setLockAeForAf(af_rk->lockae);
560 else
561 ae_algo->setLockAeForAf(false);
562 }
563 }
564 }
565
566 if (af_com->af_cfg_update) {
567 mAfMeasResSyncFalg = shared->frameId;
568 af_param->sync_flag = mAfMeasResSyncFalg;
569 #if RKAIQ_HAVE_AF_V32_LITE || RKAIQ_ONLY_AF_STATS_V32_LITE
570 cur_params->mAfV32LiteParams = params->mAfV32LiteParams;
571 #endif
572 #if RKAIQ_HAVE_AF_V31 || RKAIQ_ONLY_AF_STATS_V31
573 cur_params->mAfV32Params = params->mAfV32Params;
574 #endif
575 #if RKAIQ_HAVE_AF_V30 || RKAIQ_ONLY_AF_STATS_V30
576 cur_params->mAfV3xParams = params->mAfV3xParams;
577 #endif
578 #if RKAIQ_HAVE_AF_V20 || RKAIQ_ONLY_AF_STATS_V20
579 cur_params->mAfParams = params->mAfParams;
580 #endif
581 af_param->is_update = true;
582 af_com->af_cfg_update = false;
583 LOGD_AF("[%d] meas params from algo", mAfMeasResSyncFalg);
584 } else if (mAfMeasResSyncFalg != af_param->sync_flag) {
585 af_param->sync_flag = mAfMeasResSyncFalg;
586 #if RKAIQ_HAVE_AF_V32_LITE || RKAIQ_ONLY_AF_STATS_V32_LITE
587 if (cur_params->mAfV32LiteParams.ptr()) {
588 af_param->result = cur_params->mAfV32LiteParams->data()->result;
589 af_param->is_update = true;
590 } else {
591 LOGE_AF("no latest meas params !");
592 af_param->is_update = false;
593 }
594 #endif
595 #if RKAIQ_HAVE_AF_V31 || RKAIQ_ONLY_AF_STATS_V31
596 if (cur_params->mAfV32Params.ptr()) {
597 af_param->result = cur_params->mAfV32Params->data()->result;
598 af_param->is_update = true;
599 } else {
600 LOGE_AF("no latest meas params !");
601 af_param->is_update = false;
602 }
603 #endif
604 #if RKAIQ_HAVE_AF_V30 || RKAIQ_ONLY_AF_STATS_V30
605 if (cur_params->mAfV3xParams.ptr()) {
606 af_param->result = cur_params->mAfV3xParams->data()->result;
607 af_param->is_update = true;
608 } else {
609 LOGE_AF("no latest meas params !");
610 af_param->is_update = false;
611 }
612 #endif
613 #if RKAIQ_HAVE_AF_V20 || RKAIQ_ONLY_AF_STATS_V20
614 if (cur_params->mAfParams.ptr()) {
615 af_param->result = cur_params->mAfParams->data()->result;
616 af_param->is_update = true;
617 } else {
618 LOGE_AF("no latest meas params !");
619 af_param->is_update = false;
620 }
621 #endif
622 LOGD_AF("[%d] meas params from latest [%d]", shared->frameId, mAfMeasResSyncFalg);
623 } else {
624 // do nothing, result in buf needn't update
625 af_param->is_update = false;
626 LOGD_AF("[%d] meas params needn't update", shared->frameId);
627 }
628
629 if (af_com->af_focus_update) {
630 mAfFocusResSyncFalg = shared->frameId;
631 focus_param->sync_flag = mAfFocusResSyncFalg;
632 cur_params->mFocusParams = params->mFocusParams;
633 focus_param->is_update = true;
634 af_com->af_focus_update = false;
635 LOGD_AF("[%d] focus params from algo", mAfFocusResSyncFalg);
636 } else if (mAfFocusResSyncFalg != focus_param->sync_flag) {
637 focus_param->sync_flag = mAfFocusResSyncFalg;
638 if (cur_params->mFocusParams.ptr()) {
639 focus_param->result = cur_params->mFocusParams->data()->result;
640 focus_param->is_update = true;
641 } else {
642 LOGE_AF("no focus latest params !");
643 focus_param->is_update = false;
644 }
645 LOGD_AF("[%d] focus params from latest [%d]", shared->frameId, mAfFocusResSyncFalg);
646 } else {
647 // do nothing, result in buf needn't update
648 focus_param->is_update = false;
649 LOGD_AF("[%d] focus params needn't update", shared->frameId);
650 }
651
652 EXIT_ANALYZER_FUNCTION();
653
654 return ret;
655 }
656
657 } // namespace RkCam
658