1 /*
2 * Copyright (c) 2019-2021 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 "RkAiqCore.h"
17
18 #include <fcntl.h>
19 #include <unistd.h>
20
21 #include <fstream>
22 #include <iostream>
23
24 #include "RkAiqHandleInt.h"
25 #include "v4l2_buffer_proxy.h"
26 #ifdef RK_SIMULATOR_HW
27 #include "simulator/isp20_hw_simulator.h"
28 #else
29 #include "common/rkisp2-config.h"
30 #include "common/rkisp21-config.h"
31 #include "isp20/Isp20Evts.h"
32 #include "isp20/Isp20StatsBuffer.h"
33 #include "isp20/rkispp-config.h"
34 #endif
35
36 #include "PdafStreamProcUnit.h"
37 #include "SPStreamProcUnit.h"
38 // #include "MessageBus.h"
39 #include "RkAiqAnalyzeGroupManager.h"
40 #include "RkAiqResourceTranslatorV21.h"
41 #include "RkAiqResourceTranslatorV32.h"
42 #include "RkAiqResourceTranslatorV3x.h"
43 #ifdef RKAIQ_ENABLE_CAMGROUP
44 #include "RkAiqCamGroupManager.h"
45 #endif
46 #include "RkAiqCamProfiles.h"
47 #include "RkAiqCoreConfig.h"
48 #include "RkAiqCustomAeHandle.h"
49 #include "RkAiqCustomAwbHandle.h"
50 #include "algo_handlers/RkAiqAfdHandle.h"
51
52 #include "RkAiqCoreConfig.h"
53
54 namespace RkCam {
55
56 #define EPSINON 0.0000001
57
58 bool
loop()59 RkAiqCoreThread::loop()
60 {
61 ENTER_ANALYZER_FUNCTION();
62
63 const static int32_t timeout = -1;
64 SmartPtr<VideoBuffer> stats = mStatsQueue.pop (timeout);
65
66 if (!stats.ptr()) {
67 LOGW_ANALYZER("RkAiqCoreThread got empty stats, stop thread");
68 return false;
69 }
70
71 XCamReturn ret = mRkAiqCore->analyze (stats);
72 if (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS)
73 return true;
74
75 LOGE_ANALYZER("RkAiqCoreThread failed to analyze 3a stats");
76
77 EXIT_ANALYZER_FUNCTION();
78
79 return false;
80 }
81
82 bool
loop()83 RkAiqCoreEvtsThread::loop()
84 {
85 ENTER_ANALYZER_FUNCTION();
86
87 const static int32_t timeout = -1;
88
89 SmartPtr<ispHwEvt_t> evts = mEvtsQueue.pop (timeout);
90 if (!evts.ptr()) {
91 LOGW_ANALYZER("RkAiqCoreEvtsThread got empty stats, stop thread");
92 return false;
93 }
94
95 XCamReturn ret = mRkAiqCore->events_analyze (evts);
96 if (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS)
97 return true;
98
99 LOGE_ANALYZER("RkAiqCoreEvtsThread failed to analyze events");
100
101 EXIT_ANALYZER_FUNCTION();
102
103 return false;
104 }
105
106 // notice that some pool shared items may be cached by other
107 // modules(e.g. CamHwIsp20), so here should consider the cached number
108 uint16_t RkAiqCore::DEFAULT_POOL_SIZE = 3;
109 static uint16_t FULLPARMAS_MAX_PENDING_SIZE = 2;
110
isGroupAlgo(int algoType)111 bool RkAiqCore::isGroupAlgo(int algoType) {
112 static auto policy = mProfiles.getAlgoPolicies();
113 return policy[algoType] == CamProfiles::AlgoSchedPolicy::kGroupOnly;
114 }
115
116 #define RKAIQ_DISABLE_CORETHRD
117 #define RKAIQ_DISABLE_EVTSTHRD
118
RkAiqCore(int isp_hw_ver)119 RkAiqCore::RkAiqCore(int isp_hw_ver)
120 :
121 #ifndef RKAIQ_DISABLE_CORETHRD
122 mRkAiqCoreTh(new RkAiqCoreThread(this)),
123 #endif
124 #if defined(ISP_HW_V20)
125 mRkAiqCorePpTh(new RkAiqCoreThread(this)),
126 #endif
127 #ifndef RKAIQ_DISABLE_CORETHRD
128 mRkAiqCoreEvtsTh(new RkAiqCoreEvtsThread(this)),
129 #endif
130 mState(RK_AIQ_CORE_STATE_INVALID)
131 , mCb(NULL)
132 , mIsSingleThread(true)
133 , mAiqParamsPool(new RkAiqFullParamsPool("RkAiqFullParams", RkAiqCore::DEFAULT_POOL_SIZE))
134 , mAiqCpslParamsPool(new RkAiqCpslParamsPool("RkAiqCpslParamsPool", RkAiqCore::DEFAULT_POOL_SIZE))
135 , mAiqStatsPool(nullptr)
136 , mAiqSofInfoWrapperPool(new RkAiqSofInfoWrapperPool("RkAiqSofPoolWrapper", RkAiqCore::DEFAULT_POOL_SIZE))
137 , mAiqIspStatsIntPool(new RkAiqIspStatsIntPool("RkAiqIspStatsIntPool", RkAiqCore::DEFAULT_POOL_SIZE))
138 , mAiqAecStatsPool(nullptr)
139 , mAiqAwbStatsPool(nullptr)
140 , mAiqAtmoStatsPool(nullptr)
141 , mAiqAdehazeStatsPool(nullptr)
142 , mAiqAfStatsPool(nullptr)
143 , mAiqOrbStatsIntPool(nullptr)
144 #if RKAIQ_HAVE_PDAF
145 , mAiqPdafStatsPool(nullptr)
146 #endif
147 , mInitDisAlgosMask(0)
148 , groupUpdateMask(0x00)
149 {
150 ENTER_ANALYZER_FUNCTION();
151 // mAlogsSharedParams.reset();
152 mAlogsComSharedParams.reset();
153 xcam_mem_clear(mHwInfo);
154 mCurCpslOn = false;
155 mStrthLed = 0.0f;
156 mStrthIr = 0.0f;
157 mGrayMode = RK_AIQ_GRAY_MODE_CPSL;
158 firstStatsReceived = false;
159
160 SmartPtr<RkAiqFullParams> fullParam = new RkAiqFullParams();
161 mAiqCurParams = new RkAiqFullParamsProxy(fullParam );
162 mIspOnline = false;
163 mIspHwVer = isp_hw_ver;
164 mSafeEnableAlgo = true;
165 mLastAnalyzedId = 0;
166 #ifdef RKAIQ_ENABLE_CAMGROUP
167 mCamGroupCoreManager = NULL;
168 #endif
169 mAllReqAlgoResMask = 0;
170 mAlgosDesArray = g_default_3a_des;
171
172 #ifdef ISP_HW_V20
173 mHasPp = true;
174 mTranslator = new RkAiqResourceTranslator();
175 #endif
176 #ifdef ISP_HW_V21
177 mHasPp = false;
178 mTranslator = new RkAiqResourceTranslatorV21();
179 #endif
180 #ifdef ISP_HW_V30
181 mHasPp = false;
182 mTranslator = new RkAiqResourceTranslatorV3x();
183 #endif
184 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
185 mHasPp = false;
186 mTranslator = new RkAiqResourceTranslatorV32();
187 mIsSingleThread = true;
188 #endif
189 mFullParamsPendingMap.clear();
190 EXIT_ANALYZER_FUNCTION();
191 }
192
~RkAiqCore()193 RkAiqCore::~RkAiqCore()
194 {
195 ENTER_ANALYZER_FUNCTION();
196 if (mAlogsComSharedParams.resourcePath) {
197 xcam_free((void*)(mAlogsComSharedParams.resourcePath));
198 mAlogsComSharedParams.resourcePath = NULL;
199 }
200 EXIT_ANALYZER_FUNCTION();
201 }
202
203 #if RKAIQ_HAVE_ASD_V10
initCpsl()204 void RkAiqCore::initCpsl()
205 {
206 queryCpsLtCap(mCpslCap);
207
208 rk_aiq_cpsl_cfg_t* cfg = &mAlogsComSharedParams.cpslCfg;
209 const CamCalibDbV2Context_t* aiqCalib = mAlogsComSharedParams.calibv2;
210 CalibDbV2_Cpsl_t* calibv2_cpsl_db =
211 (CalibDbV2_Cpsl_t*)(CALIBDBV2_GET_MODULE_PTR((void*)aiqCalib, cpsl));
212 CalibDbV2_Cpsl_Param_t* calibv2_cpsl_calib = &calibv2_cpsl_db->param;
213 // TODO: something from calib
214 LOGD_ASD("init cpsl enable %d num %d", calibv2_cpsl_calib->enable, mCpslCap.modes_num);
215 if (mCpslCap.modes_num > 0 && calibv2_cpsl_calib->enable) {
216 cfg->mode = calibv2_cpsl_calib->mode;
217
218 if (calibv2_cpsl_calib->light_src == 1) {
219 cfg->lght_src = RK_AIQ_CPSLS_LED;
220 } else if (calibv2_cpsl_calib->light_src == 2) {
221 cfg->lght_src = RK_AIQ_CPSLS_IR;
222 } else if (calibv2_cpsl_calib->light_src == 3) {
223 cfg->lght_src = RK_AIQ_CPSLS_MIX;
224 } else {
225 cfg->lght_src = RK_AIQ_CPSLS_INVALID;
226 }
227 cfg->gray_on = calibv2_cpsl_calib->force_gray;
228 if (cfg->mode == RK_AIQ_OP_MODE_AUTO) {
229 cfg->u.a.sensitivity = calibv2_cpsl_calib->auto_adjust_sens;
230 cfg->u.a.sw_interval = calibv2_cpsl_calib->auto_sw_interval;
231 LOGD_ASD("mode sensitivity %f, interval time %d s\n",
232 cfg->u.a.sensitivity, cfg->u.a.sw_interval);
233 } else {
234 cfg->u.m.on = calibv2_cpsl_calib->manual_on;
235 cfg->u.m.strength_ir = calibv2_cpsl_calib->manual_strength;
236 cfg->u.m.strength_led = calibv2_cpsl_calib->manual_strength;
237 LOGD_ASD("on %d, strength_led %f, strength_ir %f \n",
238 cfg->u.m.on, cfg->u.m.strength_led, cfg->u.m.strength_ir);
239 }
240 } else {
241 cfg->mode = RK_AIQ_OP_MODE_INVALID;
242 LOGD_ASD("not support light compensation \n");
243 }
244 }
245 #endif
246
247 #ifdef RKAIQ_ENABLE_CAMGROUP
setCamGroupManager(RkAiqCamGroupManager * cam_group_manager)248 void RkAiqCore::setCamGroupManager(RkAiqCamGroupManager* cam_group_manager) {
249 mCamGroupCoreManager = cam_group_manager;
250 if (mTranslator.ptr() && cam_group_manager) mTranslator->setGroupMode(true);
251
252 string ini_path{mAlogsComSharedParams.resourcePath};
253 if (ini_path.length() > 0) {
254 ini_path.append("/profile.ini");
255 } else {
256 ini_path = "/etc/iqfiles/profile.ini";
257 }
258 mProfiles.ParseFromIni(ini_path);
259
260 uint64_t removed_mask = 0xffffffffffffffff;
261 if (mCamGroupCoreManager != nullptr) {
262 if (isGroupAlgo(RK_AIQ_ALGO_TYPE_AE)) {
263 removed_mask &=
264 ~((1ULL << XCAM_MESSAGE_AE_PRE_RES_OK) | (1ULL << XCAM_MESSAGE_AE_PROC_RES_OK));
265 }
266 if (isGroupAlgo(RK_AIQ_ALGO_TYPE_AWB)) {
267 removed_mask &= ~(1ULL << XCAM_MESSAGE_AWB_PROC_RES_OK);
268 }
269 if (isGroupAlgo(RK_AIQ_ALGO_TYPE_AF)) {
270 removed_mask &= ~(1ULL << XCAM_MESSAGE_AF_PROC_RES_OK);
271 }
272 if (isGroupAlgo(RK_AIQ_ALGO_TYPE_AYNR)) {
273 removed_mask &= ~((1ULL << XCAM_MESSAGE_YNR_V3_PROC_RES_OK) |
274 (1ULL << XCAM_MESSAGE_YNR_V22_PROC_RES_OK));
275 }
276 if (isGroupAlgo(RK_AIQ_ALGO_TYPE_ABLC)) {
277 removed_mask &= ~((1ULL << XCAM_MESSAGE_BLC_PROC_RES_OK) |
278 (1ULL << XCAM_MESSAGE_BLC_V32_PROC_RES_OK));
279 }
280 auto groups = mRkAiqCoreGroupManager->getGroups();
281 for (auto& g : groups) {
282 auto f = g.second->getDepsFlag();
283 f &= removed_mask;
284 g.second->setDepsFlag(f);
285 }
286 }
287 }
288 #endif
289
290 XCamReturn
init(const char * sns_ent_name,const CamCalibDbContext_t * aiqCalib,const CamCalibDbV2Context_t * aiqCalibv2)291 RkAiqCore::init(const char* sns_ent_name, const CamCalibDbContext_t* aiqCalib,
292 const CamCalibDbV2Context_t* aiqCalibv2)
293 {
294 ENTER_ANALYZER_FUNCTION();
295
296 if (mState != RK_AIQ_CORE_STATE_INVALID) {
297 LOGE_ANALYZER("wrong state %d\n", mState);
298 return XCAM_RETURN_ERROR_ANALYZER;
299 }
300
301
302 #ifdef RKAIQ_ENABLE_PARSER_V1
303 mAlogsComSharedParams.calib = aiqCalib;
304 #endif
305 mAlogsComSharedParams.calibv2 = aiqCalibv2;
306
307 const CalibDb_AlgoSwitch_t *algoSwitch = &aiqCalibv2->sys_cfg->algoSwitch;
308 if (algoSwitch->enable && algoSwitch->disable_algos) {
309 for (uint16_t i = 0; i < algoSwitch->disable_algos_len; i++)
310 mInitDisAlgosMask |= 1ULL << algoSwitch->disable_algos[i];
311 }
312 LOGI_ANALYZER("mInitDisAlgosMask: 0x%" PRIx64 "\n", mInitDisAlgosMask);
313 addDefaultAlgos(mAlgosDesArray);
314 #if RKAIQ_HAVE_ASD_V10
315 initCpsl();
316 #endif
317 newAiqParamsPool();
318 newAiqGroupAnayzer();
319 #if RKAIQ_HAVE_PDAF
320 newPdafStatsPool();
321 #endif
322
323 mState = RK_AIQ_CORE_STATE_INITED;
324 return XCAM_RETURN_NO_ERROR;
325
326 EXIT_ANALYZER_FUNCTION();
327 }
328
329 XCamReturn
deInit()330 RkAiqCore::deInit()
331 {
332 ENTER_ANALYZER_FUNCTION();
333
334 for (auto mapIt = mAlogsGroupSharedParamsMap.begin(); \
335 mapIt != mAlogsGroupSharedParamsMap.end();) {
336 delete mapIt->second;
337 mAlogsGroupSharedParamsMap.erase(mapIt++);
338 }
339
340 if (mState == RK_AIQ_CORE_STATE_STARTED || mState == RK_AIQ_CORE_STATE_RUNNING) {
341 LOGE_ANALYZER("wrong state %d\n", mState);
342 return XCAM_RETURN_ERROR_ANALYZER;
343 }
344
345 #if RKAIQ_HAVE_PDAF
346 delPdafStatsPool();
347 #endif
348 mState = RK_AIQ_CORE_STATE_INVALID;
349
350 EXIT_ANALYZER_FUNCTION();
351
352 return XCAM_RETURN_NO_ERROR;
353 }
354
355 XCamReturn
start()356 RkAiqCore::start()
357 {
358 ENTER_ANALYZER_FUNCTION();
359
360 if ((mState != RK_AIQ_CORE_STATE_PREPARED) &&
361 (mState != RK_AIQ_CORE_STATE_STOPED)) {
362 LOGE_ANALYZER("wrong state %d\n", mState);
363 return XCAM_RETURN_ERROR_ANALYZER;
364 }
365
366 #ifndef RKAIQ_DISABLE_CORETHRD
367 mRkAiqCoreTh->triger_start();
368 mRkAiqCoreTh->start();
369 #endif
370 #if defined(ISP_HW_V20)
371 if (mHasPp) {
372 mRkAiqCorePpTh->triger_start();
373 mRkAiqCorePpTh->start();
374 }
375 #endif
376 #ifndef RKAIQ_DISABLE_CORETHRD
377 mRkAiqCoreEvtsTh->triger_start();
378 mRkAiqCoreEvtsTh->start();
379 #endif
380
381 #if RKAIQ_HAVE_PDAF
382 uint64_t deps = mRkAiqCoreGroupManager->getGrpDeps(RK_AIQ_CORE_ANALYZE_AF);
383 if (get_pdaf_support()) {
384 deps |= 1LL << XCAM_MESSAGE_PDAF_STATS_OK;
385 } else {
386 deps &= ~(1LL << XCAM_MESSAGE_PDAF_STATS_OK);
387 }
388 mRkAiqCoreGroupManager->setGrpDeps(RK_AIQ_CORE_ANALYZE_AF, deps);
389 #endif
390 mRkAiqCoreGroupManager->start();
391
392 #if defined(RKAIQ_HAVE_THUMBNAILS)
393 if (mThumbnailsService.ptr()) {
394 mThumbnailsService->Start();
395 }
396 #endif
397
398 mState = RK_AIQ_CORE_STATE_STARTED;
399
400 EXIT_ANALYZER_FUNCTION();
401
402 return XCAM_RETURN_NO_ERROR;
403 }
404
405 XCamReturn
stop()406 RkAiqCore::stop()
407 {
408 ENTER_ANALYZER_FUNCTION();
409
410 if (mState != RK_AIQ_CORE_STATE_STARTED && mState != RK_AIQ_CORE_STATE_RUNNING) {
411 LOGW_ANALYZER("in state %d\n", mState);
412 return XCAM_RETURN_NO_ERROR;
413 }
414
415 #ifndef RKAIQ_DISABLE_CORETHRD
416 mRkAiqCoreTh->triger_stop();
417 mRkAiqCoreTh->stop();
418 #endif
419
420 #if defined(ISP_HW_V20)
421 if (mHasPp) {
422 mRkAiqCorePpTh->triger_stop();
423 mRkAiqCorePpTh->stop();
424 }
425 #endif
426 #ifndef RKAIQ_DISABLE_CORETHRD
427 mRkAiqCoreEvtsTh->triger_stop();
428 mRkAiqCoreEvtsTh->stop();
429 #endif
430
431 mRkAiqCoreGroupManager->stop();
432 #if defined(RKAIQ_HAVE_THUMBNAILS)
433 if (mThumbnailsService.ptr()) {
434 mThumbnailsService->Stop();
435 }
436 #endif
437
438 {
439 SmartLock locker (ispStatsListMutex);
440 mAiqStatsCachedList.clear();
441 mAiqStatsOutMap.clear();
442 mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_INIT;
443 mState = RK_AIQ_CORE_STATE_STOPED;
444 firstStatsReceived = false;
445 mLastAnalyzedId = 0;
446 }
447 mIspStatsCond.broadcast ();
448 mSafeEnableAlgo = true;
449 {
450 SmartLock locker (_mFullParam_mutex);
451 mFullParamsPendingMap.clear();
452 mLatestParamsDoneId = 0;
453 mLatestEvtsId = 0;
454 mLatestStatsId = 0;
455 }
456 EXIT_ANALYZER_FUNCTION();
457
458 return XCAM_RETURN_NO_ERROR;
459 }
460
461 XCamReturn
prepare(const rk_aiq_exposure_sensor_descriptor * sensor_des,int mode)462 RkAiqCore::prepare(const rk_aiq_exposure_sensor_descriptor* sensor_des,
463 int mode)
464 {
465 ENTER_ANALYZER_FUNCTION();
466 XCamReturn ret = XCAM_RETURN_NO_ERROR;
467 // check state
468 if ((mState == RK_AIQ_CORE_STATE_STARTED) ||
469 (mState == RK_AIQ_CORE_STATE_INVALID) ||
470 (mState == RK_AIQ_CORE_STATE_RUNNING)) {
471 LOGW_ANALYZER("in state %d\n", mState);
472 return XCAM_RETURN_NO_ERROR;
473 }
474
475 bool res_changed = (mAlogsComSharedParams.snsDes.isp_acq_width != 0) &&
476 (sensor_des->isp_acq_width != mAlogsComSharedParams.snsDes.isp_acq_width ||
477 sensor_des->isp_acq_height != mAlogsComSharedParams.snsDes.isp_acq_height);
478 if (res_changed) {
479 mAlogsComSharedParams.conf_type |= RK_AIQ_ALGO_CONFTYPE_CHANGERES;
480 LOGD_ANALYZER("resolution changed !");
481 } else
482 mAlogsComSharedParams.conf_type &= ~RK_AIQ_ALGO_CONFTYPE_CHANGERES;
483
484 if ((mState == RK_AIQ_CORE_STATE_STOPED) ||
485 (mState == RK_AIQ_CORE_STATE_PREPARED)) {
486 mAlogsComSharedParams.conf_type |= RK_AIQ_ALGO_CONFTYPE_KEEPSTATUS;
487 LOGD_ANALYZER("prepare from stopped, should keep algo status !");
488 }
489
490 mAlogsComSharedParams.snsDes = *sensor_des;
491 mAlogsComSharedParams.working_mode = mode;
492 mAlogsComSharedParams.spWidth = mSpWidth;
493 mAlogsComSharedParams.spHeight = mSpHeight;
494 mAlogsComSharedParams.spAlignedWidth = mSpAlignedWidth;
495 mAlogsComSharedParams.spAlignedHeight = mSpAlignedHeight;
496 CalibDbV2_ColorAsGrey_t *colorAsGrey =
497 (CalibDbV2_ColorAsGrey_t*)CALIBDBV2_GET_MODULE_PTR((void*)(mAlogsComSharedParams.calibv2), colorAsGrey);
498 #if RKAIQ_HAVE_ASD_V10
499 CalibDbV2_Cpsl_t* calibv2_cpsl_db =
500 (CalibDbV2_Cpsl_t*)CALIBDBV2_GET_MODULE_PTR((void*)(mAlogsComSharedParams.calibv2), cpsl);
501 #else
502 CalibDbV2_Cpsl_t* calibv2_cpsl_db = NULL;
503 #endif
504 #if defined(RKAIQ_HAVE_THUMBNAILS)
505 CalibDbV2_Thumbnails_t* thumbnails_config_db =
506 (CalibDbV2_Thumbnails_t*)CALIBDBV2_GET_MODULE_PTR((void*)(mAlogsComSharedParams.calibv2), thumbnails);
507 if (thumbnails_config_db) {
508 CalibDbV2_Thumbnails_Param_t* thumbnails_config = &thumbnails_config_db->param;
509 if (thumbnails_config->thumbnail_configs_len > 0) {
510 mThumbnailsService = new ThumbnailsService();
511 if (mThumbnailsService.ptr()) {
512 auto ret = mThumbnailsService->Prepare(thumbnails_config);
513 if (ret == XCAM_RETURN_NO_ERROR) {
514 auto cb = std::bind(&RkAiqCore::onThumbnailsResult, this, std::placeholders::_1);
515 mThumbnailsService->SetResultCallback(cb);
516 } else {
517 mThumbnailsService.release();
518 }
519 }
520 }
521 }
522 #endif
523
524 mTranslator->setWorkingMode(mode);
525
526 #if defined(RKAIQ_HAVE_MULTIISP)
527
528 if (mHwInfo.is_multi_isp_mode) {
529 XCAM_ASSERT((sensor_des->isp_acq_width % 32 == 0));// &&
530 //(sensor_des->isp_acq_height % 16 == 0));
531 uint32_t extended_pixel = mHwInfo.multi_isp_extended_pixel;
532 RkAiqResourceTranslatorV3x* translator = static_cast<RkAiqResourceTranslatorV3x*>(mTranslator.ptr());
533 translator->SetMultiIspMode(true)
534 .SetPicInfo({0, 0, sensor_des->isp_acq_width, sensor_des->isp_acq_height})
535 .SetLeftIspRect(
536 {0, 0, sensor_des->isp_acq_width / 2 + extended_pixel, sensor_des->isp_acq_height})
537 .SetRightIspRect({sensor_des->isp_acq_width / 2 - extended_pixel, 0,
538 sensor_des->isp_acq_width / 2 + extended_pixel,
539 sensor_des->isp_acq_height});
540 RkAiqResourceTranslatorV3x::Rectangle f = translator->GetPicInfo();
541 RkAiqResourceTranslatorV3x::Rectangle l = translator->GetLeftIspRect();
542 RkAiqResourceTranslatorV3x::Rectangle r = translator->GetRightIspRect();
543 LOGD_ANALYZER(
544 "Set Multi-ISP mode Translator info :"
545 " F: { %u, %u, %u, %u }"
546 " L: { %u, %u, %u, %u }"
547 " R: { %u, %u, %u, %u }",
548 f.x, f.y, f.w, f.h, l.x, l.y, l.w, l.h, r.x, r.y, r.w, r.h);
549 mAlogsComSharedParams.is_multi_isp_mode = mHwInfo.is_multi_isp_mode;
550 mAlogsComSharedParams.multi_isp_extended_pixels = extended_pixel;
551 } else {
552 if (mIspHwVer == 3)
553 static_cast<RkAiqResourceTranslatorV3x*>(mTranslator.ptr())->SetMultiIspMode(false);
554 }
555 #endif
556
557 if ((mAlogsComSharedParams.snsDes.sensor_pixelformat == V4L2_PIX_FMT_GREY) ||
558 (mAlogsComSharedParams.snsDes.sensor_pixelformat == V4L2_PIX_FMT_Y10) ||
559 (mAlogsComSharedParams.snsDes.sensor_pixelformat == V4L2_PIX_FMT_Y12)) {
560 mAlogsComSharedParams.is_bw_sensor = true;
561 mGrayMode = RK_AIQ_GRAY_MODE_ON;
562 mAlogsComSharedParams.gray_mode = true;
563 } else {
564 mAlogsComSharedParams.is_bw_sensor = false;
565 if (colorAsGrey->param.enable) {
566 mAlogsComSharedParams.gray_mode = true;
567 mGrayMode = RK_AIQ_GRAY_MODE_ON;
568 } else if (calibv2_cpsl_db && calibv2_cpsl_db->param.enable) {
569 mGrayMode = RK_AIQ_GRAY_MODE_CPSL;
570 mAlogsComSharedParams.gray_mode =
571 mAlogsComSharedParams.fill_light_on && calibv2_cpsl_db->param.force_gray;
572 } else {
573 mGrayMode = RK_AIQ_GRAY_MODE_OFF;
574 mAlogsComSharedParams.gray_mode = false;
575 }
576 }
577
578 for (auto& algoHdl : mCurIspAlgoHandleList) {
579 RkAiqHandle* curHdl = algoHdl.ptr();
580 while (curHdl) {
581 if (curHdl->getEnable()) {
582 /* update user initial params */
583 ret = curHdl->updateConfig(true);
584 RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d update initial user params failed", curHdl->getAlgoType());
585 algoHdl->setReConfig(mState == RK_AIQ_CORE_STATE_STOPED);
586 ret = curHdl->prepare();
587 RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d prepare failed", curHdl->getAlgoType());
588 }
589 curHdl = curHdl->getNextHdl();
590 }
591 }
592
593
594 mAlogsComSharedParams.init = true;
595 // run algos without stats to generate
596 // initial params
597 CalibDb_Aec_ParaV2_t* calibv2_ae_calib =
598 (CalibDb_Aec_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)(mAlogsComSharedParams.calibv2), ae_calib));
599
600 auto mapIter = mAlogsGroupSharedParamsMap.begin();
601 while (mapIter != mAlogsGroupSharedParamsMap.end()) {
602 RkAiqAlgosGroupShared_t* &shared = mapIter->second;
603 if (!(mAlogsComSharedParams.conf_type & RK_AIQ_ALGO_CONFTYPE_CHANGERES)) {
604 shared->reset();
605 } else {
606 // do not reset all for case of resolution changed
607 shared->frameId = 0;
608 shared->sof = 0;
609 shared->ispStats = 0;
610 }
611 SmartPtr<RkAiqFullParams> curParams = mAiqCurParams->data();
612 if (curParams.ptr() && curParams->mExposureParams.ptr()) {
613 shared->curExp =
614 curParams->mExposureParams->data()->result.new_ae_exp;
615 }
616 mapIter++;
617 }
618
619 //TODO: this will lead no initial ae params
620 //analyzeInternal(RK_AIQ_CORE_ANALYZE_AE);
621 analyzeInternal(RK_AIQ_CORE_ANALYZE_ALL);
622 mFullParamsPendingMap.clear();
623 for (uint32_t i = 0; i < RK_AIQ_CORE_ANALYZE_MAX; i++)
624 freeSharebuf(i);
625 // syncVicapScaleMode();
626
627 mAlogsComSharedParams.init = false;
628
629 mState = RK_AIQ_CORE_STATE_PREPARED;
630
631 EXIT_ANALYZER_FUNCTION();
632
633 return XCAM_RETURN_NO_ERROR;
634 }
635
getDummyAlgoRes(int type,uint32_t frame_id)636 void RkAiqCore::getDummyAlgoRes(int type, uint32_t frame_id) {
637 if (type == RK_AIQ_ALGO_TYPE_AE) {
638 SmartPtr<VideoBuffer> bp = new RkAiqAlgoPreResAeIntShared;
639 bp->set_sequence(frame_id);
640 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_AE_PRE_RES_OK, frame_id, bp);
641 post_message(msg);
642
643 } else if (type == RK_AIQ_ALGO_TYPE_AWB) {
644 SmartPtr<VideoBuffer> bp = new RkAiqAlgoProcResAwbIntShared;
645 bp->set_sequence(frame_id);
646 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_AWB_PROC_RES_OK, frame_id, bp);
647 post_message(msg);
648 } else if (type == RK_AIQ_ALGO_TYPE_ABLC) {
649 #if ISP_HW_V32
650 SmartPtr<VideoBuffer> bp = new RkAiqAlgoProcResAblcV32IntShared;
651 #else
652 SmartPtr<VideoBuffer> bp = new RkAiqAlgoProcResAblcIntShared;
653 #endif
654 bp->set_sequence(frame_id);
655 #if ISP_HW_V32
656 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_BLC_V32_PROC_RES_OK, frame_id, bp);
657 #else
658 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_BLC_PROC_RES_OK, frame_id, bp);
659 #endif
660 post_message(msg);
661 } else if (type == RK_AIQ_ALGO_TYPE_AYNR) {
662 #if ISP_HW_V32
663 SmartPtr<VideoBuffer> bp = new RkAiqAlgoProcResAynrV22IntShared;
664 #else
665 SmartPtr<VideoBuffer> bp = new RkAiqAlgoProcResAynrV3IntShared;
666 #endif
667 bp->set_sequence(frame_id);
668 #if ISP_HW_V32
669 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_YNR_V22_PROC_RES_OK, frame_id, bp);
670 #else
671 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_YNR_V3_PROC_RES_OK, frame_id, bp);
672 #endif
673 post_message(msg);
674 }
675 }
676
677 SmartPtr<RkAiqFullParamsProxy>
analyzeInternal(enum rk_aiq_core_analyze_type_e grp_type)678 RkAiqCore::analyzeInternal(enum rk_aiq_core_analyze_type_e grp_type)
679 {
680 ENTER_ANALYZER_FUNCTION();
681
682 XCamReturn ret = XCAM_RETURN_NO_ERROR;
683
684 SmartPtr<RkAiqFullParamsProxy> aiqParamProxy = NULL;
685 RkAiqFullParams* aiqParams = NULL;
686 bool got_full_buf = false;
687
688 std::vector<SmartPtr<RkAiqHandle>>& algo_list = mRkAiqCoreGroupManager->getGroupAlgoList(grp_type);
689 SmartPtr<RkAiqFullParams> curParams = mAiqCurParams->data();
690 for (auto& algoHdl : algo_list) {
691 RkAiqHandle* curHdl = algoHdl.ptr();
692 bool got_buffer = false;
693 while (curHdl) {
694 if (curHdl->getEnable()) {
695 int type = curHdl->getAlgoType();
696 if (!got_buffer) {
697 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)(curHdl->getGroupShared());
698 uint32_t frame_id = -1;
699 if (shared) frame_id = shared->frameId;
700
701 if (!got_full_buf) {
702 SmartLock locker (_mFullParam_mutex);
703 if (mFullParamsPendingMap.count(frame_id)) {
704 aiqParamProxy = mFullParamsPendingMap[frame_id].proxy;
705 LOGD_ANALYZER("[%d] pending params, algo_type: 0x%x, grp_type: 0x%x, params_ptr: %p",
706 frame_id, type, grp_type, aiqParamProxy->data().ptr());
707
708 } else {
709 if (mAiqParamsPool->has_free_items())
710 aiqParamProxy = mAiqParamsPool->get_item();
711
712 if (!aiqParamProxy.ptr()) {
713 LOGE_ANALYZER("no free aiq params buffer!");
714 return NULL;
715 }
716
717 LOGD_ANALYZER("[%d] new params, algo_type: 0x%x, grp_type: 0x%x, params_ptr: %p",
718 frame_id, type, grp_type, aiqParamProxy->data().ptr());
719
720 mFullParamsPendingMap[frame_id].proxy = aiqParamProxy;
721 }
722
723 mFullParamsPendingMap[frame_id].groupMasks |= 1ULL << grp_type;
724 if (mFullParamsPendingMap[frame_id].groupMasks == mFullParamReqGroupsMasks)
725 mFullParamsPendingMap[frame_id].ready = true;
726 else
727 mFullParamsPendingMap[frame_id].ready = false;
728 aiqParams = aiqParamProxy->data().ptr();
729 got_full_buf = true;
730 }
731
732 ret = getAiqParamsBuffer(aiqParams, type, frame_id);
733 if (ret) break;
734 if (!mAlogsComSharedParams.init && isGroupAlgo(type)) {
735 getDummyAlgoRes(type, frame_id);
736 }
737 shared->fullParams = aiqParams;
738 got_buffer = true;
739 if (shared->frameId < mLatestParamsDoneId) {
740 LOGW_ANALYZER("[%u] < [%u], skip grp_type 0x%x process !",
741 shared->frameId, mLatestParamsDoneId, grp_type);
742 return NULL;
743 }
744 }
745 if (mAlogsComSharedParams.init || !isGroupAlgo(type)) {
746 ret = curHdl->updateConfig(true);
747 ret = curHdl->preProcess();
748 ret = curHdl->processing();
749 ret = algoHdl->postProcess();
750 curHdl->genIspResult(aiqParams, curParams.ptr());
751 if (ret) break;
752 }
753 }
754 curHdl = curHdl->getNextHdl();
755 }
756 }
757
758 EXIT_ANALYZER_FUNCTION();
759
760 return aiqParamProxy;
761 }
762
freeSharebuf(uint64_t grpId)763 XCamReturn RkAiqCore::freeSharebuf(uint64_t grpId) {
764 RkAiqAlgosGroupShared_t* shared = nullptr;
765 uint64_t grpMask = grpId2GrpMask(grpId);
766 if (!getGroupSharedParams(grpMask, shared)) {
767 if (shared) {
768 if (shared->afStatsBuf) {
769 shared->afStatsBuf = nullptr;
770 }
771 if (shared->ispStats) {
772 shared->ispStats->unref(shared->ispStats);
773 shared->ispStats = nullptr;
774 }
775 if (shared->tx) {
776 shared->tx->unref(shared->tx);
777 shared->tx = nullptr;
778 }
779 if (shared->sp) {
780 shared->sp->unref(shared->sp);
781 shared->sp = nullptr;
782 }
783 if (shared->ispGain) {
784 shared->ispGain->unref(shared->ispGain);
785 shared->ispGain = nullptr;
786 }
787 if (shared->kgGain) {
788 shared->kgGain->unref(shared->kgGain);
789 shared->kgGain = nullptr;
790 }
791 if (shared->wrGain) {
792 shared->wrGain->unref(shared->wrGain);
793 shared->wrGain = nullptr;
794 }
795 if (shared->orbStats) {
796 shared->orbStats->unref(shared->orbStats);
797 shared->orbStats = nullptr;
798 }
799 if (shared->nrImg) {
800 shared->nrImg->unref(shared->nrImg);
801 shared->nrImg = nullptr;
802 }
803 if (shared->pdafStatsBuf) {
804 shared->pdafStatsBuf = nullptr;
805 }
806 if (shared->res_comb.ae_pre_res) {
807 shared->res_comb.ae_pre_res->unref(shared->res_comb.ae_pre_res);
808 shared->res_comb.ae_pre_res = nullptr;
809 }
810 if (shared->res_comb.ae_proc_res) {
811 shared->res_comb.ae_proc_res->unref(shared->res_comb.ae_proc_res);
812 shared->res_comb.ae_proc_res = nullptr;
813 }
814 if (shared->res_comb.awb_proc_res) {
815 shared->res_comb.awb_proc_res->unref(shared->res_comb.awb_proc_res);
816 shared->res_comb.awb_proc_res = nullptr;
817 }
818
819 return XCAM_RETURN_NO_ERROR;
820 }
821 }
822 return XCAM_RETURN_NO_ERROR;
823 }
824
825 XCamReturn
getAiqParamsBuffer(RkAiqFullParams * aiqParams,int type,uint32_t frame_id)826 RkAiqCore::getAiqParamsBuffer(RkAiqFullParams* aiqParams, int type, uint32_t frame_id)
827 {
828 #define NEW_PARAMS_BUFFER(lc, BC) \
829 if (!aiqParams->m##lc##Params.ptr()) { \
830 if (mAiqIsp##lc##ParamsPool->has_free_items()) { \
831 aiqParams->m##lc##Params = mAiqIsp##lc##ParamsPool->get_item(); \
832 aiqParams->m##lc##Params->data()->frame_id = frame_id; \
833 aiqParams->m##lc##Params->data()->is_update = false; \
834 } else { \
835 LOGE_ANALYZER("no free %s buffer for Id: %d !", #BC, frame_id); \
836 return XCAM_RETURN_ERROR_MEM; \
837 } \
838 } else { \
839 aiqParams->m##lc##Params->data()->frame_id = frame_id; \
840 aiqParams->m##lc##Params->data()->is_update = false; \
841 }
842
843 #define NEW_PARAMS_BUFFER_WITH_V(lc, BC, v) \
844 if (!aiqParams->m##lc##V##v##Params.ptr()) { \
845 if (mAiqIsp##lc##V##v##ParamsPool->has_free_items()) { \
846 aiqParams->m##lc##V##v##Params = mAiqIsp##lc##V##v##ParamsPool->get_item(); \
847 aiqParams->m##lc##V##v##Params->data()->frame_id = frame_id; \
848 aiqParams->m##lc##V##v##Params->data()->is_update = false; \
849 } else { \
850 LOGE_ANALYZER("no free %s buffer for Id: %d !", #BC, frame_id); \
851 return XCAM_RETURN_ERROR_MEM; \
852 } \
853 } else { \
854 aiqParams->m##lc##V##v##Params->data()->frame_id = frame_id; \
855 aiqParams->m##lc##V##v##Params->data()->is_update = false; \
856 }
857
858 switch (type) {
859 case RK_AIQ_ALGO_TYPE_AE:
860 if (!aiqParams->mExposureParams.ptr()) {
861 if (mAiqExpParamsPool->has_free_items()) {
862 aiqParams->mExposureParams = mAiqExpParamsPool->get_item();
863 aiqParams->mExposureParams->data()->frame_id = frame_id;
864 } else {
865 LOGE_ANALYZER("no free exposure params buffer for id: %d !",frame_id);
866 return XCAM_RETURN_ERROR_MEM;
867 }
868 } else {
869 aiqParams->mExposureParams->data()->frame_id = frame_id;
870 }
871
872 if (!aiqParams->mIrisParams.ptr()) {
873 if (mAiqIrisParamsPool->has_free_items()) {
874 aiqParams->mIrisParams = mAiqIrisParamsPool->get_item();
875 } else {
876 LOGE_ANALYZER("no free iris params buffer!");
877 return XCAM_RETURN_ERROR_MEM;
878 }
879 }
880
881 NEW_PARAMS_BUFFER(Aec, aec);
882 NEW_PARAMS_BUFFER(Hist, hist);
883 break;
884 case RK_AIQ_ALGO_TYPE_AWB:
885 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
886 NEW_PARAMS_BUFFER_WITH_V(Awb, awb, 32);
887 #elif defined(ISP_HW_V30)
888 NEW_PARAMS_BUFFER_WITH_V(Awb, awb, 3x);
889 #elif defined(ISP_HW_V21)
890 NEW_PARAMS_BUFFER_WITH_V(Awb, awb, 21);
891 #else
892 NEW_PARAMS_BUFFER(Awb, awb);
893 #endif
894 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
895 NEW_PARAMS_BUFFER_WITH_V(AwbGain, awb_gain, 32);
896 #else
897 NEW_PARAMS_BUFFER(AwbGain, awb_gain);
898 #endif
899 break;
900 case RK_AIQ_ALGO_TYPE_AF:
901 if (!aiqParams->mFocusParams.ptr()) {
902 if (mAiqFocusParamsPool->has_free_items()) {
903 aiqParams->mFocusParams = mAiqFocusParamsPool->get_item();
904 } else {
905 LOGE_ANALYZER("no free focus params buffer for id : %d !", frame_id);
906 return XCAM_RETURN_ERROR_MEM;
907 }
908 }
909 #if defined(ISP_HW_V32_LITE)
910 NEW_PARAMS_BUFFER_WITH_V(Af, af, 32Lite);
911 #elif defined(ISP_HW_V32)
912 NEW_PARAMS_BUFFER_WITH_V(Af, af, 32);
913 #elif defined(ISP_HW_V30)
914 NEW_PARAMS_BUFFER_WITH_V(Af, af, 3x);
915 #else
916 NEW_PARAMS_BUFFER(Af, af);
917 #endif
918 break;
919 case RK_AIQ_ALGO_TYPE_ABLC:
920 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
921 NEW_PARAMS_BUFFER_WITH_V(Blc, blc, 32);
922 #elif defined(ISP_HW_V30) || defined(ISP_HW_V21)
923 NEW_PARAMS_BUFFER_WITH_V(Blc, blc, 21);
924 #else
925 NEW_PARAMS_BUFFER(Blc, blc);
926 #endif
927 break;
928 case RK_AIQ_ALGO_TYPE_ADPCC:
929 NEW_PARAMS_BUFFER(Dpcc, dpcc);
930 break;
931 #if 0
932 case RK_AIQ_ALGO_TYPE_AHDR:
933 NEW_PARAMS_BUFFER(Hdr, hdr);
934 break;
935 #else
936 case RK_AIQ_ALGO_TYPE_AMERGE:
937 NEW_PARAMS_BUFFER(Merge, merge);
938 break;
939 #if RKAIQ_HAVE_TMO_V1
940 case RK_AIQ_ALGO_TYPE_ATMO:
941 NEW_PARAMS_BUFFER(Tmo, tmo);
942 break;
943 #endif
944 #endif
945 case RK_AIQ_ALGO_TYPE_ALSC:
946 NEW_PARAMS_BUFFER(Lsc, lsc);
947 break;
948 case RK_AIQ_ALGO_TYPE_AGIC:
949 NEW_PARAMS_BUFFER(Gic, gic);
950 break;
951 case RK_AIQ_ALGO_TYPE_ADEBAYER:
952 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
953 NEW_PARAMS_BUFFER_WITH_V(Debayer, debayer, 32);
954 #else
955 NEW_PARAMS_BUFFER(Debayer, debayer);
956 #endif
957 break;
958 case RK_AIQ_ALGO_TYPE_ACCM:
959 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
960 NEW_PARAMS_BUFFER_WITH_V(Ccm, ccm, 32);
961 #else
962 NEW_PARAMS_BUFFER(Ccm, ccm);
963 #endif
964 break;
965 case RK_AIQ_ALGO_TYPE_AGAMMA:
966 NEW_PARAMS_BUFFER(Agamma, agamma);
967 break;
968 case RK_AIQ_ALGO_TYPE_AWDR:
969 NEW_PARAMS_BUFFER(Wdr, wdr);
970 break;
971 case RK_AIQ_ALGO_TYPE_ADHAZ:
972 NEW_PARAMS_BUFFER(Dehaze, dehaze);
973 break;
974 case RK_AIQ_ALGO_TYPE_A3DLUT:
975 NEW_PARAMS_BUFFER(Lut3d, lut3d);
976 break;
977 case RK_AIQ_ALGO_TYPE_ALDCH:
978 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
979 NEW_PARAMS_BUFFER_WITH_V(Ldch, ldch, 32);
980 #else
981 NEW_PARAMS_BUFFER(Ldch, ldch);
982 #endif
983 break;
984 case RK_AIQ_ALGO_TYPE_ACSM:
985 NEW_PARAMS_BUFFER(Csm, csm);
986 break;
987 case RK_AIQ_ALGO_TYPE_ACP:
988 NEW_PARAMS_BUFFER(Cp, cp);
989 break;
990 case RK_AIQ_ALGO_TYPE_AIE:
991 NEW_PARAMS_BUFFER(Ie, ie);
992 break;
993 case RK_AIQ_ALGO_TYPE_ACGC:
994 NEW_PARAMS_BUFFER(Cgc, cgc);
995 break;
996 case RK_AIQ_ALGO_TYPE_ASD:
997 break;
998 case RK_AIQ_ALGO_TYPE_ADRC:
999 NEW_PARAMS_BUFFER(Drc, drc);
1000 break;
1001 case RK_AIQ_ALGO_TYPE_ADEGAMMA:
1002 NEW_PARAMS_BUFFER(Adegamma, adegamma);
1003 break;
1004 case RK_AIQ_ALGO_TYPE_ARAWNR:
1005 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1006 NEW_PARAMS_BUFFER_WITH_V(Baynr, baynr, 32);
1007 #elif defined(ISP_HW_V30)
1008 NEW_PARAMS_BUFFER_WITH_V(Baynr, baynr, 3x);
1009 #elif defined(ISP_HW_V21)
1010 NEW_PARAMS_BUFFER_WITH_V(Baynr, baynr, 21);
1011 #else
1012 NEW_PARAMS_BUFFER(Rawnr, rawnr);
1013 #endif
1014 break;
1015 case RK_AIQ_ALGO_TYPE_AMFNR:
1016 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1017 NEW_PARAMS_BUFFER_WITH_V(Tnr, tnr, 32);
1018 #elif defined(ISP_HW_V30)
1019 NEW_PARAMS_BUFFER_WITH_V(Tnr, tnr, 3x);
1020 #else
1021 NEW_PARAMS_BUFFER(Tnr, tnr);
1022 #endif
1023 break;
1024 case RK_AIQ_ALGO_TYPE_AYNR:
1025 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1026 NEW_PARAMS_BUFFER_WITH_V(Ynr, ynr, 32);
1027 #elif defined(ISP_HW_V30)
1028 NEW_PARAMS_BUFFER_WITH_V(Ynr, ynr, 3x);
1029 #elif defined(ISP_HW_V21)
1030 NEW_PARAMS_BUFFER_WITH_V(Ynr, ynr, 21);
1031 #else
1032 NEW_PARAMS_BUFFER(Ynr, ynr);
1033 #endif
1034 break;
1035 case RK_AIQ_ALGO_TYPE_ACNR:
1036 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1037 NEW_PARAMS_BUFFER_WITH_V(Cnr, cnr, 32);
1038 #elif defined(ISP_HW_V30)
1039 NEW_PARAMS_BUFFER_WITH_V(Cnr, cnr, 3x);
1040 #elif defined(ISP_HW_V21)
1041 NEW_PARAMS_BUFFER_WITH_V(Cnr, cnr, 21);
1042 #else
1043 NEW_PARAMS_BUFFER(Uvnr, uvnr);
1044 #endif
1045 break;
1046 case RK_AIQ_ALGO_TYPE_ASHARP:
1047 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1048 NEW_PARAMS_BUFFER_WITH_V(Sharp, sharp, 32);
1049 #elif defined(ISP_HW_V30)
1050 NEW_PARAMS_BUFFER_WITH_V(Sharpen, sharpen, 3x);
1051 #elif defined(ISP_HW_V21)
1052 NEW_PARAMS_BUFFER_WITH_V(Sharpen, sharpen, 21);
1053 #else
1054 NEW_PARAMS_BUFFER(Sharpen, sharpen);
1055 NEW_PARAMS_BUFFER(Edgeflt, edgeflt);
1056 #endif
1057 break;
1058 #if RKAIQ_HAVE_ORB_V1
1059 case RK_AIQ_ALGO_TYPE_AORB:
1060 NEW_PARAMS_BUFFER(Orb, orb);
1061 break;
1062 #endif
1063 case RK_AIQ_ALGO_TYPE_AFEC:
1064 case RK_AIQ_ALGO_TYPE_AEIS:
1065 NEW_PARAMS_BUFFER(Fec, fec);
1066 break;
1067 #if defined(ISP_HW_V20)
1068 case RK_AIQ_ALGO_TYPE_ANR:
1069 NEW_PARAMS_BUFFER(Rawnr, rawnr);
1070 NEW_PARAMS_BUFFER(Tnr, tnr);
1071 NEW_PARAMS_BUFFER(Ynr, ynr);
1072 NEW_PARAMS_BUFFER(Uvnr, uvnr);
1073 NEW_PARAMS_BUFFER(Gain, gain);
1074 NEW_PARAMS_BUFFER(Motion, motion);
1075 break;
1076 #endif
1077 #if RKAIQ_HAVE_AMD_V1
1078 case RK_AIQ_ALGO_TYPE_AMD:
1079 NEW_PARAMS_BUFFER(Md, md);
1080 break;
1081 #endif
1082 case RK_AIQ_ALGO_TYPE_AGAIN:
1083 #if defined(ISP_HW_V30) || defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1084 NEW_PARAMS_BUFFER_WITH_V(Gain, Gain, 3x);
1085 #endif
1086 break;
1087 case RK_AIQ_ALGO_TYPE_ACAC:
1088 #if RKAIQ_HAVE_CAC_V11
1089 NEW_PARAMS_BUFFER_WITH_V(Cac, cac, 32);
1090 #elif RKAIQ_HAVE_CAC_V10 || RKAIQ_HAVE_CAC_V03
1091 NEW_PARAMS_BUFFER_WITH_V(Cac, cac, 3x);
1092 #endif
1093 break;
1094 case RK_AIQ_ALGO_TYPE_AFD:
1095 #if RKAIQ_HAVE_AFD_V1 || RKAIQ_HAVE_AFD_V2
1096 NEW_PARAMS_BUFFER(Afd, afd);
1097 #endif
1098 break;
1099 default:
1100 break;
1101 }
1102
1103 return XCAM_RETURN_NO_ERROR;
1104 }
1105
1106 XCamReturn
pushStats(SmartPtr<VideoBuffer> & buffer)1107 RkAiqCore::pushStats(SmartPtr<VideoBuffer> &buffer)
1108 {
1109 ENTER_ANALYZER_FUNCTION();
1110
1111 XCAM_ASSERT(buffer.ptr());
1112 mLatestStatsId = buffer->get_sequence();
1113 int32_t delta = mLatestStatsId - mLatestEvtsId;
1114 if (delta > 3) {
1115 LOGW_ANALYZER("stats delta: %d, skip stats %u", delta, mLatestStatsId);
1116 return XCAM_RETURN_NO_ERROR;
1117 }
1118
1119 #ifndef RKAIQ_DISABLE_CORETHRD
1120 mRkAiqCoreTh->push_stats(buffer);
1121 #else
1122 auto ret = analyze (buffer);
1123 #endif
1124 EXIT_ANALYZER_FUNCTION();
1125
1126 return XCAM_RETURN_NO_ERROR;
1127 }
1128
1129 XCamReturn
pushEvts(SmartPtr<ispHwEvt_t> & evts)1130 RkAiqCore::pushEvts(SmartPtr<ispHwEvt_t> &evts)
1131 {
1132 ENTER_ANALYZER_FUNCTION();
1133
1134 XCAM_ASSERT(evts.ptr());
1135
1136 if (evts->evt_code == V4L2_EVENT_FRAME_SYNC) {
1137 Isp20Evt* isp20Evts =
1138 evts.get_cast_ptr<Isp20Evt>();
1139 mLatestEvtsId = isp20Evts->sequence;
1140 int32_t delta = mLatestEvtsId - mLatestStatsId;
1141 if (delta > 3) {
1142 LOGW_ANALYZER("sof delta: %d, skip sof %u", delta, mLatestEvtsId);
1143 return XCAM_RETURN_NO_ERROR;
1144 }
1145 #ifndef RKAIQ_DISABLE_CORETHRD
1146 mRkAiqCoreEvtsTh->push_evts(evts);
1147 #else
1148 XCamReturn ret = events_analyze (evts);
1149 #endif
1150 }
1151 EXIT_ANALYZER_FUNCTION();
1152
1153 return XCAM_RETURN_NO_ERROR;
1154 }
1155
1156 RkAiqHandle*
getAiqAlgoHandle(const int algo_type)1157 RkAiqCore::getAiqAlgoHandle(const int algo_type)
1158 {
1159 // get defalut algo handle(id == 0)
1160 SmartPtr<RkAiqHandle>* handlePtr = getCurAlgoTypeHandle(algo_type);
1161 if (handlePtr == nullptr) {
1162 return NULL;
1163 }
1164
1165 return (*handlePtr).ptr();
1166 }
1167
1168 SmartPtr<RkAiqHandle>*
getCurAlgoTypeHandle(int algo_type)1169 RkAiqCore::getCurAlgoTypeHandle(int algo_type)
1170 {
1171 // get defalut algo handle(id == 0)
1172 if (mCurAlgoHandleMaps.find(algo_type) != mCurAlgoHandleMaps.end())
1173 return &mCurAlgoHandleMaps.at(algo_type);
1174
1175 LOGE("can't find algo handle %d", algo_type);
1176 return NULL;
1177 }
1178
1179 std::map<int, SmartPtr<RkAiqHandle>>*
getAlgoTypeHandleMap(int algo_type)1180 RkAiqCore::getAlgoTypeHandleMap(int algo_type)
1181 {
1182 if (mAlgoHandleMaps.find(algo_type) != mAlgoHandleMaps.end())
1183 return &mAlgoHandleMaps.at(algo_type);
1184
1185 LOGE("can't find algo map %d", algo_type);
1186 return NULL;
1187 }
1188
1189 // add rk default handlers(id == 0), can't be removed
1190 void
addDefaultAlgos(const struct RkAiqAlgoDesCommExt * algoDes)1191 RkAiqCore::addDefaultAlgos(const struct RkAiqAlgoDesCommExt* algoDes)
1192 {
1193 map<int, SmartPtr<RkAiqHandle>> algoMap;
1194 for (int i = 0; i < RK_AIQ_ALGO_TYPE_MAX; i++) {
1195 #ifdef RKAIQ_ENABLE_PARSER_V1
1196 mAlogsComSharedParams.ctxCfigs[i].calib =
1197 const_cast<CamCalibDbContext_t*>(mAlogsComSharedParams.calib);
1198 #endif
1199 mAlogsComSharedParams.ctxCfigs[i].calibv2 =
1200 const_cast<CamCalibDbV2Context_t*>(mAlogsComSharedParams.calibv2);
1201 mAlogsComSharedParams.ctxCfigs[i].isp_hw_version = mIspHwVer;
1202 }
1203
1204 std::vector<uint32_t> group_list;
1205 for (size_t i = 0; algoDes[i].des != NULL; i++) {
1206 int algo_type = algoDes[i].des->type;
1207 // enable only the specified algorithm modules
1208 if ((1ULL << algo_type) & mInitDisAlgosMask)
1209 continue;
1210 int64_t grpMask = 1ULL << algoDes[i].group;
1211 #ifdef RKAIQ_ENABLE_PARSER_V1
1212 mAlogsComSharedParams.ctxCfigs[algo_type].calib =
1213 const_cast<CamCalibDbContext_t*>(mAlogsComSharedParams.calib);
1214 #endif
1215 mAlogsComSharedParams.ctxCfigs[algo_type].calibv2 =
1216 const_cast<CamCalibDbV2Context_t*>(mAlogsComSharedParams.calibv2);
1217 mAlogsComSharedParams.ctxCfigs[algo_type].module_hw_version = algoDes[i].module_hw_ver;
1218 mAlgoTypeToGrpMaskMap[algo_type] = grpMask;
1219 bool isExist = false;
1220 for(auto it = group_list.begin(); it != group_list.end(); it++) {
1221 if (*it == algoDes[i].group)
1222 isExist = true;
1223 }
1224 if (!isExist) {
1225 group_list.push_back(algoDes[i].group);
1226 auto groupId = algoDes[i].group;
1227 mAlogsGroupSharedParamsMap[grpMask] = new RkAiqAlgosGroupShared_t;
1228 mAlogsGroupSharedParamsMap[grpMask]->reset();
1229 mAlogsGroupSharedParamsMap[grpMask]->groupId = algoDes[i].group;
1230 mAlogsGroupSharedParamsMap[grpMask]->frameId = 0;
1231 mAlogsGroupSharedParamsMap[grpMask]->ispStats = NULL;
1232
1233 }
1234 algoMap[0] = newAlgoHandle(algoDes[i].des, algoDes[i].algo_ver, algoDes[i].handle_ver);
1235 if (!algoMap[0].ptr()) {
1236 LOGE_ANALYZER("new algo_type %d handle failed", algo_type);
1237 continue;
1238 }
1239 algoMap[0]->setGroupId(grpMask);
1240 algoMap[0]->setGroupShared(mAlogsGroupSharedParamsMap[grpMask]);
1241 mAlgoHandleMaps[algo_type] = algoMap;
1242 mCurIspAlgoHandleList.push_back(algoMap[0]);
1243 mCurAlgoHandleMaps[algo_type] = algoMap[0];
1244 enableAlgo(algo_type, 0, true);
1245 algoMap.clear();
1246 }
1247 }
1248
1249 SmartPtr<RkAiqHandle>
newAlgoHandle(RkAiqAlgoDesComm * algo,int hw_ver,int handle_ver)1250 RkAiqCore::newAlgoHandle(RkAiqAlgoDesComm* algo, int hw_ver, int handle_ver)
1251 {
1252 std::string className = "RkAiq";
1253 className.append(AlgoTypeToString(algo->type));
1254 if (handle_ver)
1255 className.append("V" + std::to_string(handle_ver));
1256 className.append("HandleInt");
1257 LOGD_ANALYZER("Creating algorithm: %s, version: %d", className.c_str(), hw_ver);
1258 return SmartPtr<RkAiqHandle>(RkAiqHandleFactory::createInstance(className, algo, this));
1259 }
1260
1261 // register custom algos
1262 XCamReturn
addAlgo(RkAiqAlgoDesComm & algo)1263 RkAiqCore::addAlgo(RkAiqAlgoDesComm& algo)
1264 {
1265 ENTER_ANALYZER_FUNCTION();
1266
1267 std::map<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algo.type);
1268
1269 if (!algo_map) {
1270 LOGE_ANALYZER("do not support this algo type %d !", algo.type);
1271 return XCAM_RETURN_ERROR_FAILED;
1272 }
1273 // TODO, check if exist befor insert ?
1274 std::map<int, SmartPtr<RkAiqHandle>>::reverse_iterator rit = algo_map->rbegin();
1275
1276 algo.id = rit->first + 1;
1277
1278 int i = 0;
1279 const struct RkAiqAlgoDesCommExt* def_des = NULL;
1280 while (mAlgosDesArray[i].des != NULL) {
1281 if (mAlgosDesArray[i].des->type == algo.type) {
1282 def_des = &mAlgosDesArray[i];
1283 break;
1284 }
1285 i++;
1286 }
1287
1288 SmartPtr<RkAiqHandle> new_hdl;
1289 if (algo.type == RK_AIQ_ALGO_TYPE_AE)
1290 new_hdl = new RkAiqCustomAeHandle(&algo, this);
1291 #if RKAIQ_HAVE_AWB_V21 ||RKAIQ_HAVE_AWB_V32
1292 else if (algo.type == RK_AIQ_ALGO_TYPE_AWB)
1293 new_hdl = new RkAiqCustomAwbHandle(&algo, this);
1294 #endif
1295 else {
1296 LOGE_ANALYZER("not supported custom algo type: %d ", algo.type);
1297 return XCAM_RETURN_ERROR_FAILED;
1298 }
1299 new_hdl->setEnable(false);
1300 new_hdl->setGroupId((*algo_map)[0]->getGroupId());
1301 new_hdl->setGroupShared((*algo_map)[0]->getGroupShared());
1302 rit->second->setNextHdl(new_hdl.ptr());
1303 new_hdl->setParentHdl((*algo_map)[0].ptr());
1304
1305 (*algo_map)[algo.id] = new_hdl;
1306
1307 EXIT_ANALYZER_FUNCTION();
1308
1309 return XCAM_RETURN_NO_ERROR;
1310 }
1311
getReqAlgoResMask(int algoType)1312 std::bitset<RK_AIQ_ALGO_TYPE_MAX> RkAiqCore::getReqAlgoResMask(int algoType) {
1313 std::bitset<RK_AIQ_ALGO_TYPE_MAX> tmp{};
1314 switch (algoType) {
1315 case RK_AIQ_ALGO_TYPE_AE:
1316 tmp[RESULT_TYPE_EXPOSURE_PARAM] = 1;
1317 tmp[RESULT_TYPE_AEC_PARAM] = 1;
1318 tmp[RESULT_TYPE_HIST_PARAM] = 1;
1319 break;
1320 case RK_AIQ_ALGO_TYPE_AWB:
1321 tmp[RESULT_TYPE_AWB_PARAM] = 1;
1322 tmp[RESULT_TYPE_AWBGAIN_PARAM] = 1;
1323 break;
1324 case RK_AIQ_ALGO_TYPE_AF:
1325 tmp[RESULT_TYPE_AF_PARAM] = 1;
1326 //tmp[RESULT_TYPE_FOCUS_PARAM] = 1;
1327 break;
1328 case RK_AIQ_ALGO_TYPE_ADPCC:
1329 tmp[RESULT_TYPE_DPCC_PARAM] = 1;
1330 break;
1331 case RK_AIQ_ALGO_TYPE_AMERGE:
1332 tmp[RESULT_TYPE_MERGE_PARAM] = 1;
1333 break;
1334 case RK_AIQ_ALGO_TYPE_ATMO:
1335 tmp[RESULT_TYPE_TMO_PARAM] = 1;
1336 break;
1337 case RK_AIQ_ALGO_TYPE_ACCM:
1338 tmp[RESULT_TYPE_CCM_PARAM] = 1;
1339 break;
1340 case RK_AIQ_ALGO_TYPE_ALSC:
1341 tmp[RESULT_TYPE_LSC_PARAM] = 1;
1342 break;
1343 case RK_AIQ_ALGO_TYPE_ABLC:
1344 tmp[RESULT_TYPE_BLC_PARAM] = 1;
1345 break;
1346 case RK_AIQ_ALGO_TYPE_ARAWNR:
1347 tmp[RESULT_TYPE_RAWNR_PARAM] = 1;
1348 break;
1349 case RK_AIQ_ALGO_TYPE_AGIC:
1350 tmp[RESULT_TYPE_GIC_PARAM] = 1;
1351 break;
1352 case RK_AIQ_ALGO_TYPE_ADEBAYER:
1353 tmp[RESULT_TYPE_DEBAYER_PARAM] = 1;
1354 break;
1355 case RK_AIQ_ALGO_TYPE_ALDCH:
1356 tmp[RESULT_TYPE_LDCH_PARAM] = 1;
1357 break;
1358 case RK_AIQ_ALGO_TYPE_A3DLUT:
1359 tmp[RESULT_TYPE_LUT3D_PARAM] = 1;
1360 break;
1361 case RK_AIQ_ALGO_TYPE_ADHAZ:
1362 tmp[RESULT_TYPE_DEHAZE_PARAM] = 1;
1363 break;
1364 case RK_AIQ_ALGO_TYPE_AGAMMA:
1365 tmp[RESULT_TYPE_AGAMMA_PARAM] = 1;
1366 break;
1367 case RK_AIQ_ALGO_TYPE_ADEGAMMA:
1368 tmp[RESULT_TYPE_ADEGAMMA_PARAM] = 1;
1369 break;
1370 case RK_AIQ_ALGO_TYPE_AWDR:
1371 tmp[RESULT_TYPE_WDR_PARAM] = 1;
1372 break;
1373 case RK_AIQ_ALGO_TYPE_AGAIN:
1374 tmp[RESULT_TYPE_GAIN_PARAM] = 1;
1375 break;
1376 case RK_AIQ_ALGO_TYPE_ACP:
1377 tmp[RESULT_TYPE_CP_PARAM] = 1;
1378 break;
1379 case RK_AIQ_ALGO_TYPE_ACSM:
1380 tmp[RESULT_TYPE_CSM_PARAM] = 1;
1381 break;
1382 case RK_AIQ_ALGO_TYPE_AIE:
1383 tmp[RESULT_TYPE_IE_PARAM] = 1;
1384 break;
1385 case RK_AIQ_ALGO_TYPE_AMD:
1386 tmp[RESULT_TYPE_MOTION_PARAM] = 1;
1387 break;
1388 case RK_AIQ_ALGO_TYPE_AMFNR:
1389 tmp[RESULT_TYPE_TNR_PARAM] = 1;
1390 break;
1391 case RK_AIQ_ALGO_TYPE_AYNR:
1392 tmp[RESULT_TYPE_YNR_PARAM] = 1;
1393 break;
1394 case RK_AIQ_ALGO_TYPE_ACNR:
1395 tmp[RESULT_TYPE_UVNR_PARAM] = 1;
1396 break;
1397 case RK_AIQ_ALGO_TYPE_ASHARP:
1398 tmp[RESULT_TYPE_SHARPEN_PARAM] = 1;
1399 break;
1400 case RK_AIQ_ALGO_TYPE_AFEC:
1401 case RK_AIQ_ALGO_TYPE_AEIS:
1402 tmp[RESULT_TYPE_FEC_PARAM] = 1;
1403 break;
1404 case RK_AIQ_ALGO_TYPE_ADRC:
1405 tmp[RESULT_TYPE_DRC_PARAM] = 1;
1406 break;
1407 case RK_AIQ_ALGO_TYPE_ACAC:
1408 tmp[RESULT_TYPE_CAC_PARAM] = 1;
1409 break;
1410 case RK_AIQ_ALGO_TYPE_ACGC:
1411 tmp[RESULT_TYPE_CGC_PARAM] = 1;
1412 break;
1413 case RK_AIQ_ALGO_TYPE_ASD:
1414 tmp[RESULT_TYPE_CPSL_PARAM] = 1;
1415 break;
1416 default:
1417 break;
1418 }
1419
1420 return tmp;
1421 }
1422
setReqAlgoResMask(int algoType,bool req)1423 void RkAiqCore::setReqAlgoResMask(int algoType, bool req) {
1424 auto tmp = getReqAlgoResMask(algoType);
1425 if (req) {
1426 mAllReqAlgoResMask |= tmp;
1427 } else {
1428 mAllReqAlgoResMask &= ~tmp;
1429 }
1430
1431 LOGI_ANALYZER("mAllReqAlgoResMask : %llx", mAllReqAlgoResMask);
1432 }
1433
1434 XCamReturn
enableAlgo(int algoType,int id,bool enable)1435 RkAiqCore::enableAlgo(int algoType, int id, bool enable)
1436 {
1437 ENTER_ANALYZER_FUNCTION();
1438 // get default algotype handle, id should be 0
1439 SmartPtr<RkAiqHandle>* cur_algo_hdl = getCurAlgoTypeHandle(algoType);
1440 if (!cur_algo_hdl) {
1441 LOGE_ANALYZER("can't find current type %d algo", algoType);
1442 return XCAM_RETURN_ERROR_FAILED;
1443 }
1444 std::map<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algoType);
1445 NULL_RETURN_RET(algo_map, XCAM_RETURN_ERROR_FAILED);
1446 std::map<int, SmartPtr<RkAiqHandle>>::iterator it = algo_map->find(id);
1447 bool switch_algo = false;
1448
1449 if (it == algo_map->end()) {
1450 LOGE_ANALYZER("can't find type id <%d, %d> algo", algoType, id);
1451 return XCAM_RETURN_ERROR_FAILED;
1452 }
1453
1454 SmartLock locker (mApiMutex);
1455 while (mSafeEnableAlgo != true)
1456 mApiMutexCond.wait(mApiMutex);
1457
1458 LOGI_ANALYZER("set algo type_id <%d,%d> to %d", algoType, id, enable);
1459
1460 it->second->setEnable(enable);
1461 /* WARNING:
1462 * Be careful when use SmartPtr<RkAiqxxxHandle> = SmartPtr<RkAiqHandle>
1463 * if RkAiqxxxHandle is derived from multiple RkAiqHandle,
1464 * the ptr of RkAiqxxxHandle and RkAiqHandle IS NOT the same
1465 * (RkAiqHandle ptr = RkAiqxxxHandle ptr + offset), but seams like
1466 * SmartPtr do not deal with this correctly.
1467 */
1468
1469 if (enable) {
1470 if (mState >= RK_AIQ_CORE_STATE_PREPARED)
1471 it->second->prepare();
1472 }
1473
1474 int enable_cnt = 0;
1475 RkAiqHandle* curHdl = (*cur_algo_hdl).ptr();
1476
1477 while (curHdl) {
1478 if (curHdl->getEnable()) {
1479 enable_cnt++;
1480 }
1481 curHdl = curHdl->getNextHdl();
1482 }
1483
1484 setReqAlgoResMask(algoType, enable_cnt > 0 ? true : false);
1485
1486 curHdl = (*cur_algo_hdl).ptr();
1487
1488 while (curHdl) {
1489 curHdl->setMulRun(enable_cnt > 1 ? true : false);
1490 curHdl = curHdl->getNextHdl();
1491 }
1492
1493 LOGI_ANALYZER("algo type %d enabled count :%d", algoType, enable_cnt);
1494
1495 EXIT_ANALYZER_FUNCTION();
1496
1497 return XCAM_RETURN_NO_ERROR;
1498 }
1499
1500 XCamReturn
rmAlgo(int algoType,int id)1501 RkAiqCore::rmAlgo(int algoType, int id)
1502 {
1503 ENTER_ANALYZER_FUNCTION();
1504
1505 // can't remove default algos
1506 if (id == 0)
1507 return XCAM_RETURN_NO_ERROR;
1508
1509 SmartPtr<RkAiqHandle>* cur_algo_hdl = getCurAlgoTypeHandle(algoType);
1510 if (!cur_algo_hdl) {
1511 LOGE_ANALYZER("can't find current type %d algo", algoType);
1512 return XCAM_RETURN_ERROR_FAILED;
1513 }
1514 std::map<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algoType);
1515 NULL_RETURN_RET(algo_map, XCAM_RETURN_ERROR_FAILED);
1516 std::map<int, SmartPtr<RkAiqHandle>>::iterator it = algo_map->find(id);
1517
1518 if (it == algo_map->end()) {
1519 LOGE_ANALYZER("can't find type id <%d, %d> algo", algoType, id);
1520 return XCAM_RETURN_ERROR_FAILED;
1521 }
1522
1523 SmartLock locker (mApiMutex);
1524 while (mState == RK_AIQ_CORE_STATE_RUNNING && mSafeEnableAlgo != true)
1525 mApiMutexCond.wait(mApiMutex);
1526
1527 RkAiqHandle* rmHdl = it->second.ptr();
1528 RkAiqHandle* curHdl = (*cur_algo_hdl).ptr();
1529 while (curHdl) {
1530 RkAiqHandle* nextHdl = curHdl->getNextHdl();
1531 if (nextHdl == rmHdl) {
1532 curHdl->setNextHdl(nextHdl->getNextHdl());
1533 break;
1534 }
1535 curHdl = nextHdl;
1536 }
1537
1538 algo_map->erase(it);
1539
1540 EXIT_ANALYZER_FUNCTION();
1541
1542 return XCAM_RETURN_NO_ERROR;
1543 }
1544
1545 bool
getAxlibStatus(int algoType,int id)1546 RkAiqCore::getAxlibStatus(int algoType, int id)
1547 {
1548 std::map<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algoType);
1549 NULL_RETURN_RET(algo_map, false);
1550 std::map<int, SmartPtr<RkAiqHandle>>::iterator it = algo_map->find(id);
1551
1552 if (it == algo_map->end()) {
1553 LOGE_ANALYZER("can't find type id <%d, %d> algo", algoType, id);
1554 return false;
1555 }
1556
1557 LOGD_ANALYZER("algo type id <%d,%d> status %s", algoType, id,
1558 it->second->getEnable() ? "enable" : "disable");
1559
1560 return it->second->getEnable();
1561 }
1562
1563 // get the last enabled ctx of same type
1564 RkAiqAlgoContext*
getEnabledAxlibCtx(const int algo_type)1565 RkAiqCore::getEnabledAxlibCtx(const int algo_type)
1566 {
1567 if (algo_type <= RK_AIQ_ALGO_TYPE_NONE ||
1568 algo_type >= RK_AIQ_ALGO_TYPE_MAX)
1569 return NULL;
1570
1571 std::map<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algo_type);
1572 std::map<int, SmartPtr<RkAiqHandle>>::reverse_iterator rit = algo_map->rbegin();
1573 if (rit != algo_map->rend() && rit->second->getEnable())
1574 return rit->second->getAlgoCtx();
1575 else
1576 return NULL;
1577 }
1578
1579
1580 RkAiqAlgoContext*
getAxlibCtx(const int algo_type,const int lib_id)1581 RkAiqCore::getAxlibCtx(const int algo_type, const int lib_id)
1582 {
1583 if (algo_type <= RK_AIQ_ALGO_TYPE_NONE ||
1584 algo_type >= RK_AIQ_ALGO_TYPE_MAX)
1585 return NULL;
1586
1587 std::map<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algo_type);
1588
1589 std::map<int, SmartPtr<RkAiqHandle>>::iterator it = algo_map->find(lib_id);
1590
1591 if (it != algo_map->end()) {
1592 return it->second->getAlgoCtx();
1593 }
1594
1595 EXIT_ANALYZER_FUNCTION();
1596
1597 return NULL;
1598
1599 }
1600
1601 void
copyIspStats(SmartPtr<RkAiqAecStatsProxy> & aecStat,SmartPtr<RkAiqAwbStatsProxy> & awbStat,SmartPtr<RkAiqAfStatsProxy> & afStat,rk_aiq_isp_stats_t * to)1602 RkAiqCore::copyIspStats(SmartPtr<RkAiqAecStatsProxy>& aecStat,
1603 SmartPtr<RkAiqAwbStatsProxy>& awbStat,
1604 SmartPtr<RkAiqAfStatsProxy>& afStat,
1605 rk_aiq_isp_stats_t* to)
1606 {
1607 if (aecStat.ptr()) {
1608 to->aec_stats = aecStat->data()->aec_stats;
1609 to->frame_id = aecStat->data()->frame_id;
1610 }
1611 if (mIspHwVer == 4) {
1612 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1613 to->awb_hw_ver = 4;
1614 if (awbStat.ptr()) {
1615 to->awb_stats_v32 = awbStat->data()->awb_stats_v32;
1616 }
1617 #endif
1618 } else if (mIspHwVer == 3) {
1619 #if ISP_HW_V30
1620 to->awb_hw_ver = 3;
1621 if (awbStat.ptr()) {
1622 memcpy(to->awb_stats_v3x.light, awbStat->data()->awb_stats_v3x.light,
1623 sizeof(to->awb_stats_v3x.light));
1624 #ifdef ISP_HW_V30
1625 memcpy(to->awb_stats_v3x.WpNo2, awbStat->data()->awb_stats_v3x.WpNo2,
1626 sizeof(to->awb_stats_v3x.WpNo2));
1627 #endif
1628 memcpy(to->awb_stats_v3x.blockResult, awbStat->data()->awb_stats_v3x.blockResult,
1629 sizeof(to->awb_stats_v3x.blockResult));
1630 #ifdef ISP_HW_V30
1631 memcpy(to->awb_stats_v3x.multiwindowLightResult,
1632 awbStat->data()->awb_stats_v3x.multiwindowLightResult,
1633 sizeof(to->awb_stats_v3x.multiwindowLightResult));
1634 memcpy(to->awb_stats_v3x.excWpRangeResult,
1635 awbStat->data()->awb_stats_v3x.excWpRangeResult,
1636 sizeof(to->awb_stats_v3x.excWpRangeResult));
1637 #endif
1638 memcpy(to->awb_stats_v3x.WpNoHist, awbStat->data()->awb_stats_v3x.WpNoHist,
1639 sizeof(to->awb_stats_v3x.WpNoHist));
1640 }
1641 #endif
1642 } else if (mIspHwVer == 1) {
1643 #if ISP_HW_V21
1644 to->awb_hw_ver = 1;
1645 if (awbStat.ptr()) {
1646 memcpy(to->awb_stats_v21.light, awbStat->data()->awb_stats_v201.light,
1647 sizeof(to->awb_stats_v21.light));
1648 memcpy(to->awb_stats_v21.blockResult, awbStat->data()->awb_stats_v201.blockResult,
1649 sizeof(to->awb_stats_v21.blockResult));
1650 memcpy(to->awb_stats_v21.WpNoHist, awbStat->data()->awb_stats_v201.WpNoHist,
1651 sizeof(to->awb_stats_v21.WpNoHist));
1652 }
1653 #endif
1654 } else {
1655 #if ISP_HW_V20
1656 to->awb_hw_ver = 0;
1657 if (awbStat.ptr()) to->awb_stats_v200 = awbStat->data()->awb_stats;
1658 #endif
1659 }
1660 if (mIspHwVer == 4) {
1661 #if RKAIQ_HAVE_AF_V32_LITE || RKAIQ_ONLY_AF_STATS_V32_LITE
1662 to->af_hw_ver = RKAIQ_AF_HW_V32_LITE;
1663 if (afStat.ptr()) to->af_stats_v3x = afStat->data()->af_stats_v3x;
1664 #endif
1665 #if RKAIQ_HAVE_AF_V31 || RKAIQ_ONLY_AF_STATS_V31
1666 to->af_hw_ver = RKAIQ_AF_HW_V31;
1667 if (afStat.ptr()) to->af_stats_v3x = afStat->data()->af_stats_v3x;
1668 #endif
1669 } else if (mIspHwVer == 3) {
1670 #if RKAIQ_HAVE_AF_V30 || RKAIQ_ONLY_AF_STATS_V30
1671 to->af_hw_ver = RKAIQ_AF_HW_V30;
1672 if (afStat.ptr()) to->af_stats_v3x = afStat->data()->af_stats_v3x;
1673 #endif
1674 } else {
1675 #if RKAIQ_HAVE_AF_V20 || RKAIQ_HAVE_AF_V21 || RKAIQ_ONLY_AF_STATS_V20
1676 to->af_hw_ver = RKAIQ_AF_HW_V20;
1677 if (afStat.ptr()) to->af_stats = afStat->data()->af_stats;
1678 #endif
1679 }
1680 }
1681
1682 void
cacheIspStatsToList(SmartPtr<RkAiqAecStatsProxy> & aecStat,SmartPtr<RkAiqAwbStatsProxy> & awbStat,SmartPtr<RkAiqAfStatsProxy> & afStat)1683 RkAiqCore::cacheIspStatsToList(SmartPtr<RkAiqAecStatsProxy>& aecStat,
1684 SmartPtr<RkAiqAwbStatsProxy>& awbStat,
1685 SmartPtr<RkAiqAfStatsProxy>& afStat)
1686 {
1687 SmartLock locker (ispStatsListMutex);
1688 SmartPtr<RkAiqStatsProxy> stats = NULL;
1689 if (!mAiqStatsPool.ptr()) return;
1690
1691 if (mAiqStatsPool->has_free_items()) {
1692 stats = mAiqStatsPool->get_item();
1693 } else {
1694 if (mAiqStatsCachedList.empty()) {
1695 LOGW_ANALYZER("no free or cached stats, user may hold all stats buf !");
1696 return;
1697 }
1698 stats = mAiqStatsCachedList.front();
1699 mAiqStatsCachedList.pop_front();
1700 }
1701
1702 copyIspStats(aecStat, awbStat, afStat, &stats->data()->result);
1703
1704 mAiqStatsCachedList.push_back(stats);
1705 mIspStatsCond.broadcast ();
1706 }
1707
get3AStatsFromCachedList(rk_aiq_isp_stats_t ** stats,int timeout_ms)1708 XCamReturn RkAiqCore::get3AStatsFromCachedList(rk_aiq_isp_stats_t **stats, int timeout_ms)
1709 {
1710 SmartLock locker (ispStatsListMutex);
1711 if (!mAiqStatsPool.ptr())
1712 mAiqStatsPool = new RkAiqStatsPool("RkAiqStatsPool", 2);
1713
1714 int code = 0;
1715 while (mState != RK_AIQ_CORE_STATE_STOPED &&
1716 mAiqStatsCachedList.empty() &&
1717 code == 0) {
1718 if (timeout_ms < 0)
1719 code = mIspStatsCond.wait(ispStatsListMutex);
1720 else
1721 code = mIspStatsCond.timedwait(ispStatsListMutex, timeout_ms * 1000);
1722 }
1723
1724 if (mState == RK_AIQ_CORE_STATE_STOPED) {
1725 *stats = NULL;
1726 return XCAM_RETURN_NO_ERROR;
1727 }
1728
1729 if (mAiqStatsCachedList.empty()) {
1730 if (code == ETIMEDOUT) {
1731 *stats = NULL;
1732 return XCAM_RETURN_ERROR_TIMEOUT;
1733 } else {
1734 *stats = NULL;
1735 return XCAM_RETURN_ERROR_FAILED;
1736 }
1737 }
1738 SmartPtr<RkAiqStatsProxy> stats_proxy = mAiqStatsCachedList.front();
1739 mAiqStatsCachedList.pop_front();
1740 *stats = &stats_proxy->data()->result;
1741 mAiqStatsOutMap[*stats] = stats_proxy;
1742 stats_proxy.release();
1743
1744 return XCAM_RETURN_NO_ERROR;
1745 }
1746
release3AStatsRef(rk_aiq_isp_stats_t * stats)1747 void RkAiqCore::release3AStatsRef(rk_aiq_isp_stats_t *stats)
1748 {
1749 SmartLock locker (ispStatsListMutex);
1750
1751 std::map<rk_aiq_isp_stats_t*, SmartPtr<RkAiqStatsProxy>>::iterator it;
1752 it = mAiqStatsOutMap.find(stats);
1753 if (it != mAiqStatsOutMap.end()) {
1754 mAiqStatsOutMap.erase(it);
1755 }
1756 }
1757
get3AStatsFromCachedList(rk_aiq_isp_stats_t & stats)1758 XCamReturn RkAiqCore::get3AStatsFromCachedList(rk_aiq_isp_stats_t &stats)
1759 {
1760 SmartLock locker (ispStatsListMutex);
1761 if (!mAiqStatsPool.ptr())
1762 mAiqStatsPool = new RkAiqStatsPool("RkAiqStatsPool", 2);
1763
1764 if(!mAiqStatsCachedList.empty()) {
1765 SmartPtr<RkAiqStatsProxy> stats_proxy = mAiqStatsCachedList.front();
1766 mAiqStatsCachedList.pop_front();
1767 stats = stats_proxy->data()->result;
1768 stats_proxy.release();
1769 return XCAM_RETURN_NO_ERROR;
1770 } else {
1771 return XCAM_RETURN_ERROR_FAILED;
1772 }
1773 }
1774
1775 XCamReturn
analyze(const SmartPtr<VideoBuffer> & buffer)1776 RkAiqCore::analyze(const SmartPtr<VideoBuffer> &buffer)
1777 {
1778 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1779
1780 {
1781 SmartLock locker (mApiMutex);
1782 mSafeEnableAlgo = false;
1783 }
1784
1785 if (!firstStatsReceived) {
1786 firstStatsReceived = true;
1787 mState = RK_AIQ_CORE_STATE_RUNNING;
1788 }
1789
1790 if (__builtin_expect(buffer->_buf_type == ISP_POLL_3A_STATS, true)) {
1791 SmartPtr<RkAiqAecStatsProxy> aecStat = NULL;
1792 SmartPtr<RkAiqAwbStatsProxy> awbStat = NULL;
1793 SmartPtr<RkAiqAfStatsProxy> afStat = NULL;
1794 SmartPtr<RkAiqAtmoStatsProxy> tmoStat = NULL;
1795 SmartPtr<RkAiqAdehazeStatsProxy> dehazeStat = NULL;
1796 LOGD_ANALYZER("new stats: camId:%d, sequence(%d)",
1797 mAlogsComSharedParams.mCamPhyId, buffer->get_sequence());
1798 if (mTranslator->getParams(buffer))
1799 return ret;
1800 handleAecStats(buffer, aecStat);
1801 handleAwbStats(buffer, awbStat);
1802 handleAfStats(buffer, afStat);
1803 #if RKAIQ_HAVE_TMO_V1
1804 handleAtmoStats(buffer, tmoStat);
1805 #endif
1806 handleAdehazeStats(buffer, dehazeStat);
1807 #if defined(ISP_HW_V20)
1808 handleIspStats(buffer, aecStat, awbStat, afStat, tmoStat, dehazeStat);
1809 #endif
1810 mTranslator->releaseParams();
1811 cacheIspStatsToList(aecStat, awbStat, afStat);
1812 } else {
1813 int type = -1;
1814 switch (buffer->_buf_type) {
1815 case ISPP_POLL_NR_STATS: {
1816 handleOrbStats(buffer);
1817 break;
1818 }
1819 case ISP_POLL_SP:
1820 type = XCAM_MESSAGE_ISP_POLL_SP_OK;
1821 break;
1822 case ISP_GAIN:
1823 type = XCAM_MESSAGE_ISP_GAIN_OK;
1824 break;
1825 case ISPP_GAIN_KG:
1826 type = XCAM_MESSAGE_ISPP_GAIN_KG_OK;
1827 break;
1828 case ISPP_GAIN_WR:
1829 type = XCAM_MESSAGE_ISPP_GAIN_WR_OK;
1830 break;
1831 case ISP_NR_IMG:
1832 type = XCAM_MESSAGE_NR_IMG_OK;
1833 break;
1834 case ISP_POLL_TX: {
1835 type = XCAM_MESSAGE_ISP_POLL_TX_OK;
1836 break;
1837 }
1838 case VICAP_POLL_SCL:
1839 handleVicapScaleBufs(buffer);
1840 break;
1841 #if RKAIQ_HAVE_PDAF
1842 case ISP_POLL_PDAF_STATS: {
1843 handlePdafStats(buffer);
1844 break;
1845 }
1846 #endif
1847 case ISPP_POLL_TNR_STATS:
1848 case ISPP_POLL_FEC_PARAMS:
1849 case ISPP_POLL_TNR_PARAMS:
1850 case ISPP_POLL_NR_PARAMS:
1851 case ISP_POLL_LUMA:
1852 case ISP_POLL_PARAMS:
1853 case ISP_POLL_SOF:
1854 case ISP_POLL_RX:
1855 case ISP_POLL_ISPSTREAMSYNC:
1856 case VICAP_STREAM_ON_EVT:
1857 LOGW_ANALYZER("buffer type: 0x%x is not used!", buffer->_buf_type);
1858 assert(false);
1859 break;
1860 default:
1861 LOGW_ANALYZER("don't know buffer type: 0x%x!", buffer->_buf_type);
1862 assert(false);
1863 break;
1864 }
1865 if (type != -1) {
1866 RkAiqCoreVdBufMsg msg(static_cast<XCamMessageType>(type),
1867 buffer->get_sequence(), buffer);
1868 post_message(msg);
1869 }
1870 }
1871
1872 return ret;
1873 }
1874
1875 XCamReturn
events_analyze(const SmartPtr<ispHwEvt_t> & evts)1876 RkAiqCore::events_analyze(const SmartPtr<ispHwEvt_t> &evts)
1877 {
1878 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1879 SmartPtr<RkAiqSensorExpParamsProxy> preExpParams = nullptr;
1880 SmartPtr<RkAiqSensorExpParamsProxy> curExpParams = nullptr;
1881 SmartPtr<RkAiqSensorExpParamsProxy> nxtExpParams = nullptr;
1882
1883 Isp20Evt* isp20Evts =
1884 evts.get_cast_ptr<Isp20Evt>();
1885 uint32_t sequence = isp20Evts->sequence;
1886 if (sequence == (uint32_t)(-1))
1887 return ret;
1888
1889 uint32_t id = 0, maxId = 0;
1890 if (sequence > 0)
1891 id = mLastAnalyzedId + 1 > sequence ? mLastAnalyzedId + 1 : sequence;
1892 maxId = sequence == 0 ? 0 : sequence + isp20Evts->expDelay - 1;
1893
1894 LOGD_ANALYZER("camId:%d, sequence(%d), expDelay(%d), id(%d), maxId(%d)",
1895 mAlogsComSharedParams.mCamPhyId,
1896 isp20Evts->sequence, isp20Evts->expDelay,
1897 id, maxId);
1898
1899 while (id <= maxId) {
1900 if (isp20Evts->getExpInfoParams(preExpParams, id > 0 ? id - 1 : 0 ) < 0) {
1901 LOGE_ANALYZER("id(%d) get pre exp failed!", id);
1902 break;
1903 }
1904 if (isp20Evts->getExpInfoParams(curExpParams, id) < 0) {
1905 LOGE_ANALYZER("id(%d) get exp failed!", id);
1906 break;
1907 }
1908 if (isp20Evts->getExpInfoParams(nxtExpParams, id + 1) < 0) {
1909 LOGE_ANALYZER("id(%d) get exp failed!", id + 1);
1910 break;
1911 }
1912
1913 SmartPtr<RkAiqSofInfoWrapperProxy> sofInfo = NULL;
1914 if (mAiqSofInfoWrapperPool->has_free_items()) {
1915 sofInfo = mAiqSofInfoWrapperPool->get_item();
1916 } else {
1917 LOGE_ANALYZER("no free item for sofInfo!");
1918 return XCAM_RETURN_BYPASS;
1919 }
1920
1921 sofInfo->data()->sequence = id;
1922 sofInfo->data()->preExp = preExpParams;
1923 sofInfo->data()->curExp = curExpParams;
1924 sofInfo->data()->nxtExp = nxtExpParams;
1925 sofInfo->data()->sof = isp20Evts->getSofTimeStamp();
1926
1927
1928 sofInfo->setId(id);
1929 sofInfo->setType(RK_AIQ_SHARED_TYPE_SOF_INFO);
1930
1931 int64_t sofTime = isp20Evts->getSofTimeStamp() / 1000LL;
1932 if (mSofTime != 0LL)
1933 mFrmInterval = sofTime - mSofTime;
1934 mSofTime = sofTime;
1935
1936 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_SOF_INFO_OK, id, sofInfo);
1937 post_message(msg);
1938
1939 mLastAnalyzedId = id;
1940 id++;
1941
1942 LOGV_ANALYZER(">>> Framenum=%d, id=%d, Cur sgain=%f,stime=%f,mgain=%f,mtime=%f,lgain=%f,ltime=%f",
1943 isp20Evts->sequence, id, curExpParams->data()->aecExpInfo.HdrExp[0].exp_real_params.analog_gain,
1944 curExpParams->data()->aecExpInfo.HdrExp[0].exp_real_params.integration_time,
1945 curExpParams->data()->aecExpInfo.HdrExp[1].exp_real_params.analog_gain,
1946 curExpParams->data()->aecExpInfo.HdrExp[1].exp_real_params.integration_time,
1947 curExpParams->data()->aecExpInfo.HdrExp[2].exp_real_params.analog_gain,
1948 curExpParams->data()->aecExpInfo.HdrExp[2].exp_real_params.integration_time);
1949 LOGV_ANALYZER(">>> Framenum=%d, id=%d, nxt sgain=%f,stime=%f,mgain=%f,mtime=%f,lgain=%f,ltime=%f",
1950 isp20Evts->sequence, id, nxtExpParams->data()->aecExpInfo.HdrExp[0].exp_real_params.analog_gain,
1951 nxtExpParams->data()->aecExpInfo.HdrExp[0].exp_real_params.integration_time,
1952 nxtExpParams->data()->aecExpInfo.HdrExp[1].exp_real_params.analog_gain,
1953 nxtExpParams->data()->aecExpInfo.HdrExp[1].exp_real_params.integration_time,
1954 nxtExpParams->data()->aecExpInfo.HdrExp[2].exp_real_params.analog_gain,
1955 nxtExpParams->data()->aecExpInfo.HdrExp[2].exp_real_params.integration_time);
1956
1957 LOGV_ANALYZER("analyze the id(%d), sequence(%d), mLastAnalyzedId(%d)",
1958 id, sequence, mLastAnalyzedId);
1959 }
1960
1961 return ret;
1962 }
1963
1964 XCamReturn
prepare(enum rk_aiq_core_analyze_type_e type)1965 RkAiqCore::prepare(enum rk_aiq_core_analyze_type_e type)
1966 {
1967 ENTER_ANALYZER_FUNCTION();
1968
1969 XCamReturn ret = XCAM_RETURN_BYPASS;
1970 XCamReturn ret2 = XCAM_RETURN_BYPASS;
1971
1972 std::vector<SmartPtr<RkAiqHandle>>& algo_list =
1973 mRkAiqCoreGroupManager->getGroupAlgoList(type);
1974
1975 for (auto& algoHdl : algo_list) {
1976 RkAiqHandle* curHdl = algoHdl.ptr();
1977 while (curHdl) {
1978 if (curHdl->getEnable()) {
1979 ret2 = curHdl->updateConfig(true);
1980 RKAIQCORE_CHECK_BYPASS(ret2, "algoHdl %d updateConfig failed", curHdl->getAlgoType());
1981 ret2 = curHdl->prepare();
1982 RKAIQCORE_CHECK_BYPASS(ret2, "algoHdl %d processing failed", curHdl->getAlgoType());
1983 if (ret2 == XCAM_RETURN_NO_ERROR) {
1984 ret = XCAM_RETURN_NO_ERROR;
1985 }
1986 }
1987 curHdl = curHdl->getNextHdl();
1988 }
1989 }
1990
1991 EXIT_ANALYZER_FUNCTION();
1992
1993 return XCAM_RETURN_NO_ERROR;
1994 }
1995
1996 XCamReturn
setHwInfos(struct RkAiqHwInfo & hw_info)1997 RkAiqCore::setHwInfos(struct RkAiqHwInfo &hw_info)
1998 {
1999 ENTER_ANALYZER_FUNCTION();
2000 mHwInfo = hw_info;
2001 if (mTranslator.ptr())
2002 mTranslator->setModuleRot(mHwInfo.module_rotation);
2003 EXIT_ANALYZER_FUNCTION();
2004
2005 return XCAM_RETURN_NO_ERROR;
2006 }
2007
2008 #if RKAIQ_HAVE_ASD_V10
2009 XCamReturn
setCpsLtCfg(rk_aiq_cpsl_cfg_t & cfg)2010 RkAiqCore::setCpsLtCfg(rk_aiq_cpsl_cfg_t &cfg)
2011 {
2012 ENTER_ANALYZER_FUNCTION();
2013 if (mState < RK_AIQ_CORE_STATE_INITED) {
2014 LOGE_ASD("should call afer init");
2015 return XCAM_RETURN_ERROR_FAILED;
2016 }
2017
2018 if (mCpslCap.modes_num == 0)
2019 return XCAM_RETURN_ERROR_PARAM;
2020
2021 int i = 0;
2022 for (; i < mCpslCap.modes_num; i++) {
2023 if (mCpslCap.supported_modes[i] == cfg.mode)
2024 break;
2025 }
2026
2027 if (i == mCpslCap.modes_num) {
2028 return XCAM_RETURN_ERROR_PARAM;
2029 }
2030
2031 if (cfg.mode == RK_AIQ_OP_MODE_AUTO) {
2032 mAlogsComSharedParams.cpslCfg.u.a = cfg.u.a;
2033 } else if (cfg.mode == RK_AIQ_OP_MODE_MANUAL) {
2034 mAlogsComSharedParams.cpslCfg.u.m = cfg.u.m;
2035 } else {
2036 return XCAM_RETURN_ERROR_PARAM;
2037 }
2038
2039 mAlogsComSharedParams.cpslCfg.mode = cfg.mode;
2040
2041 for (i = 0; i < mCpslCap.lght_src_num; i++) {
2042 if (mCpslCap.supported_lght_src[i] == cfg.lght_src)
2043 break;
2044 }
2045
2046 if (i == mCpslCap.lght_src_num) {
2047 return XCAM_RETURN_ERROR_PARAM;
2048 }
2049
2050 mAlogsComSharedParams.cpslCfg = cfg;
2051 LOGD_ASD("set cpsl: mode %d", cfg.mode);
2052 EXIT_ANALYZER_FUNCTION();
2053
2054 return XCAM_RETURN_NO_ERROR;
2055 }
2056
2057 XCamReturn
getCpsLtInfo(rk_aiq_cpsl_info_t & info)2058 RkAiqCore::getCpsLtInfo(rk_aiq_cpsl_info_t &info)
2059 {
2060 ENTER_ANALYZER_FUNCTION();
2061 if (mState < RK_AIQ_CORE_STATE_INITED) {
2062 LOGE_ANALYZER("should call afer init");
2063 return XCAM_RETURN_ERROR_FAILED;
2064 }
2065
2066 info.mode = mAlogsComSharedParams.cpslCfg.mode;
2067 if (info.mode == RK_AIQ_OP_MODE_MANUAL) {
2068 info.on = mAlogsComSharedParams.cpslCfg.u.m.on;
2069 info.strength_led = mAlogsComSharedParams.cpslCfg.u.m.strength_led;
2070 info.strength_ir = mAlogsComSharedParams.cpslCfg.u.m.strength_ir;
2071 } else {
2072 info.on = mCurCpslOn;
2073 info.gray = mAlogsComSharedParams.gray_mode;
2074 }
2075
2076 info.lght_src = mAlogsComSharedParams.cpslCfg.lght_src;
2077 EXIT_ANALYZER_FUNCTION();
2078
2079 return XCAM_RETURN_NO_ERROR;
2080 }
2081
2082 XCamReturn
queryCpsLtCap(rk_aiq_cpsl_cap_t & cap)2083 RkAiqCore::queryCpsLtCap(rk_aiq_cpsl_cap_t &cap)
2084 {
2085 ENTER_ANALYZER_FUNCTION();
2086 if (mHwInfo.fl_supported || mHwInfo.irc_supported) {
2087 cap.supported_modes[0] = RK_AIQ_OP_MODE_AUTO;
2088 cap.supported_modes[1] = RK_AIQ_OP_MODE_MANUAL;
2089 cap.modes_num = 2;
2090 } else {
2091 cap.modes_num = 0;
2092 }
2093
2094 cap.lght_src_num = 0;
2095 if (mHwInfo.fl_supported) {
2096 cap.supported_lght_src[0] = RK_AIQ_CPSLS_LED;
2097 cap.lght_src_num++;
2098 }
2099
2100 if (mHwInfo.irc_supported) {
2101 cap.supported_lght_src[cap.lght_src_num] = RK_AIQ_CPSLS_IR;
2102 cap.lght_src_num++;
2103 }
2104
2105 if (cap.lght_src_num > 1) {
2106 cap.supported_lght_src[cap.lght_src_num] = RK_AIQ_CPSLS_MIX;
2107 cap.lght_src_num++;
2108 }
2109
2110 cap.strength_led.min = 0;
2111 cap.strength_led.max = 100;
2112 if (!mHwInfo.fl_strth_adj)
2113 cap.strength_led.step = 100;
2114 else
2115 cap.strength_led.step = 1;
2116
2117 cap.strength_ir.min = 0;
2118 cap.strength_ir.max = 100;
2119 if (!mHwInfo.fl_ir_strth_adj)
2120 cap.strength_ir.step = 100;
2121 else
2122 cap.strength_ir.step = 1;
2123
2124 cap.sensitivity.min = 0;
2125 cap.sensitivity.max = 100;
2126 cap.sensitivity.step = 1;
2127
2128 LOGD_ASD("cpsl cap: light_src_num %d, led_step %f, ir_step %f",
2129 cap.lght_src_num, cap.strength_led.step, cap.strength_ir.step);
2130
2131 EXIT_ANALYZER_FUNCTION();
2132
2133 return XCAM_RETURN_NO_ERROR;
2134 }
2135
2136 XCamReturn
genCpslResult(RkAiqFullParams * params,RkAiqAlgoPreResAsd * asd_pre_rk)2137 RkAiqCore::genCpslResult(RkAiqFullParams* params, RkAiqAlgoPreResAsd* asd_pre_rk)
2138 {
2139 rk_aiq_cpsl_cfg_t* cpsl_cfg = &mAlogsComSharedParams.cpslCfg;
2140
2141 if (cpsl_cfg->mode == RK_AIQ_OP_MODE_INVALID)
2142 return XCAM_RETURN_NO_ERROR;
2143
2144 if (mAiqCpslParamsPool->has_free_items()) {
2145 params->mCpslParams = mAiqCpslParamsPool->get_item();
2146 } else {
2147 LOGW_ANALYZER("no free cpsl params buffer!");
2148 return XCAM_RETURN_NO_ERROR;
2149 }
2150
2151 RKAiqCpslInfoWrapper_t* cpsl_param = params->mCpslParams->data().ptr();
2152 //xcam_mem_clear(*cpsl_param);
2153
2154 LOGD_ANALYZER("cpsl mode %d, light src %d", cpsl_cfg->mode, cpsl_cfg->lght_src);
2155 bool cpsl_on = false;
2156 bool need_update = false;
2157
2158 if (cpsl_cfg->mode == RK_AIQ_OP_MODE_MANUAL) {
2159 if ((mCurCpslOn != cpsl_cfg->u.m.on) ||
2160 (fabs(mStrthLed - cpsl_cfg->u.m.strength_led) > EPSINON) ||
2161 (fabs(mStrthIr - cpsl_cfg->u.m.strength_ir) > EPSINON)) {
2162 need_update = true;
2163 cpsl_on = cpsl_cfg->u.m.on;
2164 cpsl_param->fl.power[0] = cpsl_cfg->u.m.strength_led / 100.0f;
2165 cpsl_param->fl_ir.power[0] = cpsl_cfg->u.m.strength_ir / 100.0f;
2166 }
2167 } else {
2168 RkAiqAlgosGroupShared_t* shared = nullptr;
2169 int groupId = getGroupId(RK_AIQ_ALGO_TYPE_ASD);
2170 if (groupId >= 0) {
2171 if (getGroupSharedParams(groupId, shared) != XCAM_RETURN_NO_ERROR)
2172 return XCAM_RETURN_BYPASS;
2173 } else
2174 return XCAM_RETURN_BYPASS;
2175 if (asd_pre_rk) {
2176 asd_preprocess_result_t* asd_result = &asd_pre_rk->asd_result;
2177 if (mCurCpslOn != asd_result->cpsl_on) {
2178 need_update = true;
2179 cpsl_on = asd_result->cpsl_on;
2180 }
2181 }
2182 cpsl_param->fl.power[0] = 1.0f;
2183 cpsl_param->fl_ir.power[0] = 1.0f;
2184 }
2185
2186 // need to init cpsl status, cause the cpsl driver state
2187 // may be not correct
2188 if (mState == RK_AIQ_CORE_STATE_INITED)
2189 need_update = true;
2190
2191 if (need_update) {
2192 if (cpsl_cfg->lght_src & RK_AIQ_CPSLS_LED) {
2193 cpsl_param->update_fl = true;
2194 if (cpsl_on)
2195 cpsl_param->fl.flash_mode = RK_AIQ_FLASH_MODE_TORCH;
2196 else
2197 cpsl_param->fl.flash_mode = RK_AIQ_FLASH_MODE_OFF;
2198 if (cpsl_on ) {
2199 cpsl_param->fl.strobe = true;
2200 mAlogsComSharedParams.fill_light_on = true;
2201 } else {
2202 cpsl_param->fl.strobe = false;
2203 mAlogsComSharedParams.fill_light_on = false;
2204 }
2205 LOGD_ANALYZER("cpsl fl mode %d, strength %f, strobe %d",
2206 cpsl_param->fl.flash_mode, cpsl_param->fl.power[0],
2207 cpsl_param->fl.strobe);
2208 }
2209
2210 if (cpsl_cfg->lght_src & RK_AIQ_CPSLS_IR) {
2211 cpsl_param->update_ir = true;
2212 if (cpsl_on) {
2213 cpsl_param->ir.irc_on = true;
2214 cpsl_param->fl_ir.flash_mode = RK_AIQ_FLASH_MODE_TORCH;
2215 cpsl_param->fl_ir.strobe = true;
2216 mAlogsComSharedParams.fill_light_on = true;
2217 } else {
2218 cpsl_param->ir.irc_on = false;
2219 cpsl_param->fl_ir.flash_mode = RK_AIQ_FLASH_MODE_OFF;
2220 cpsl_param->fl_ir.strobe = false;
2221 mAlogsComSharedParams.fill_light_on = false;
2222 }
2223 LOGD_ANALYZER("cpsl irc on %d, fl_ir: mode %d, strength %f, strobe %d",
2224 cpsl_param->ir.irc_on, cpsl_param->fl_ir.flash_mode, cpsl_param->fl_ir.power[0],
2225 cpsl_param->fl_ir.strobe);
2226 }
2227
2228 if (mGrayMode == RK_AIQ_GRAY_MODE_CPSL) {
2229 if (mAlogsComSharedParams.fill_light_on && cpsl_cfg->gray_on) {
2230 mAlogsComSharedParams.gray_mode = true;
2231 } else
2232 mAlogsComSharedParams.gray_mode = false;
2233
2234 } else {
2235 /* no mutex lock protection for gray_mode with setGrayMode,
2236 * so need set again here
2237 */
2238 if (mGrayMode == RK_AIQ_GRAY_MODE_OFF)
2239 mAlogsComSharedParams.gray_mode = false;
2240 else if (mGrayMode == RK_AIQ_GRAY_MODE_ON)
2241 mAlogsComSharedParams.gray_mode = true;
2242 }
2243 mCurCpslOn = cpsl_on;
2244 mStrthLed = cpsl_cfg->u.m.strength_led;
2245 mStrthIr = cpsl_cfg->u.m.strength_ir;
2246 } else {
2247 cpsl_param->update_ir = false;
2248 cpsl_param->update_fl = false;
2249 }
2250
2251 RkAiqAlgosGroupShared_t* shared = nullptr;
2252 int groupId = getGroupId(RK_AIQ_ALGO_TYPE_ASD);
2253 if (groupId >= 0) {
2254 if (getGroupSharedParams(groupId, shared) == XCAM_RETURN_NO_ERROR) {
2255 if (mAlogsComSharedParams.init)
2256 cpsl_param->frame_id = 0;
2257 else
2258 cpsl_param->frame_id = shared->frameId;
2259 }
2260 }
2261
2262 return XCAM_RETURN_NO_ERROR;
2263 }
2264 #endif
2265
2266 XCamReturn
setGrayMode(rk_aiq_gray_mode_t mode)2267 RkAiqCore::setGrayMode(rk_aiq_gray_mode_t mode)
2268 {
2269 LOGD_ANALYZER("%s: gray mode %d", __FUNCTION__, mode);
2270
2271 if (mAlogsComSharedParams.is_bw_sensor) {
2272 LOGE_ANALYZER("%s: not support for black&white sensor", __FUNCTION__);
2273 return XCAM_RETURN_ERROR_PARAM;
2274 }
2275
2276 CalibDbV2_ColorAsGrey_t *colorAsGrey =
2277 (CalibDbV2_ColorAsGrey_t*)CALIBDBV2_GET_MODULE_PTR((void*)(mAlogsComSharedParams.calibv2), colorAsGrey);
2278
2279 if (colorAsGrey->param.enable) {
2280 LOGE_ANALYZER("%s: not support,since color_as_grey is enabled in xml", __FUNCTION__);
2281 return XCAM_RETURN_ERROR_PARAM;
2282 }
2283
2284 mGrayMode = mode;
2285 if (mode == RK_AIQ_GRAY_MODE_OFF)
2286 mAlogsComSharedParams.gray_mode = false;
2287 else if (mode == RK_AIQ_GRAY_MODE_ON)
2288 mAlogsComSharedParams.gray_mode = true;
2289 else if (mode == RK_AIQ_GRAY_MODE_CPSL)
2290 ; // do nothing
2291 else
2292 LOGE_ANALYZER("%s: gray mode %d error", __FUNCTION__, mode);
2293
2294 return XCAM_RETURN_NO_ERROR;
2295 }
2296
2297 rk_aiq_gray_mode_t
getGrayMode()2298 RkAiqCore::getGrayMode()
2299 {
2300 LOGD_ANALYZER("%s: gray mode %d", __FUNCTION__, mGrayMode);
2301 return mGrayMode;
2302 }
2303
2304 void
setSensorFlip(bool mirror,bool flip)2305 RkAiqCore::setSensorFlip(bool mirror, bool flip)
2306 {
2307 mAlogsComSharedParams.sns_mirror = mirror;
2308 mAlogsComSharedParams.sns_flip = flip;
2309 }
2310
2311 #ifdef RKAIQ_ENABLE_PARSER_V1
2312 XCamReturn
setCalib(const CamCalibDbContext_t * aiqCalib)2313 RkAiqCore::setCalib(const CamCalibDbContext_t* aiqCalib)
2314 {
2315 ENTER_ANALYZER_FUNCTION();
2316
2317 if (mState != RK_AIQ_CORE_STATE_STOPED) {
2318 LOGE_ANALYZER("wrong state %d\n", mState);
2319 return XCAM_RETURN_ERROR_ANALYZER;
2320 }
2321
2322 /* TODO: xuhf WARNING */
2323 mAlogsComSharedParams.calib = aiqCalib;
2324 mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_UPDATECALIB;
2325
2326 EXIT_ANALYZER_FUNCTION();
2327
2328 return XCAM_RETURN_NO_ERROR;
2329 }
2330 #endif
2331
2332 XCamReturn
setCalib(const CamCalibDbV2Context_t * aiqCalib)2333 RkAiqCore::setCalib(const CamCalibDbV2Context_t* aiqCalib)
2334 {
2335 ENTER_ANALYZER_FUNCTION();
2336
2337 #if 0
2338 if (mState != RK_AIQ_CORE_STATE_STOPED) {
2339 LOGE_ANALYZER("wrong state %d\n", mState);
2340 return XCAM_RETURN_ERROR_ANALYZER;
2341 }
2342 #endif
2343 /* TODO: xuhf WARNING */
2344 mAlogsComSharedParams.calibv2 = aiqCalib;
2345 mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_UPDATECALIB;
2346
2347 EXIT_ANALYZER_FUNCTION();
2348
2349 return XCAM_RETURN_NO_ERROR;
2350 }
2351
calibTuning(const CamCalibDbV2Context_t * aiqCalib,ModuleNameList & change_name_list)2352 XCamReturn RkAiqCore::calibTuning(const CamCalibDbV2Context_t* aiqCalib,
2353 ModuleNameList& change_name_list)
2354 {
2355 ENTER_ANALYZER_FUNCTION();
2356
2357 if (!aiqCalib || !change_name_list) {
2358 LOGE_ANALYZER("invalied tuning param\n");
2359 return XCAM_RETURN_ERROR_PARAM;
2360 }
2361
2362 // Fill new calib to the AlogsSharedParams
2363 mAlogsComSharedParams.calibv2 = aiqCalib;
2364 mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_UPDATECALIB;
2365
2366 std::for_each(std::begin(*change_name_list), std::end(*change_name_list),
2367 [this](const std::string & name) {
2368 if (!name.compare(0, 4, "cpsl", 0, 4)) {
2369 #if RKAIQ_HAVE_ASD_V10
2370 initCpsl();
2371 #endif
2372 } else if (!name.compare(0, 11, "colorAsGrey", 0, 11)) {
2373 CalibDbV2_ColorAsGrey_t* colorAsGrey =
2374 (CalibDbV2_ColorAsGrey_t*)CALIBDBV2_GET_MODULE_PTR(
2375 (void*)(mAlogsComSharedParams.calibv2), colorAsGrey);
2376 #if RKAIQ_HAVE_ASD_V10
2377 CalibDbV2_Cpsl_t* calibv2_cpsl_db = (CalibDbV2_Cpsl_t*)CALIBDBV2_GET_MODULE_PTR(
2378 (void*)(mAlogsComSharedParams.calibv2), cpsl);
2379 #else
2380 CalibDbV2_Cpsl_t* calibv2_cpsl_db = NULL;
2381 #endif
2382
2383 if (colorAsGrey->param.enable) {
2384 mGrayMode = RK_AIQ_GRAY_MODE_ON;
2385 mAlogsComSharedParams.gray_mode = true;
2386 } else if (calibv2_cpsl_db && calibv2_cpsl_db->param.enable) {
2387 mGrayMode = RK_AIQ_GRAY_MODE_CPSL;
2388 mAlogsComSharedParams.gray_mode =
2389 mAlogsComSharedParams.fill_light_on && calibv2_cpsl_db->param.force_gray;
2390 } else {
2391 mGrayMode = RK_AIQ_GRAY_MODE_OFF;
2392 mAlogsComSharedParams.gray_mode = false;
2393 }
2394 }
2395 });
2396
2397 uint64_t grpMask = 0;
2398 auto algoGroupMap = mRkAiqCoreGroupManager->getGroupAlgoListMap();
2399 for (const auto& group : algoGroupMap) {
2400 if (group.first != RK_AIQ_CORE_ANALYZE_ALL) {
2401 grpMask |= grpId2GrpMask(group.first);
2402 }
2403 }
2404
2405 notifyUpdate(grpMask);
2406 if (mState != RK_AIQ_CORE_STATE_RUNNING)
2407 updateCalib(RK_AIQ_CORE_ANALYZE_ALL);
2408 else {
2409 waitUpdateDone();
2410 }
2411 mAlogsComSharedParams.conf_type &= ~RK_AIQ_ALGO_CONFTYPE_UPDATECALIB;
2412
2413 EXIT_ANALYZER_FUNCTION();
2414
2415 return XCAM_RETURN_NO_ERROR;
2416 }
2417
setMemsSensorIntf(const rk_aiq_mems_sensor_intf_t * intf)2418 XCamReturn RkAiqCore::setMemsSensorIntf(const rk_aiq_mems_sensor_intf_t* intf) {
2419 if (mState != RK_AIQ_CORE_STATE_INITED) {
2420 LOGE_ANALYZER("set MEMS sensor intf in wrong aiq state %d !", mState);
2421 return XCAM_RETURN_ERROR_FAILED;
2422 }
2423
2424 mMemsSensorIntf = intf;
2425
2426 return XCAM_RETURN_NO_ERROR;
2427 }
2428
getMemsSensorIntf()2429 const rk_aiq_mems_sensor_intf_t* RkAiqCore::getMemsSensorIntf() {
2430 return mMemsSensorIntf;
2431 }
2432
post_message(RkAiqCoreVdBufMsg & msg)2433 void RkAiqCore::post_message (RkAiqCoreVdBufMsg& msg)
2434 {
2435 mRkAiqCoreGroupManager->handleMessage(msg);
2436 #ifdef RKAIQ_ENABLE_CAMGROUP
2437 if (mCamGroupCoreManager)
2438 mCamGroupCoreManager->processAiqCoreMsgs(this, msg);
2439 #endif
2440 }
2441
2442 XCamReturn
handle_message(const SmartPtr<XCamMessage> & msg)2443 RkAiqCore::handle_message (const SmartPtr<XCamMessage> &msg)
2444 {
2445 //return mRkAiqCoreGroupManager->handleMessage(msg);
2446 return XCAM_RETURN_NO_ERROR;
2447 }
2448
groupAnalyze(uint64_t grpId,const RkAiqAlgosGroupShared_t * shared)2449 XCamReturn RkAiqCore::groupAnalyze(uint64_t grpId, const RkAiqAlgosGroupShared_t* shared) {
2450 ENTER_ANALYZER_FUNCTION();
2451
2452 SmartPtr<RkAiqFullParamsProxy> fullParam = NULL;
2453
2454 analyzeInternal(static_cast<rk_aiq_core_analyze_type_e>(grpId));
2455 {
2456 SmartLock locker (_mFullParam_mutex);
2457 if (mFullParamsPendingMap.count(shared->frameId) &&
2458 mFullParamsPendingMap[shared->frameId].ready) {
2459 #if 1
2460 for (auto item = mFullParamsPendingMap.begin(); item != mFullParamsPendingMap.end();) {
2461 if (item->first <= shared->frameId) {
2462 fullParam = item->second.proxy;
2463 fullParam->data()->mFrmId = item->first;
2464 item = mFullParamsPendingMap.erase(item);
2465 mLatestParamsDoneId = fullParam->data()->mFrmId;
2466 LOGD_ANALYZER("[%d]:%p fullParams done !", fullParam->data()->mFrmId, fullParam->data().ptr());
2467 } else
2468 break;
2469 }
2470 #else
2471 auto item = mFullParamsPendingMap.find(shared->frameId);
2472 fullParam = item->second.proxy;
2473 fullParam->data()->mFrmId = shared->frameId;
2474 mFullParamsPendingMap.erase(item);
2475 LOGD_ANALYZER("[%d]:%p fullParams done !", fullParam->data()->mFrmId, fullParam->data().ptr());
2476 #endif
2477 } else {
2478 uint16_t counts = mFullParamsPendingMap.size();
2479 if (counts > FULLPARMAS_MAX_PENDING_SIZE) {
2480 auto item = mFullParamsPendingMap.begin();
2481 fullParam = item->second.proxy;
2482 LOGW_ANALYZER("force [%d->%d]:%p fullParams done !", item->first, shared->frameId, fullParam->data().ptr());
2483 mFullParamsPendingMap.erase(item);
2484 fullParam->data()->mFrmId = shared->frameId;
2485 mLatestParamsDoneId = fullParam->data()->mFrmId;
2486 }
2487 }
2488 }
2489 if (fullParam.ptr()) {
2490 LOG1_ANALYZER("cb [%d] fullParams done !", shared->frameId);
2491 #ifdef RKAIQ_ENABLE_CAMGROUP
2492 if (mCamGroupCoreManager)
2493 mCamGroupCoreManager->RelayAiqCoreResults(this, fullParam);
2494 else if (mCb)
2495 #else
2496 if (mCb)
2497 #endif
2498 mCb->rkAiqCalcDone(fullParam);
2499 }
2500 exit:
2501 EXIT_ANALYZER_FUNCTION();
2502 return XCAM_RETURN_NO_ERROR;
2503 }
2504
2505 #if defined(RKAIQ_HAVE_THUMBNAILS)
2506 XCamReturn
thumbnailsGroupAnalyze(rkaiq_image_source_t & thumbnailsSrc)2507 RkAiqCore::thumbnailsGroupAnalyze(rkaiq_image_source_t &thumbnailsSrc)
2508 {
2509 uint32_t frameId = thumbnailsSrc.frame_id;
2510
2511 if (mThumbnailsService.ptr())
2512 mThumbnailsService->OnFrameEvent(thumbnailsSrc);
2513
2514 thumbnailsSrc.image_source->unref(thumbnailsSrc.image_source);
2515
2516 return XCAM_RETURN_NO_ERROR;
2517 }
2518 #endif
2519
newAiqParamsPool()2520 void RkAiqCore::newAiqParamsPool()
2521 {
2522 for (auto& algoHdl : mCurIspAlgoHandleList) {
2523 bool alloc_pool = false;
2524 RkAiqHandle* curHdl = algoHdl.ptr();
2525 while (curHdl) {
2526 if (curHdl->getEnable()) {
2527 alloc_pool = true;
2528 break;
2529 }
2530 curHdl = curHdl->getNextHdl();
2531 }
2532 if (alloc_pool) {
2533 switch (algoHdl->getAlgoType()) {
2534 case RK_AIQ_ALGO_TYPE_AE:
2535 if (!mAiqAecStatsPool.ptr())
2536 mAiqAecStatsPool = new RkAiqAecStatsPool("RkAiqAecStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
2537 mAiqExpParamsPool =
2538 new RkAiqExpParamsPool("RkAiqExpParams", RkAiqCore::DEFAULT_POOL_SIZE);
2539 mAiqIrisParamsPool = new RkAiqIrisParamsPool("RkAiqIrisParams", RkAiqCore::DEFAULT_POOL_SIZE);
2540 mAiqIspAecParamsPool =
2541 new RkAiqIspAecParamsPool("RkAiqIspAecParams", RkAiqCore::DEFAULT_POOL_SIZE);
2542 mAiqIspHistParamsPool =
2543 new RkAiqIspHistParamsPool("RkAiqIspHistParams", RkAiqCore::DEFAULT_POOL_SIZE);
2544 break;
2545 case RK_AIQ_ALGO_TYPE_AWB:
2546 if (!mAiqAwbStatsPool.ptr())
2547 mAiqAwbStatsPool = new RkAiqAwbStatsPool("RkAiqAwbStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
2548 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2549 mAiqIspAwbV32ParamsPool = new RkAiqIspAwbParamsPoolV32(
2550 "RkAiqIspAwbV32Params", RkAiqCore::DEFAULT_POOL_SIZE);
2551 #elif defined(ISP_HW_V30)
2552 mAiqIspAwbV3xParamsPool = new RkAiqIspAwbParamsPoolV3x(
2553 "RkAiqIspAwbV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
2554 #elif defined(ISP_HW_V21)
2555 mAiqIspAwbV21ParamsPool = new RkAiqIspAwbParamsPoolV21(
2556 "RkAiqIspAwbV21Params", RkAiqCore::DEFAULT_POOL_SIZE);
2557 #else
2558 mAiqIspAwbParamsPool =
2559 new RkAiqIspAwbParamsPool("RkAiqIspAwbParams", RkAiqCore::DEFAULT_POOL_SIZE);
2560 #endif
2561 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2562 mAiqIspAwbGainV32ParamsPool = new RkAiqIspAwbGainParamsPoolV32(
2563 "RkAiqIspAwbGainParams", RkAiqCore::DEFAULT_POOL_SIZE);
2564 #else
2565 mAiqIspAwbGainParamsPool = new RkAiqIspAwbGainParamsPool(
2566 "RkAiqIspAwbGainParams", RkAiqCore::DEFAULT_POOL_SIZE);
2567 #endif
2568 break;
2569 case RK_AIQ_ALGO_TYPE_AF:
2570 if (!mAiqAfStatsPool.ptr())
2571 mAiqAfStatsPool = new RkAiqAfStatsPool("RkAiqAfStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
2572 #if RKAIQ_HAVE_PDAF
2573 if (!mAiqPdafStatsPool.ptr())
2574 mAiqPdafStatsPool = new RkAiqPdafStatsPool("RkAiqPdafStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
2575 #endif
2576 mAiqFocusParamsPool = new RkAiqFocusParamsPool("RkAiqFocusParams", RkAiqCore::DEFAULT_POOL_SIZE);
2577 #if defined(ISP_HW_V32_LITE)
2578 mAiqIspAfV32LiteParamsPool =
2579 new RkAiqIspAfParamsPoolV32Lite("RkAiqIspAfParams", RkAiqCore::DEFAULT_POOL_SIZE);
2580 #elif defined(ISP_HW_V32)
2581 mAiqIspAfV32ParamsPool =
2582 new RkAiqIspAfParamsPoolV32("RkAiqIspAfParams", RkAiqCore::DEFAULT_POOL_SIZE);
2583 #elif defined(ISP_HW_V30)
2584 mAiqIspAfV3xParamsPool =
2585 new RkAiqIspAfParamsPoolV3x("RkAiqIspAfParams", RkAiqCore::DEFAULT_POOL_SIZE);
2586 #else
2587 mAiqIspAfParamsPool =
2588 new RkAiqIspAfParamsPool("RkAiqIspAfParams", RkAiqCore::DEFAULT_POOL_SIZE);
2589 #endif
2590 break;
2591 case RK_AIQ_ALGO_TYPE_ADPCC:
2592 mAiqIspDpccParamsPool = new RkAiqIspDpccParamsPool("RkAiqIspDpccParams", RkAiqCore::DEFAULT_POOL_SIZE);
2593 break;
2594 case RK_AIQ_ALGO_TYPE_AMERGE:
2595 mAiqIspMergeParamsPool = new RkAiqIspMergeParamsPool("RkAiqIspMergeParams", RkAiqCore::DEFAULT_POOL_SIZE);
2596 break;
2597 case RK_AIQ_ALGO_TYPE_ATMO:
2598 #if defined(ISP_HW_V20)
2599 if (!mAiqAtmoStatsPool.ptr())
2600 mAiqAtmoStatsPool = new RkAiqAtmoStatsPool("RkAiqAtmoStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
2601 mAiqIspTmoParamsPool =
2602 new RkAiqIspTmoParamsPool("RkAiqIspTmoParams", RkAiqCore::DEFAULT_POOL_SIZE);
2603 #endif
2604 break;
2605 case RK_AIQ_ALGO_TYPE_ACCM:
2606 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2607 mAiqIspCcmV32ParamsPool = new RkAiqIspCcmParamsPoolV32("RkAiqIspCcmV32Params", RkAiqCore::DEFAULT_POOL_SIZE);
2608 #else
2609 mAiqIspCcmParamsPool = new RkAiqIspCcmParamsPool("RkAiqIspCcmParams", RkAiqCore::DEFAULT_POOL_SIZE);
2610 #endif
2611 break;
2612 case RK_AIQ_ALGO_TYPE_ALSC:
2613 mAiqIspLscParamsPool = new RkAiqIspLscParamsPool("RkAiqIspLscParams", RkAiqCore::DEFAULT_POOL_SIZE);
2614 break;
2615 case RK_AIQ_ALGO_TYPE_ABLC:
2616 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2617 mAiqIspBlcV32ParamsPool = new RkAiqIspBlcParamsPoolV32("RkAiqIspBlcV32Params", RkAiqCore::DEFAULT_POOL_SIZE);
2618 #elif defined(ISP_HW_V21) || defined(ISP_HW_V30)
2619 mAiqIspBlcV21ParamsPool = new RkAiqIspBlcParamsPoolV21("RkAiqIspBlcParamsV21", RkAiqCore::DEFAULT_POOL_SIZE);
2620 #else
2621 mAiqIspBlcParamsPool = new RkAiqIspBlcParamsPool("RkAiqIspBlcParams", RkAiqCore::DEFAULT_POOL_SIZE);
2622 #endif
2623 break;
2624 case RK_AIQ_ALGO_TYPE_ARAWNR:
2625 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2626 mAiqIspBaynrV32ParamsPool = new RkAiqIspBaynrParamsPoolV32("RkAiqIspRawnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
2627 #elif defined(ISP_HW_V30)
2628 mAiqIspBaynrV3xParamsPool = new RkAiqIspBaynrParamsPoolV3x("RkAiqIspRawnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
2629 #elif defined(ISP_HW_V21)
2630 mAiqIspBaynrV21ParamsPool = new RkAiqIspBaynrParamsPoolV21("RkAiqIspRawnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
2631 #else
2632 mAiqIspRawnrParamsPool = new RkAiqIspRawnrParamsPool("RkAiqIspRawnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
2633 #endif
2634 break;
2635 case RK_AIQ_ALGO_TYPE_AGIC:
2636 mAiqIspGicParamsPool = new RkAiqIspGicParamsPool("RkAiqIspGicParams", RkAiqCore::DEFAULT_POOL_SIZE);
2637 break;
2638 case RK_AIQ_ALGO_TYPE_ADEBAYER:
2639 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2640 mAiqIspDebayerV32ParamsPool = new RkAiqIspDebayerParamsPoolV32("RkAiqIspDebayerParams", RkAiqCore::DEFAULT_POOL_SIZE);
2641 #else
2642 mAiqIspDebayerParamsPool = new RkAiqIspDebayerParamsPool("RkAiqIspDebayerParams", RkAiqCore::DEFAULT_POOL_SIZE);
2643 #endif
2644 break;
2645 case RK_AIQ_ALGO_TYPE_ALDCH:
2646 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2647 mAiqIspLdchV32ParamsPool = new RkAiqIspLdchParamsPoolV32("RkAiqIspLdchParams", RkAiqCore::DEFAULT_POOL_SIZE);
2648 #else
2649 mAiqIspLdchParamsPool = new RkAiqIspLdchParamsPool("RkAiqIspLdchParams", RkAiqCore::DEFAULT_POOL_SIZE);
2650 #endif
2651 break;
2652 case RK_AIQ_ALGO_TYPE_A3DLUT:
2653 mAiqIspLut3dParamsPool = new RkAiqIspLut3dParamsPool("RkAiqIspLut3dParams", RkAiqCore::DEFAULT_POOL_SIZE);
2654 break;
2655 case RK_AIQ_ALGO_TYPE_ADHAZ:
2656 if (!mAiqAdehazeStatsPool.ptr())
2657 mAiqAdehazeStatsPool = new RkAiqAdehazeStatsPool("RkAiqAdehazeStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
2658 mAiqIspDehazeParamsPool = new RkAiqIspDehazeParamsPool(
2659 "RkAiqIspDehazeParams", RkAiqCore::DEFAULT_POOL_SIZE);
2660 break;
2661 case RK_AIQ_ALGO_TYPE_AGAMMA:
2662 mAiqIspAgammaParamsPool = new RkAiqIspAgammaParamsPool("RkAiqIspAgammaParams", RkAiqCore::DEFAULT_POOL_SIZE);
2663 break;
2664 case RK_AIQ_ALGO_TYPE_ADEGAMMA:
2665 mAiqIspAdegammaParamsPool = new RkAiqIspAdegammaParamsPool("RkAiqIspAdegammaParams", RkAiqCore::DEFAULT_POOL_SIZE);
2666 break;
2667 case RK_AIQ_ALGO_TYPE_AWDR:
2668 mAiqIspWdrParamsPool = new RkAiqIspWdrParamsPool("RkAiqIspWdrParams", RkAiqCore::DEFAULT_POOL_SIZE);
2669 break;
2670 case RK_AIQ_ALGO_TYPE_ACSM:
2671 mAiqIspCsmParamsPool = new RkAiqIspCsmParamsPool("RkAiqIspCsmParams", RkAiqCore::DEFAULT_POOL_SIZE);
2672 break;
2673 case RK_AIQ_ALGO_TYPE_ACGC:
2674 mAiqIspCgcParamsPool = new RkAiqIspCgcParamsPool("RkAiqIspCgcParams", RkAiqCore::DEFAULT_POOL_SIZE);
2675 break;
2676 case RK_AIQ_ALGO_TYPE_AGAIN:
2677 #if defined(ISP_HW_V30) || defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2678 mAiqIspGainV3xParamsPool = new RkAiqIspGainParamsPoolV3x("RkAiqIspGainV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
2679 #else
2680 mAiqIspGainParamsPool = new RkAiqIspGainParamsPool("RkAiqIspGainParams", RkAiqCore::DEFAULT_POOL_SIZE);
2681 #endif
2682 break;
2683 case RK_AIQ_ALGO_TYPE_ACP:
2684 mAiqIspCpParamsPool = new RkAiqIspCpParamsPool("RkAiqIspCpParams", RkAiqCore::DEFAULT_POOL_SIZE);
2685 break;
2686 case RK_AIQ_ALGO_TYPE_AIE:
2687 mAiqIspIeParamsPool = new RkAiqIspIeParamsPool("RkAiqIspIeParams", RkAiqCore::DEFAULT_POOL_SIZE);
2688 break;
2689 case RK_AIQ_ALGO_TYPE_AMD:
2690 mAiqIspMdParamsPool = new RkAiqIspMdParamsPool("RkAiqIspMdParams", RkAiqCore::DEFAULT_POOL_SIZE);
2691 break;
2692 case RK_AIQ_ALGO_TYPE_AMFNR:
2693 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2694 mAiqIspTnrV32ParamsPool = new RkAiqIspTnrParamsPoolV32("RkAiqIspTnrV32Params", RkAiqCore::DEFAULT_POOL_SIZE);
2695 #elif defined(ISP_HW_V30)
2696 mAiqIspTnrV3xParamsPool = new RkAiqIspTnrParamsPoolV3x("RkAiqIspTnrV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
2697 #else
2698 mAiqIspTnrParamsPool = new RkAiqIspTnrParamsPool("RkAiqIspTnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
2699 #endif
2700 break;
2701 case RK_AIQ_ALGO_TYPE_AYNR:
2702 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2703 mAiqIspYnrV32ParamsPool = new RkAiqIspYnrParamsPoolV32("RkAiqIspYnrV32Params", RkAiqCore::DEFAULT_POOL_SIZE);
2704 #elif defined(ISP_HW_V30)
2705 mAiqIspYnrV3xParamsPool = new RkAiqIspYnrParamsPoolV3x("RkAiqIspYnrV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
2706 #elif defined(ISP_HW_V21)
2707 mAiqIspYnrV21ParamsPool = new RkAiqIspYnrParamsPoolV21("RkAiqIspYnrV21Params", RkAiqCore::DEFAULT_POOL_SIZE);
2708 #else
2709 mAiqIspYnrParamsPool = new RkAiqIspYnrParamsPool("RkAiqIspYnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
2710 #endif
2711 break;
2712 case RK_AIQ_ALGO_TYPE_ACNR:
2713 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2714 mAiqIspCnrV32ParamsPool = new RkAiqIspCnrParamsPoolV32("RkAiqIspCnrV32Params", RkAiqCore::DEFAULT_POOL_SIZE);
2715 #elif defined(ISP_HW_V30)
2716 mAiqIspCnrV3xParamsPool = new RkAiqIspCnrParamsPoolV3x("RkAiqIspCnrV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
2717 #elif defined(ISP_HW_V21)
2718 mAiqIspCnrV21ParamsPool = new RkAiqIspCnrParamsPoolV21("RkAiqIspCnrV21Params", RkAiqCore::DEFAULT_POOL_SIZE);
2719 #else
2720 mAiqIspUvnrParamsPool = new RkAiqIspUvnrParamsPool("RkAiqIspUvnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
2721 #endif
2722 break;
2723 case RK_AIQ_ALGO_TYPE_ASHARP:
2724 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
2725 mAiqIspSharpV32ParamsPool = new RkAiqIspSharpParamsPoolV32("RkAiqIspSharpV32Params", RkAiqCore::DEFAULT_POOL_SIZE);
2726 #elif defined(ISP_HW_V30)
2727 mAiqIspSharpenV3xParamsPool = new RkAiqIspSharpenParamsPoolV3x("RkAiqIspSharpenV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
2728 #elif defined(ISP_HW_V21)
2729 mAiqIspSharpenV21ParamsPool = new RkAiqIspSharpenParamsPoolV21("RkAiqIspSharpenV21Params", RkAiqCore::DEFAULT_POOL_SIZE);
2730 #else
2731 mAiqIspSharpenParamsPool = new RkAiqIspSharpenParamsPool("RkAiqIspSharpenParams", RkAiqCore::DEFAULT_POOL_SIZE);
2732 mAiqIspEdgefltParamsPool = new RkAiqIspEdgefltParamsPool("RkAiqIspEdgefltParams", RkAiqCore::DEFAULT_POOL_SIZE);
2733 #endif
2734 break;
2735 #if RKAIQ_HAVE_ORB_V1
2736 case RK_AIQ_ALGO_TYPE_AORB:
2737 if (!mAiqOrbStatsIntPool.ptr())
2738 mAiqOrbStatsIntPool =
2739 new RkAiqOrbStatsPool("RkAiqOrbStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
2740 mAiqIspOrbParamsPool =
2741 new RkAiqIspOrbParamsPool("RkAiqIspOrbParams", RkAiqCore::DEFAULT_POOL_SIZE);
2742 break;
2743 #endif
2744 case RK_AIQ_ALGO_TYPE_AFEC:
2745 case RK_AIQ_ALGO_TYPE_AEIS:
2746 mAiqIspFecParamsPool = new RkAiqIspFecParamsPool("RkAiqIspFecParams", RkAiqCore::DEFAULT_POOL_SIZE);
2747 break;
2748 case RK_AIQ_ALGO_TYPE_ACAC:
2749 #if RKAIQ_HAVE_CAC_V11
2750 mAiqIspCacV32ParamsPool = new RkAiqIspCacParamsPoolV32("RkAiqIspCacV32Params", RkAiqCore::DEFAULT_POOL_SIZE);
2751 #elif RKAIQ_HAVE_CAC_V10 || RKAIQ_HAVE_CAC_V03
2752 mAiqIspCacV3xParamsPool = new RkAiqIspCacParamsPoolV3x("RkAiqIspCacV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
2753 #endif
2754 break;
2755 case RK_AIQ_ALGO_TYPE_ADRC:
2756 mAiqIspDrcParamsPool = new RkAiqIspDrcParamsPool("RkAiqIspDrcParamsPool", RkAiqCore::DEFAULT_POOL_SIZE);
2757 break;
2758 case RK_AIQ_ALGO_TYPE_AFD:
2759 mAiqIspAfdParamsPool = new RkAiqIspAfdParamsPool("RkAiqIspAfdParams", RkAiqCore::DEFAULT_POOL_SIZE);
2760 break;
2761 default:
2762 break;
2763 }
2764 }
2765 }
2766 }
2767
2768 #if RKAIQ_HAVE_PDAF
newPdafStatsPool()2769 void RkAiqCore::newPdafStatsPool() {
2770 if (!mAiqPdafStatsPool.ptr())
2771 return;
2772 const CamCalibDbContext_t* aiqCalib = mAlogsComSharedParams.calibv2;
2773 uint32_t max_cnt = mAiqPdafStatsPool->get_free_buffer_size();
2774 SmartPtr<RkAiqPdafStatsProxy> pdafStats = NULL;
2775 CalibDbV2_Af_Pdaf_t* pdaf = NULL;
2776 int pd_size = 0;
2777
2778 if (CHECK_ISP_HW_V30()) {
2779 CalibDbV2_AFV30_t* af_v30 =
2780 (CalibDbV2_AFV30_t*)(CALIBDBV2_GET_MODULE_PTR((void*)aiqCalib, af_v30));
2781 pdaf = &af_v30->TuningPara.pdaf;
2782 pd_size = pdaf->pdMaxWidth * pdaf->pdMaxHeight * sizeof(short);
2783 }
2784
2785 if (pd_size > 0 && pdaf && pdaf->enable) {
2786 for (uint32_t i = 0; i < max_cnt; i++) {
2787 pdafStats = mAiqPdafStatsPool->get_item();
2788
2789 rk_aiq_isp_pdaf_stats_t* pdaf_stats = &pdafStats->data().ptr()->pdaf_stats;
2790 pdaf_stats->pdWidth = pdaf->pdMaxWidth;
2791 pdaf_stats->pdHeight = pdaf->pdMaxHeight;
2792 pdaf_stats->pdLData = (unsigned short*)malloc(pd_size);
2793 pdaf_stats->pdRData = (unsigned short*)malloc(pd_size);
2794 }
2795 } else {
2796 for (uint32_t i = 0; i < max_cnt; i++) {
2797 pdafStats = mAiqPdafStatsPool->get_item();
2798
2799 rk_aiq_isp_pdaf_stats_t* pdaf_stats = &pdafStats->data().ptr()->pdaf_stats;
2800 pdaf_stats->pdLData = NULL;
2801 pdaf_stats->pdRData = NULL;
2802 }
2803 }
2804 }
2805
delPdafStatsPool()2806 void RkAiqCore::delPdafStatsPool() {
2807 if (!mAiqPdafStatsPool.ptr())
2808 return;
2809 SmartPtr<RkAiqPdafStatsProxy> pdafStats = NULL;
2810 uint32_t max_cnt = mAiqPdafStatsPool->get_free_buffer_size();
2811 rk_aiq_isp_pdaf_stats_t* pdaf_stats;
2812
2813 for (uint32_t i = 0; i < max_cnt; i++) {
2814 pdafStats = mAiqPdafStatsPool->get_item();
2815 pdaf_stats = &pdafStats->data().ptr()->pdaf_stats;
2816
2817 if (pdaf_stats->pdLData) {
2818 free(pdaf_stats->pdLData);
2819 pdaf_stats->pdLData = NULL;
2820 }
2821 if (pdaf_stats->pdRData) {
2822 free(pdaf_stats->pdRData);
2823 pdaf_stats->pdRData = NULL;
2824 }
2825 }
2826
2827 if (mPdafStats.ptr()) {
2828 if (mPdafStats->data().ptr()) {
2829 pdaf_stats = &mPdafStats->data().ptr()->pdaf_stats;
2830 if (pdaf_stats->pdLData) {
2831 free(pdaf_stats->pdLData);
2832 pdaf_stats->pdLData = NULL;
2833 }
2834 if (pdaf_stats->pdRData) {
2835 free(pdaf_stats->pdRData);
2836 pdaf_stats->pdRData = NULL;
2837 }
2838 }
2839 }
2840 }
2841 #endif
2842
2843 #if defined(RKAIQ_HAVE_THUMBNAILS)
onThumbnailsResult(const rkaiq_thumbnails_t & thumbnail)2844 void RkAiqCore::onThumbnailsResult(const rkaiq_thumbnails_t& thumbnail) {
2845 LOGV_ANALYZER("Callback thumbnail : id:%d, type:%d, 1/%dx1/%d, %dx%d", thumbnail.frame_id,
2846 thumbnail.config.stream_type, thumbnail.config.width_intfactor,
2847 thumbnail.config.height_intfactor, thumbnail.buffer->info.width,
2848 thumbnail.buffer->info.height);
2849 #if 0
2850 thumbnail.buffer->ref(thumbnail.buffer);
2851 if (thumbnail.frame_id == 1) {
2852 char* ptr = reinterpret_cast<char*>(thumbnail.buffer->map(thumbnail.buffer));
2853 size_t size = thumbnail.buffer->info.size;
2854 std::string path = "/data/thumbnails_";
2855 path.append(std::to_string(thumbnail.frame_id));
2856 path.append("_");
2857 path.append(std::to_string(thumbnail.buffer->info.width));
2858 path.append("x");
2859 path.append(std::to_string(thumbnail.buffer->info.height));
2860 path.append(".yuv");
2861 std::ofstream ofs(path, std::ios::binary);
2862 ofs.write(ptr, size);
2863 thumbnail.buffer->unmap(thumbnail.buffer);
2864 }
2865 thumbnail.buffer->unref(thumbnail.buffer);
2866 #endif
2867 }
2868 #endif
2869
2870 int32_t
getGroupId(RkAiqAlgoType_t type)2871 RkAiqCore::getGroupId(RkAiqAlgoType_t type)
2872 {
2873 auto mapIter = mAlgoTypeToGrpMaskMap.find(type);
2874 if (mapIter != mAlgoTypeToGrpMaskMap.end()) {
2875 return mapIter->second;
2876 } else {
2877 LOGW_ANALYZER("don't find the group id of module(0x%x)", type);
2878 return XCAM_RETURN_ERROR_FAILED;
2879 }
2880 }
2881
2882 XCamReturn
getGroupSharedParams(uint64_t groupId,RkAiqAlgosGroupShared_t * & shared)2883 RkAiqCore::getGroupSharedParams(uint64_t groupId, RkAiqAlgosGroupShared_t* &shared)
2884 {
2885 auto mapIter = mAlogsGroupSharedParamsMap.find(groupId);
2886 if (mapIter != mAlogsGroupSharedParamsMap.end()) {
2887 shared = mapIter->second;
2888 } else {
2889 LOGW_ANALYZER("don't find the group shared params of group(0x%llx)", groupId);
2890 return XCAM_RETURN_ERROR_FAILED;
2891 }
2892
2893 return XCAM_RETURN_NO_ERROR;
2894 }
2895
handleIspStats(const SmartPtr<VideoBuffer> & buffer,const SmartPtr<RkAiqAecStatsProxy> & aecStat,const SmartPtr<RkAiqAwbStatsProxy> & awbStat,const SmartPtr<RkAiqAfStatsProxy> & afStat,const SmartPtr<RkAiqAtmoStatsProxy> & tmoStat,const SmartPtr<RkAiqAdehazeStatsProxy> & dehazeStat)2896 XCamReturn RkAiqCore::handleIspStats(const SmartPtr<VideoBuffer>& buffer,
2897 const SmartPtr<RkAiqAecStatsProxy>& aecStat,
2898 const SmartPtr<RkAiqAwbStatsProxy>& awbStat,
2899 const SmartPtr<RkAiqAfStatsProxy>& afStat,
2900 const SmartPtr<RkAiqAtmoStatsProxy>& tmoStat,
2901 const SmartPtr<RkAiqAdehazeStatsProxy>& dehazeStat) {
2902 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2903 SmartPtr<RkAiqIspStatsIntProxy> ispStatsInt = NULL;
2904
2905 if (mAiqIspStatsIntPool->has_free_items()) {
2906 ispStatsInt = mAiqIspStatsIntPool->get_item();
2907 } else {
2908 LOGE_ANALYZER("no free ispStatsInt!");
2909 return XCAM_RETURN_BYPASS;
2910 }
2911
2912 ret = mTranslator->translateIspStats(buffer, ispStatsInt, aecStat, awbStat, afStat, tmoStat,
2913 dehazeStat);
2914 if (ret) {
2915 LOGE_ANALYZER("translate isp stats failed!");
2916 return XCAM_RETURN_BYPASS;
2917 }
2918
2919 uint32_t id = buffer->get_sequence();
2920 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_ISP_STATS_OK,
2921 id, ispStatsInt);
2922 post_message(msg);
2923
2924 return XCAM_RETURN_NO_ERROR;
2925 }
2926
2927 XCamReturn
handleAecStats(const SmartPtr<VideoBuffer> & buffer,SmartPtr<RkAiqAecStatsProxy> & aecStat_ret)2928 RkAiqCore::handleAecStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAecStatsProxy>& aecStat_ret)
2929 {
2930 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2931 SmartPtr<RkAiqAecStatsProxy> aecStats = NULL;
2932
2933 if (!mAiqAecStatsPool.ptr()) {
2934 return XCAM_RETURN_BYPASS;
2935 } else if (mAiqAecStatsPool->has_free_items()) {
2936 aecStats = mAiqAecStatsPool->get_item();
2937 } else {
2938 LOGW_AEC("no free aecStats buffer!");
2939 ret = XCAM_RETURN_BYPASS;
2940 goto out;
2941 }
2942 ret = mTranslator->translateAecStats(buffer, aecStats);
2943 if (ret < 0) {
2944 LOGE_ANALYZER("translate aec stats failed!");
2945 aecStats = NULL;
2946 ret = XCAM_RETURN_BYPASS;
2947 }
2948
2949 out:
2950 aecStat_ret = aecStats;
2951
2952 uint32_t id = buffer->get_sequence();
2953 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_AEC_STATS_OK,
2954 id, aecStats);
2955 post_message(msg);
2956
2957 return XCAM_RETURN_NO_ERROR;
2958 }
2959
2960 XCamReturn
handleAwbStats(const SmartPtr<VideoBuffer> & buffer,SmartPtr<RkAiqAwbStatsProxy> & awbStat_ret)2961 RkAiqCore::handleAwbStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAwbStatsProxy>& awbStat_ret)
2962 {
2963 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2964 SmartPtr<RkAiqAwbStatsProxy> awbStats = NULL;
2965
2966 if (!mAiqAwbStatsPool.ptr()) {
2967 return XCAM_RETURN_BYPASS;
2968 } else if (mAiqAwbStatsPool->has_free_items()) {
2969 awbStats = mAiqAwbStatsPool->get_item();
2970 } else {
2971 LOGW_AWB("no free awbStats buffer!");
2972 ret = XCAM_RETURN_BYPASS;
2973 goto out;
2974 }
2975 ret = mTranslator->translateAwbStats(buffer, awbStats);
2976 if (ret < 0) {
2977 LOGE_ANALYZER("translate awb stats failed!");
2978 awbStats = NULL;
2979 ret = XCAM_RETURN_BYPASS;
2980 }
2981
2982 out:
2983 awbStat_ret = awbStats;
2984
2985 uint32_t id = buffer->get_sequence();
2986 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_AWB_STATS_OK,
2987 id, awbStats);
2988 post_message(msg);
2989
2990 return ret;
2991 }
2992
2993 XCamReturn
handleAfStats(const SmartPtr<VideoBuffer> & buffer,SmartPtr<RkAiqAfStatsProxy> & afStat_ret)2994 RkAiqCore::handleAfStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAfStatsProxy>& afStat_ret)
2995 {
2996 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2997 SmartPtr<RkAiqAfStatsProxy> afStats = NULL;
2998
2999 if (!mAiqAfStatsPool.ptr()) {
3000 return XCAM_RETURN_BYPASS;
3001 } else if (mAiqAfStatsPool->has_free_items()) {
3002 afStats = mAiqAfStatsPool->get_item();
3003 } else {
3004 LOGW_AF("no free afStats buffer!");
3005 ret = XCAM_RETURN_BYPASS;
3006 goto out;
3007 }
3008 ret = mTranslator->translateAfStats(buffer, afStats);
3009 if (ret < 0) {
3010 LOGE_ANALYZER("translate af stats failed!");
3011 afStats = NULL;
3012 ret = XCAM_RETURN_BYPASS;
3013 }
3014
3015 out:
3016 afStat_ret = afStats;
3017 if (mPdafSupport) {
3018 mAfStats = afStats;
3019 mAfStatsFrmId = buffer->get_sequence();
3020 mAfStatsTime = buffer->get_timestamp();
3021 if (((ABS(mAfStatsTime - mPdafStatsTime) < mFrmInterval / 2LL) && mIspOnline) ||
3022 ((mAfStatsTime - mPdafStatsTime < mFrmInterval) && (mAfStatsTime >= mPdafStatsTime) && !mIspOnline)) {
3023 RkAiqCoreVdBufMsg afStatsMsg (XCAM_MESSAGE_AF_STATS_OK, mAfStatsFrmId, mAfStats);
3024 RkAiqCoreVdBufMsg pdafStatsMsg (XCAM_MESSAGE_PDAF_STATS_OK, mAfStatsFrmId, mPdafStats);
3025 post_message(afStatsMsg);
3026 post_message(pdafStatsMsg);
3027 mAfStats = NULL;
3028 mPdafStats = NULL;
3029 }
3030 } else {
3031 uint32_t id = buffer->get_sequence();
3032 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_AF_STATS_OK, id, afStats);
3033 post_message(msg);
3034 }
3035
3036 return ret;
3037 }
3038
3039 #if RKAIQ_HAVE_PDAF
handlePdafStats(const SmartPtr<VideoBuffer> & buffer)3040 XCamReturn RkAiqCore::handlePdafStats(const SmartPtr<VideoBuffer>& buffer) {
3041 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3042 SmartPtr<RkAiqPdafStatsProxy> pdafStats = NULL;
3043 bool sns_mirror = mAlogsComSharedParams.sns_mirror;
3044
3045 if (mAiqPdafStatsPool->has_free_items()) {
3046 pdafStats = mAiqPdafStatsPool->get_item();
3047 } else {
3048 LOGE_ANALYZER("no free afStats buffer!");
3049 return XCAM_RETURN_BYPASS;
3050 }
3051 ret = mTranslator->translatePdafStats(buffer, pdafStats, sns_mirror);
3052 if (ret < 0) {
3053 LOGE_ANALYZER("translate af stats failed!");
3054 return XCAM_RETURN_BYPASS;
3055 }
3056
3057 mPdafStats = pdafStats;
3058 mPdafStatsTime = buffer->get_timestamp();
3059 if (((ABS(mAfStatsTime - mPdafStatsTime) < mFrmInterval / 2LL) && mIspOnline) ||
3060 ((mAfStatsTime - mPdafStatsTime < mFrmInterval) && (mAfStatsTime >= mPdafStatsTime) && !mIspOnline)) {
3061 RkAiqCoreVdBufMsg afStatsMsg (XCAM_MESSAGE_AF_STATS_OK, mAfStatsFrmId, mAfStats);
3062 RkAiqCoreVdBufMsg pdafStatsMsg (XCAM_MESSAGE_PDAF_STATS_OK, mAfStatsFrmId, mPdafStats);
3063
3064 post_message(afStatsMsg);
3065 post_message(pdafStatsMsg);
3066 mAfStats = NULL;
3067 mPdafStats = NULL;
3068 }
3069
3070 return XCAM_RETURN_NO_ERROR;
3071 }
3072 #endif
3073
handleAtmoStats(const SmartPtr<VideoBuffer> & buffer,SmartPtr<RkAiqAtmoStatsProxy> & tmoStat)3074 XCamReturn RkAiqCore::handleAtmoStats(const SmartPtr<VideoBuffer>& buffer,
3075 SmartPtr<RkAiqAtmoStatsProxy>& tmoStat) {
3076 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3077
3078 if (!mAiqAtmoStatsPool.ptr()) {
3079 return XCAM_RETURN_BYPASS;
3080 } else if (mAiqAtmoStatsPool->has_free_items()) {
3081 tmoStat = mAiqAtmoStatsPool->get_item();
3082 } else {
3083 LOGW_ATMO("no free atmoStats buffer!");
3084 ret = XCAM_RETURN_BYPASS;
3085 goto out;
3086 }
3087 ret = mTranslator->translateAtmoStats(buffer, tmoStat);
3088 if (ret < 0) {
3089 LOGE_ANALYZER("translate tmo stats failed!");
3090 tmoStat = NULL;
3091 ret = XCAM_RETURN_BYPASS;
3092 }
3093
3094 out:
3095 uint32_t id = buffer->get_sequence();
3096 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_ATMO_STATS_OK,
3097 id, tmoStat);
3098 post_message(msg);
3099
3100 return ret;
3101 }
3102
handleAdehazeStats(const SmartPtr<VideoBuffer> & buffer,SmartPtr<RkAiqAdehazeStatsProxy> & dehazeStat)3103 XCamReturn RkAiqCore::handleAdehazeStats(const SmartPtr<VideoBuffer>& buffer,
3104 SmartPtr<RkAiqAdehazeStatsProxy>& dehazeStat) {
3105 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3106
3107 if (!mAiqAdehazeStatsPool.ptr()) {
3108 return XCAM_RETURN_BYPASS;
3109 } else if (mAiqAdehazeStatsPool->has_free_items()) {
3110 dehazeStat = mAiqAdehazeStatsPool->get_item();
3111 } else {
3112 LOGW_ADEHAZE("no free adehazeStats buffer!");
3113 ret = XCAM_RETURN_BYPASS;
3114 goto out;
3115 }
3116 ret = mTranslator->translateAdehazeStats(buffer, dehazeStat);
3117 if (ret < 0) {
3118 LOGE_ANALYZER("translate dehaze stats failed!");
3119 dehazeStat = NULL;
3120 ret = XCAM_RETURN_BYPASS;
3121 }
3122
3123 out:
3124 uint32_t id = buffer->get_sequence();
3125 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_ADEHAZE_STATS_OK,
3126 id, dehazeStat);
3127 post_message(msg);
3128
3129 return ret;
3130 }
3131
3132 XCamReturn
handleOrbStats(const SmartPtr<VideoBuffer> & buffer)3133 RkAiqCore::handleOrbStats(const SmartPtr<VideoBuffer> &buffer)
3134 {
3135 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3136 SmartPtr<RkAiqOrbStatsProxy> orbStats = NULL;
3137 if (!mAiqOrbStatsIntPool.ptr()) {
3138 return XCAM_RETURN_BYPASS;
3139 } else if (mAiqOrbStatsIntPool->has_free_items()) {
3140 orbStats = mAiqOrbStatsIntPool->get_item();
3141 } else {
3142 LOGW_AORB("no free orbStats!");
3143 ret = XCAM_RETURN_BYPASS;
3144 goto out;
3145 }
3146
3147 ret = mTranslator->translateOrbStats(buffer, orbStats);
3148 if (ret) {
3149 orbStats = NULL;
3150 return XCAM_RETURN_BYPASS;
3151 }
3152
3153 out:
3154 uint32_t id = buffer->get_sequence();
3155 orbStats->setId(id);
3156 orbStats->setType(RK_AIQ_SHARED_TYPE_ORB_STATS);
3157 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_ORB_STATS_OK,
3158 id, orbStats);
3159 post_message(msg);
3160
3161 return XCAM_RETURN_NO_ERROR;
3162 }
3163
3164 XCamReturn
handleVicapScaleBufs(const SmartPtr<VideoBuffer> & buffer)3165 RkAiqCore::handleVicapScaleBufs(const SmartPtr<VideoBuffer> &buffer)
3166 {
3167 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3168 V4l2BufferProxy* buf_proxy = buffer.get_cast_ptr<V4l2BufferProxy>();
3169 int *reserved = (int *)buf_proxy->get_reserved();
3170 int raw_index = reserved[0];
3171 int bpp = reserved[1];
3172 int mode = mAlogsComSharedParams.working_mode;
3173 uint32_t frameId = buffer->get_sequence();
3174 if (!mVicapBufs.ptr()) {
3175 mVicapBufs = new RkAiqVicapRawBuf_t;
3176 } else if (frameId > mVicapBufs->info.frame_id && mVicapBufs->info.flags != 0) {
3177 LOGE_ANALYZER("frame id: %d buf flags: %#x scale raw buf unready and force to release\n",
3178 mVicapBufs->info.frame_id,
3179 mVicapBufs->info.flags);
3180 mVicapBufs.release();
3181 mVicapBufs = new RkAiqVicapRawBuf_t;
3182 } else if (mVicapBufs->info.frame_id != (uint32_t)(-1) && mVicapBufs->info.flags == 0) {
3183 mVicapBufs->info.reset();
3184 } else {
3185 LOGE_ANALYZER("frame id: %d raw index %d scale raw buf is unneeded by mVicapBufs\n",
3186 mVicapBufs->info.frame_id,
3187 raw_index);
3188 return XCAM_RETURN_NO_ERROR;
3189 }
3190 if (mode == RK_AIQ_WORKING_MODE_NORMAL) {
3191 mVicapBufs->info.frame_id = buffer->get_sequence();
3192 mVicapBufs->info.raw_s = buffer;
3193 mVicapBufs->info.ready = true;
3194 mVicapBufs->info.flags = mVicapBufs->info.flags | (1 << raw_index);
3195 } else if (mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
3196 mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
3197 mVicapBufs->info.frame_id = buffer->get_sequence();
3198 if (raw_index == 0) {
3199 mVicapBufs->info.raw_l = buffer;
3200 mVicapBufs->info.flags = mVicapBufs->info.flags | (1 << raw_index);
3201 } else if (raw_index == 1) {
3202 mVicapBufs->info.raw_s = buffer;
3203 mVicapBufs->info.flags = mVicapBufs->info.flags | (1 << raw_index);
3204 }
3205 if (!(mVicapBufs->info.flags ^ RK_AIQ_VICAP_SCALE_HDR_MODE_2_HDR)) {
3206 mVicapBufs->info.ready = true;
3207 }
3208 } else if (mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
3209 mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
3210 mVicapBufs->info.frame_id = buffer->get_sequence();
3211 if (raw_index == 0) {
3212 mVicapBufs->info.raw_l = buffer;
3213 mVicapBufs->info.flags = mVicapBufs->info.flags | (1 << raw_index);
3214 } else if (raw_index == 1) {
3215 mVicapBufs->info.raw_m = buffer;
3216 mVicapBufs->info.flags = mVicapBufs->info.flags | (1 << raw_index);
3217 } else if (raw_index == 2) {
3218 mVicapBufs->info.raw_s = buffer;
3219 mVicapBufs->info.flags = mVicapBufs->info.flags | (1 << raw_index);
3220 }
3221 if (!(mVicapBufs->info.flags ^ RK_AIQ_VICAP_SCALE_HDR_MODE_3_HDR)) {
3222 mVicapBufs->info.ready = true;
3223 }
3224 }
3225 if (mVicapBufs->info.ready && mVicapBufs->info.frame_id > 2) {
3226 mVicapBufs->info.bpp = bpp;
3227 SmartPtr<BufferProxy> bp = new BufferProxy(mVicapBufs);
3228 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_VICAP_POLL_SCL_OK,
3229 mVicapBufs->info.frame_id, bp);
3230 post_message(msg);
3231 mVicapBufs.release();
3232 }
3233 return ret;
3234 }
3235
3236
set_sp_resolution(int & width,int & height,int & aligned_w,int & aligned_h)3237 XCamReturn RkAiqCore::set_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h)
3238 {
3239 mSpWidth = width;
3240 mSpHeight = height;
3241 mSpAlignedWidth = aligned_w;
3242 mSpAlignedHeight = aligned_h;
3243 return XCAM_RETURN_NO_ERROR;
3244 }
3245
3246 #if RKAIQ_HAVE_PDAF
3247 XCamReturn
set_pdaf_support(bool support)3248 RkAiqCore::set_pdaf_support(bool support)
3249 {
3250 mPdafSupport = support;
3251 return XCAM_RETURN_NO_ERROR;
3252 }
3253
get_pdaf_support()3254 bool RkAiqCore::get_pdaf_support()
3255 {
3256 return mPdafSupport;
3257 }
3258 #endif
3259
3260 XCamReturn
newAiqGroupAnayzer()3261 RkAiqCore::newAiqGroupAnayzer()
3262 {
3263 mRkAiqCoreGroupManager = new RkAiqAnalyzeGroupManager(this, mIsSingleThread);
3264 mRkAiqCoreGroupManager->parseAlgoGroup(mAlgosDesArray);
3265 std::map<uint64_t, SmartPtr<RkAiqAnalyzerGroup>> groupMaps =
3266 mRkAiqCoreGroupManager->getGroups();
3267
3268 for (auto it : groupMaps) {
3269 LOGI_ANALYZER("req >>>>> : 0x%llx", it.first);
3270 mFullParamReqGroupsMasks |= 1ULL << it.first;
3271 }
3272
3273 return XCAM_RETURN_NO_ERROR;
3274 }
3275
updateCalibDbBrutal(CamCalibDbV2Context_t * aiqCalib)3276 XCamReturn RkAiqCore::updateCalibDbBrutal(CamCalibDbV2Context_t* aiqCalib)
3277 {
3278 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3279
3280 // Fill new calib to the AlogsSharedParams
3281 mAlogsComSharedParams.calibv2 = aiqCalib;
3282 mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_UPDATECALIB;
3283
3284 #if RKAIQ_HAVE_ASD_V10
3285 initCpsl();
3286 #endif
3287 CalibDbV2_ColorAsGrey_t* colorAsGrey =
3288 (CalibDbV2_ColorAsGrey_t*)CALIBDBV2_GET_MODULE_PTR(
3289 (void*)(mAlogsComSharedParams.calibv2), colorAsGrey);
3290 if (colorAsGrey->param.enable) {
3291 mGrayMode = RK_AIQ_GRAY_MODE_ON;
3292 mAlogsComSharedParams.gray_mode = true;
3293 } else {
3294 mGrayMode = RK_AIQ_GRAY_MODE_OFF;
3295 mAlogsComSharedParams.gray_mode = false;
3296 }
3297 setGrayMode(mGrayMode);
3298
3299 for (auto& algoHdl : mCurIspAlgoHandleList) {
3300 RkAiqHandle* curHdl = algoHdl.ptr();
3301 while (curHdl) {
3302 if (curHdl->getEnable()) {
3303 /* update user initial params */
3304 ret = curHdl->updateConfig(true);
3305 RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d update initial user params failed", curHdl->getAlgoType());
3306 algoHdl->setReConfig(true);
3307 ret = curHdl->prepare();
3308 RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d prepare failed", curHdl->getAlgoType());
3309 }
3310 curHdl = curHdl->getNextHdl();
3311 }
3312 }
3313
3314 mAlogsComSharedParams.conf_type &= ~RK_AIQ_ALGO_CONFTYPE_UPDATECALIB;
3315
3316 return XCAM_RETURN_NO_ERROR;
3317 }
3318
updateCalib(enum rk_aiq_core_analyze_type_e type)3319 XCamReturn RkAiqCore::updateCalib(enum rk_aiq_core_analyze_type_e type)
3320 {
3321 SmartLock lock (_update_mutex);
3322 // check if group bit still set
3323 uint64_t need_update = groupUpdateMask & grpId2GrpMask(type);
3324 if (!need_update) {
3325 return XCAM_RETURN_NO_ERROR;
3326 }
3327
3328 prepare(type);
3329 // clear group bit after update
3330 groupUpdateMask &= (~need_update);
3331 // notify update done
3332 _update_done_cond.broadcast();
3333
3334 return XCAM_RETURN_NO_ERROR;
3335 }
3336
notifyUpdate(uint64_t mask)3337 XCamReturn RkAiqCore::notifyUpdate(uint64_t mask)
3338 {
3339 SmartLock lock (_update_mutex);
3340
3341 groupUpdateMask |= mask;
3342
3343 return XCamReturn();
3344 }
3345
waitUpdateDone()3346 XCamReturn RkAiqCore::waitUpdateDone()
3347 {
3348 SmartLock lock (_update_mutex);
3349
3350 while (groupUpdateMask != 0) {
3351 _update_done_cond.timedwait(_update_mutex, 100000ULL);
3352 }
3353
3354 return XCamReturn();
3355 }
3356
setDelayCnts(int8_t delayCnts)3357 void RkAiqCore::setDelayCnts(int8_t delayCnts) {
3358 mRkAiqCoreGroupManager->setDelayCnts(delayCnts);
3359 }
3360
setVicapScaleFlag(bool mode)3361 void RkAiqCore::setVicapScaleFlag(bool mode) {
3362 auto its = mRkAiqCoreGroupManager->getGroups();
3363 for (auto& it : its) {
3364 if (it.second->getType() == RK_AIQ_CORE_ANALYZE_AFD) {
3365 uint64_t flag = it.second->getDepsFlag();
3366 if (mode)
3367 flag |= (1ULL << XCAM_MESSAGE_VICAP_POLL_SCL_OK);
3368 else
3369 flag &= ~(1ULL << XCAM_MESSAGE_VICAP_POLL_SCL_OK);
3370 it.second->setDepsFlagAndClearMap(flag);
3371 LOGD_ANALYZER("afd algo dep flag %llx\n", flag);
3372 }
3373 }
3374 }
3375
3376 } //namespace RkCam
3377