1 /*
2 * Copyright (c) 2021-2022 Rockchip Eletronics Co., Ltd.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "RkAiqCamGroupManager.h"
17
18 #include <thread>
19
20 #include "RkAiqCamGroupHandleInt.h"
21 #include "RkAiqManager.h"
22 #include "aiq_core/RkAiqCore.h"
23 #include "aiq_core/RkAiqCoreConfig.h"
24 #include "smart_buffer_priv.h"
25
26 namespace RkCam {
27
28 #define RKAIQ_MAX_GROUP_RES_COUNT 5
29
30 bool
loop()31 RkAiqCamGroupReprocTh::loop ()
32 {
33 const static int32_t timeout = -1;
34 XCamReturn ret = XCAM_RETURN_NO_ERROR;
35 SmartPtr<rk_aiq_groupcam_result_wrapper_t> camGroupRes_wrapper = mMsgQueue.pop (timeout);
36
37 if (!camGroupRes_wrapper.ptr()) {
38 return true;
39 }
40
41 rk_aiq_groupcam_result_t* camGroupRes = camGroupRes_wrapper->_gc_result;
42 if (camGroupRes->_ready) {
43 ret = mCamGroupManager->syncSingleCamResultWithMaster(camGroupRes);
44 if (ret < 0) {
45 LOGW_CAMGROUP("Failed to sync single cam result with master");
46 }
47
48 ret = mCamGroupManager->rePrepare();
49 ret = mCamGroupManager->reProcess(camGroupRes);
50 if (ret < 0) {
51 LOGW_CAMGROUP("reprocess error, ignore!");
52 } else
53 mCamGroupManager->relayToHwi(camGroupRes);
54 }
55 // delete the processed result
56 mCamGroupManager->putGroupCamResult(camGroupRes); // paired with sendFrame
57 mCamGroupManager->clearGroupCamResult(camGroupRes->_frameId);
58
59 return true;
60 }
61
62 bool
sendFrame(rk_aiq_groupcam_result_t * gc_result)63 RkAiqCamGroupReprocTh::sendFrame(rk_aiq_groupcam_result_t* gc_result)
64 {
65 {
66 SmartLock locker (mCamGroupManager->mCamGroupResMutex);
67 gc_result->_refCnt++;
68 }
69 mMsgQueue.push(new rk_aiq_groupcam_result_wrapper_t(gc_result));
70 return true;
71 };
72
RkAiqCamGroupManager()73 RkAiqCamGroupManager::RkAiqCamGroupManager()
74 {
75 ENTER_CAMGROUP_FUNCTION();
76 mCamGroupReprocTh = new RkAiqCamGroupReprocTh(this);
77 mRequiredMsgsMask = 1ULL << XCAM_MESSAGE_SOF_INFO_OK;
78 #if RKAIQ_HAVE_AE_V1
79 mRequiredMsgsMask |= (1ULL << XCAM_MESSAGE_AEC_STATS_OK) | (1ULL << XCAM_MESSAGE_AE_PRE_RES_OK);
80 #endif
81 #if RKAIQ_HAVE_AWB_V20 | RKAIQ_HAVE_AWB_V21 | RKAIQ_HAVE_AWB_V32
82 mRequiredMsgsMask |= (1ULL << XCAM_MESSAGE_AWB_STATS_OK) | (1ULL << XCAM_MESSAGE_AWB_PROC_RES_OK);
83 #endif
84
85 mGroupAlgosDesArray = g_camgroup_algos;
86 mState = CAMGROUP_MANAGER_INVALID;
87 mRequiredCamsResMask = 0;
88 mRequiredAlgoResMask = 0;
89 mInit = false;
90 mCamgroupCalib = NULL;
91 mVicapReadyMask = 0;
92 mClearedSofId = 0;
93 mClearedResultId = 0;
94 mGroupCtx = NULL;
95 needReprepare = false;
96
97 _sync_sof_running = false;
98
99 EXIT_CAMGROUP_FUNCTION();
100 }
101
~RkAiqCamGroupManager()102 RkAiqCamGroupManager::~RkAiqCamGroupManager()
103 {
104 ENTER_CAMGROUP_FUNCTION();
105 EXIT_CAMGROUP_FUNCTION();
106 }
107
108 rk_aiq_groupcam_result_t*
getGroupCamResult(uint32_t frameId,bool query_ready)109 RkAiqCamGroupManager::getGroupCamResult(uint32_t frameId, bool query_ready)
110 {
111 SmartLock locker (mCamGroupResMutex);
112 rk_aiq_groupcam_result_t* camGroupRes = NULL;
113
114 if (mCamGroupResMap.find(frameId) != mCamGroupResMap.end()) {
115 camGroupRes = mCamGroupResMap[frameId];
116 if (!query_ready && camGroupRes->_ready)
117 return NULL;
118 camGroupRes->_refCnt++;
119 LOG1_CAMGROUP("camgroup res of frame: %u exists", frameId);
120 } else {
121 if (!query_ready)
122 return NULL;
123
124 if (mCamGroupResMap.size() > 3) {
125 LOGE_CAMGROUP("camgroup result map overflow:%d, first_id: %u",
126 mCamGroupResMap.size(), mCamGroupResMap.begin()->first);
127 clearGroupCamResult_Locked(frameId - 2);
128 }
129 if (frameId < mClearedResultId) {
130 LOGW_CAMGROUP("disorder frameId(%d) < mClearedResultId(%d)", frameId, mClearedResultId);
131 return NULL;
132 }
133 camGroupRes = new rk_aiq_groupcam_result_t();
134 if (!camGroupRes) {
135 LOGE_CAMGROUP("malloc camGroup Res failed !");
136 return NULL;
137 }
138 camGroupRes->reset();
139 camGroupRes->_frameId = frameId;
140 camGroupRes->_refCnt++;
141 mCamGroupResMap[frameId] = camGroupRes;
142 LOGD_CAMGROUP("malloc camgroup res for frame: %u success", frameId);
143 }
144
145 return camGroupRes;
146 }
147
148 void
clearGroupCamResult_Locked(uint32_t frameId)149 RkAiqCamGroupManager::clearGroupCamResult_Locked(uint32_t frameId)
150 {
151 if (frameId == (uint32_t)(-1)) {
152 // clear all
153 LOGD_CAMGROUP("clear all camgroup res");
154 for (auto it : mCamGroupResMap) {
155 (it.second)->reset();
156 delete it.second;
157 }
158 mCamGroupResMap.clear();
159 } else {
160 rk_aiq_groupcam_result_t* camGroupRes = NULL;
161
162 std::map<uint32_t, rk_aiq_groupcam_result_t*>::iterator iter;
163 for (iter = mCamGroupResMap.begin(); iter != mCamGroupResMap.end();) {
164 if (iter->first <= frameId) {
165 camGroupRes = iter->second;
166 if (camGroupRes->_refCnt > 0) {
167 if (iter->first < mClearedResultId) {
168 LOGW("impossible, id:%u < mClearedResultId:%u, refCnt: %u",
169 iter->first, mClearedResultId, camGroupRes->_refCnt);
170 }
171 iter++;
172 continue;
173 }
174 LOGD_CAMGROUP("clear camgroup res of frame: %u, ready: %d", iter->first, camGroupRes->_ready);
175 camGroupRes->reset();
176 delete camGroupRes;
177 if (iter->first > mClearedResultId)
178 mClearedResultId = iter->first;
179 iter = mCamGroupResMap.erase(iter);
180 } else {
181 iter++;
182 }
183 }
184 }
185 }
186
187 void
clearGroupCamResult(uint32_t frameId)188 RkAiqCamGroupManager::clearGroupCamResult(uint32_t frameId) {
189
190 SmartLock locker (mCamGroupResMutex);
191 clearGroupCamResult_Locked(frameId);
192 }
193
194 void
putGroupCamResult(rk_aiq_groupcam_result_t * gc_res)195 RkAiqCamGroupManager::putGroupCamResult(rk_aiq_groupcam_result_t* gc_res)
196 {
197 SmartLock locker (mCamGroupResMutex);
198 if (gc_res && gc_res->_refCnt != 0)
199 gc_res->_refCnt--;
200 }
201
202 rk_aiq_groupcam_sofsync_t*
getGroupCamSofsync(uint32_t frameId,bool query_ready)203 RkAiqCamGroupManager::getGroupCamSofsync(uint32_t frameId, bool query_ready)
204 {
205 SmartLock locker (mSofMutex);
206 rk_aiq_groupcam_sofsync_t* camGroupSofsync = NULL;
207
208 if (mCamGroupSofsyncMap.find(frameId) != mCamGroupSofsyncMap.end()) {
209 camGroupSofsync = mCamGroupSofsyncMap[frameId];
210 if (!query_ready && (camGroupSofsync->_validCamSofSyncBits == mRequiredCamsResMask))
211 return NULL;
212 camGroupSofsync->_refCnt++;
213 LOG1_CAMGROUP("camgroup sofSync of frame: %u exists", frameId);
214 } else {
215 if (!query_ready)
216 return NULL;
217
218 // if overflow, clear some ones
219 if (mCamGroupSofsyncMap.size() > 16) {
220 LOGW_CAMGROUP("camgroup sofSync overflow:%d, first_id: %d",
221 mCamGroupSofsyncMap.size(), mCamGroupSofsyncMap.begin()->first);
222 clearGroupCamSofsync_Locked(frameId - 8);
223 }
224
225 if (frameId < mClearedSofId) {
226 LOGE_CAMGROUP("disorder frameId(%u) < mClearedSofId(%u)", frameId, mClearedSofId);
227 return NULL;
228 }
229
230 camGroupSofsync = new rk_aiq_groupcam_sofsync_t();
231 if (!camGroupSofsync ) {
232 LOGE_CAMGROUP("malloc camGroup sofSync failed !");
233 return NULL;
234 }
235
236 camGroupSofsync->reset();
237 camGroupSofsync->_refCnt++;
238 mCamGroupSofsyncMap[frameId] = camGroupSofsync;
239 LOGD_CAMGROUP("malloc camgroup sofSync for frame: %u success", frameId);
240 }
241
242 return camGroupSofsync;
243 }
244
245 void
putGroupCamSofsync(rk_aiq_groupcam_sofsync_t * syncSof)246 RkAiqCamGroupManager::putGroupCamSofsync(rk_aiq_groupcam_sofsync_t* syncSof)
247 {
248 SmartLock locker (mSofMutex);
249 if (syncSof && syncSof->_refCnt != 0)
250 syncSof->_refCnt--;
251 }
252
253 void
clearGroupCamSofsync_Locked(uint32_t frameId)254 RkAiqCamGroupManager::clearGroupCamSofsync_Locked(uint32_t frameId) {
255 if (frameId == (uint32_t)(-1)) {
256 // clear all
257 LOGD_CAMGROUP("clear all camgroup sofSync res");
258 for (auto it : mCamGroupSofsyncMap) {
259 (it.second)->reset();
260 delete it.second;
261 }
262 mCamGroupSofsyncMap.clear();
263 } else {
264 rk_aiq_groupcam_sofsync_t* camGroupSofsync = NULL;
265
266 std::map<uint32_t, rk_aiq_groupcam_sofsync_t*>::iterator iter;
267 for (iter = mCamGroupSofsyncMap.begin(); iter != mCamGroupSofsyncMap.end();) {
268 if (iter->first <= frameId) {
269 camGroupSofsync = iter->second;
270 if (camGroupSofsync->_refCnt > 0) {
271 iter++;
272 continue;
273 }
274 LOGD_CAMGROUP("clear camgroup sofSync of frame: %u, ready: %d",
275 iter->first,
276 camGroupSofsync->_validCamSofSyncBits == mRequiredCamsResMask);
277 camGroupSofsync->reset();
278 delete camGroupSofsync;
279 mClearedSofId = frameId;
280 iter = mCamGroupSofsyncMap.erase(iter);
281 } else {
282 iter++;
283 }
284 }
285 if (mCamGroupSofsyncMap.size() > 100)
286 LOGE_CAMGROUP("mCamGroupSofsyncMap size > 100 !!!");
287 }
288 }
289 void
clearGroupCamSofsync(uint32_t frameId)290 RkAiqCamGroupManager::clearGroupCamSofsync(uint32_t frameId) {
291
292 SmartLock locker (mSofMutex);
293 clearGroupCamSofsync_Locked(frameId);
294 }
295
296 void
setSingleCamStatusReady(rk_aiq_singlecam_result_status_t * status,rk_aiq_groupcam_result_t * gc_result)297 RkAiqCamGroupManager::setSingleCamStatusReady(rk_aiq_singlecam_result_status_t* status, rk_aiq_groupcam_result_t* gc_result)
298 {
299 bool gc_result_ready = false;
300 {
301 SmartLock locker (mCamGroupResMutex);
302 if (((status->_validCoreMsgsBits & mRequiredMsgsMask) == mRequiredMsgsMask) &&
303 ((status->_validAlgoResBits & mRequiredAlgoResMask) == mRequiredAlgoResMask)) {
304 status->_ready = true;
305 LOGD_CAMGROUP("camgroup single cam res ready, camId:%d, frameId:%u",
306 status->_singleCamResults._3aResults._camId,
307 status->_singleCamResults._3aResults._frameId);
308 gc_result->_validCamResBits |= 1 << status->_singleCamResults._3aResults._camId;
309 if (!gc_result->_ready && (gc_result->_validCamResBits == mRequiredCamsResMask)) {
310 gc_result->_ready = true;
311 gc_result_ready = true;
312 LOGD_CAMGROUP("camgroup all cam res ready, frameId:%u",
313 status->_singleCamResults._3aResults._frameId);
314 }
315 }
316 }
317
318 if (gc_result_ready) {
319 // force to ready
320 uint32_t lastFrameId = status->_singleCamResults._3aResults._frameId - 1;
321 rk_aiq_groupcam_result_t* last_gc_result = getGroupCamResult(lastFrameId, false);
322 if (last_gc_result && (mState == CAMGROUP_MANAGER_STARTED)) {
323 last_gc_result->_ready = true;
324 last_gc_result->_validCamResBits = mRequiredCamsResMask;
325 rk_aiq_singlecam_result_status_t* last_scam_status = NULL;
326 for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
327 if ((last_gc_result->_validCamResBits >> i) & 1) {
328 last_scam_status = &last_gc_result->_singleCamResultsStatus[i];
329 last_scam_status->_validAlgoResBits = mRequiredMsgsMask;
330 last_scam_status->_validCoreMsgsBits = mRequiredAlgoResMask;
331 }
332 }
333 LOGW_CAMGROUP("camgroup res frameId disorder, unready frameId:%u < cur ready frame %u",
334 lastFrameId, status->_singleCamResults._3aResults._frameId);
335 mCamGroupReprocTh->sendFrame(last_gc_result);
336 }
337 putGroupCamResult(last_gc_result);
338 // init params is reprocessed in func prepare
339 if (mState == CAMGROUP_MANAGER_STARTED) {
340 LOGD_CAMGROUP("send frameId:%u ",gc_result->_frameId);
341 mCamGroupReprocTh->sendFrame(gc_result);
342 }
343 } else {
344 SmartLock locker (mCamGroupResMutex);
345 if (status->_singleCamResults._fullIspParam.ptr()) {
346 RkAiqFullParams* scam_aiqParams = status->_singleCamResults._fullIspParam->data().ptr();
347 LOG1_CAMGROUP("scam_aiqParams %p ", scam_aiqParams);
348 }
349 LOG1_CAMGROUP("camgroup result status: validCams:0x%x(req:0x%x), camId:%d, frameId:%u, "
350 "validAlgoResBits:0x%" PRIx64 "(req:0x%" PRIx64 "), validMsgBits:0x%" PRIx64 "(req:0x%" PRIx64 ")",
351 gc_result->_validCamResBits, mRequiredCamsResMask,
352 status->_singleCamResults._3aResults._camId,
353 status->_singleCamResults._3aResults._frameId,
354 status->_validAlgoResBits, mRequiredAlgoResMask,
355 status->_validCoreMsgsBits, mRequiredMsgsMask);
356 }
357 }
358
359 void
processAiqCoreMsgs(RkAiqCore * src,RkAiqCoreVdBufMsg & msg)360 RkAiqCamGroupManager::processAiqCoreMsgs(RkAiqCore* src, RkAiqCoreVdBufMsg& msg)
361 {
362 int camId = src->getCamPhyId();
363 uint32_t frameId = msg.frame_id;
364
365 // check if the msg is required firstly
366 if (!(mRequiredMsgsMask & (1ULL << msg.msg_id))) {
367 LOG1_CAMGROUP("camgroup: not required core msg :%s of frameId: %d, ignore",
368 MessageType2Str[msg.msg_id], msg.frame_id);
369 return;
370 }
371
372 switch (msg.msg_id) {
373 case XCAM_MESSAGE_AWB_STATS_OK :
374 case XCAM_MESSAGE_AEC_STATS_OK :
375 // TODO: should get from RkAiqAnalyzerGroup::getMsgDelayCnt
376 frameId += 2;
377 default:
378 break;
379 }
380
381 rk_aiq_groupcam_result_t* camGroupRes = getGroupCamResult(frameId);
382 if (!camGroupRes) {
383 LOGW_CAMGROUP("camgroup: get cam result faild for msg_id:%d, camId: %d, msg_id:%d, frame: %d", msg.msg_id, camId, frameId);
384 return;
385 }
386 rk_aiq_singlecam_result_status_t* singleCamStatus = &camGroupRes->_singleCamResultsStatus[camId];
387 rk_aiq_singlecam_result_t* singleCamRes = &singleCamStatus->_singleCamResults;
388
389 RkAiqCoreVdBufMsg* vdBufMsg = NULL;
390 XCamVideoBuffer* buf = NULL;
391 vdBufMsg = &msg;
392 if (!vdBufMsg->msg.ptr()) {
393 LOGW_CAMGROUP(
394 "camgroup: get cam result NULL for msg_id:%d, camId: %d, frame: %d",
395 msg.msg_id, camId, frameId);
396 goto set_bits;
397 }
398
399 switch (msg.msg_id) {
400 case XCAM_MESSAGE_AWB_STATS_OK:
401 singleCamRes->_3aResults.awb._awbStats = convert_to_XCamVideoBuffer(vdBufMsg->msg);
402 break;
403 case XCAM_MESSAGE_AWB_PROC_RES_OK:
404 singleCamRes->_3aResults.awb._awbProcRes = convert_to_XCamVideoBuffer(vdBufMsg->msg);
405 break;
406 case XCAM_MESSAGE_AEC_STATS_OK:
407 singleCamRes->_3aResults.aec._aecStats = convert_to_XCamVideoBuffer(vdBufMsg->msg);
408 break;
409 case XCAM_MESSAGE_AE_PRE_RES_OK:
410 singleCamRes->_3aResults.aec._aePreRes = convert_to_XCamVideoBuffer(vdBufMsg->msg);
411 break;
412 case XCAM_MESSAGE_AE_PROC_RES_OK:
413 //singleCamRes->_3aResults.aec._aeProcRes = convert_to_XCamVideoBuffer(vdBufMsg->msg);
414 break;
415 case XCAM_MESSAGE_SOF_INFO_OK: {
416 auto sofInfoMsg = vdBufMsg->msg.dynamic_cast_ptr<RkAiqSofInfoWrapperProxy>();
417 singleCamRes->_3aResults.aec._effAecExpInfo =
418 sofInfoMsg->data()->curExp->data()->aecExpInfo;
419 singleCamRes->_3aResults.aec._bEffAecExpValid = true;
420 } break;
421 default:
422 break;
423 }
424
425 set_bits:
426 // check if all requirements are satisfied, if so,
427 // notify the reprocess procedure
428 {
429 SmartLock locker (mCamGroupResMutex);
430 singleCamStatus->_validCoreMsgsBits |= ((uint64_t)1) << msg.msg_id;
431 singleCamRes->_3aResults._camId = camId;
432 singleCamRes->_3aResults._frameId = frameId;
433 }
434 LOGD_CAMGROUP("camgroup: got required core msg :%s of camId:%d, frameId: %u, ",
435 MessageType2Str[msg.msg_id], camId, frameId);
436 setSingleCamStatusReady(singleCamStatus, camGroupRes);
437 putGroupCamResult(camGroupRes);
438 }
439
440 void
RelayAiqCoreResults(RkAiqCore * src,SmartPtr<RkAiqFullParamsProxy> & results)441 RkAiqCamGroupManager::RelayAiqCoreResults(RkAiqCore* src, SmartPtr<RkAiqFullParamsProxy> &results)
442 {
443 // only support v3x now
444 int camId = src->getCamPhyId();
445 uint32_t frame_id = -1;
446
447 if (!CHECK_ISP_HW_V32_LITE() && !CHECK_ISP_HW_V32() && !CHECK_ISP_HW_V3X() && !CHECK_ISP_HW_V21()) {
448 LOGE_CAMGROUP("only support isp32_lite/isp32/isp3x/isp21 now");
449 return;
450 }
451
452 RkAiqFullParams* aiqParams = results->data().ptr();
453
454 #define SET_TO_CAMGROUP(lc, BC) \
455 if (aiqParams->m##lc##Params.ptr()) { \
456 frame_id = aiqParams->m##lc##Params->data()->frame_id; \
457 rk_aiq_groupcam_result_t* camGroupRes = getGroupCamResult(frame_id); \
458 if (!camGroupRes) { \
459 LOGW_CAMGROUP("camgroup: get cam result faild for type:%s, camId: %d, frame: %d", #BC, camId, frame_id); \
460 return; \
461 } \
462 rk_aiq_singlecam_result_status_t* singleCamStatus = \
463 &camGroupRes->_singleCamResultsStatus[camId]; \
464 rk_aiq_singlecam_result_t* singleCamRes = &singleCamStatus->_singleCamResults; \
465 /* compose single aiq params to one */ \
466 { \
467 SmartLock locker (mCamGroupResMutex); \
468 if (!singleCamRes->_fullIspParam.ptr()) { \
469 singleCamRes->_fullIspParam = results; \
470 LOGD_CAMGROUP("init scam_aiqParams_proxy : %p for camId:%d, frameId: %u",\
471 singleCamRes->_fullIspParam.ptr(), camId, frame_id); \
472 } \
473 RkAiqFullParams* scam_aiqParams = singleCamRes->_fullIspParam->data().ptr();\
474 if (scam_aiqParams != aiqParams) \
475 scam_aiqParams->m##lc##Params = aiqParams->m##lc##Params; \
476 singleCamStatus->_validAlgoResBits |= ((uint64_t)1) << RESULT_TYPE_##BC##_PARAM; \
477 singleCamRes->_3aResults._camId = camId; \
478 singleCamRes->_3aResults._frameId = frame_id; \
479 } \
480 LOG1_CAMGROUP("%s: relay results: camId:%d, frameId:%u, type:%s", \
481 __FUNCTION__, camId, frame_id, #BC); \
482 setSingleCamStatusReady(singleCamStatus, camGroupRes); \
483 putGroupCamResult(camGroupRes);\
484 } \
485
486 SET_TO_CAMGROUP(Exposure, EXPOSURE);
487 SET_TO_CAMGROUP(Focus, FOCUS);
488 SET_TO_CAMGROUP(Aec, AEC);
489 SET_TO_CAMGROUP(Hist, HIST);
490 SET_TO_CAMGROUP(AwbGain, AWBGAIN);
491 SET_TO_CAMGROUP(Dpcc, DPCC);
492 SET_TO_CAMGROUP(Lsc, LSC);
493 SET_TO_CAMGROUP(Debayer, DEBAYER);
494 SET_TO_CAMGROUP(Ldch, LDCH);
495 SET_TO_CAMGROUP(Lut3d, LUT3D);
496 SET_TO_CAMGROUP(Adegamma, ADEGAMMA);
497 SET_TO_CAMGROUP(Wdr, WDR);
498 SET_TO_CAMGROUP(Csm, CSM);
499 SET_TO_CAMGROUP(Cgc, CGC);
500 SET_TO_CAMGROUP(Conv422, CONV422);
501 SET_TO_CAMGROUP(Yuvconv, YUVCONV);
502 SET_TO_CAMGROUP(Cp, CP);
503 SET_TO_CAMGROUP(Ie, IE);
504 SET_TO_CAMGROUP(Cpsl, CPSL);
505 SET_TO_CAMGROUP(Motion, MOTION);
506 // TODO: special for fec ?
507 SET_TO_CAMGROUP(Fec, FEC);
508 // ispv21 and ispv3x common
509 SET_TO_CAMGROUP(Gic, GIC);
510 SET_TO_CAMGROUP(Dehaze, DEHAZE);
511 SET_TO_CAMGROUP(Drc, DRC);
512 SET_TO_CAMGROUP(Agamma, AGAMMA);
513 SET_TO_CAMGROUP(Merge, MERGE);
514
515 if (CHECK_ISP_HW_V21()) {
516 // ispv21
517 SET_TO_CAMGROUP(BlcV21, BLC);
518 SET_TO_CAMGROUP(AwbV21, AWB);
519 SET_TO_CAMGROUP(BaynrV21, RAWNR);
520 SET_TO_CAMGROUP(YnrV21, YNR);
521 SET_TO_CAMGROUP(CnrV21, UVNR);
522 SET_TO_CAMGROUP(SharpenV21, SHARPEN);
523 SET_TO_CAMGROUP(Af, AF);
524 SET_TO_CAMGROUP(Gain, GAIN);
525 } else if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
526 SET_TO_CAMGROUP(BlcV32, BLC);
527 SET_TO_CAMGROUP(CacV32, CAC);
528 SET_TO_CAMGROUP(DebayerV32, DEBAYER);
529 SET_TO_CAMGROUP(CcmV32, CCM);
530 SET_TO_CAMGROUP(LdchV32, LDCH);
531 SET_TO_CAMGROUP(BaynrV32, RAWNR);
532 SET_TO_CAMGROUP(YnrV32, YNR);
533 SET_TO_CAMGROUP(CnrV32, UVNR);
534 SET_TO_CAMGROUP(SharpV32, SHARPEN);
535 SET_TO_CAMGROUP(AwbV32, AWB);
536 SET_TO_CAMGROUP(AfV32, AF);
537 SET_TO_CAMGROUP(TnrV32, TNR);
538 SET_TO_CAMGROUP(AwbGainV32, AWBGAIN);
539 SET_TO_CAMGROUP(GainV3x, GAIN);
540 } else {
541 // ispv3x
542 SET_TO_CAMGROUP(BlcV21, BLC);
543 SET_TO_CAMGROUP(AwbV3x, AWB);
544 SET_TO_CAMGROUP(AfV3x, AF);
545 SET_TO_CAMGROUP(BaynrV3x, RAWNR);
546 SET_TO_CAMGROUP(YnrV3x, YNR);
547 SET_TO_CAMGROUP(CnrV3x, UVNR);
548 SET_TO_CAMGROUP(SharpenV3x, SHARPEN);
549 SET_TO_CAMGROUP(CacV3x, CAC);
550 SET_TO_CAMGROUP(GainV3x, GAIN);
551 SET_TO_CAMGROUP(TnrV3x, TNR);
552 }
553 if (CHECK_ISP_HW_V32()) {
554 SET_TO_CAMGROUP(CcmV32, CCM);
555 } else {
556 SET_TO_CAMGROUP(Ccm, CCM);
557 }
558 }
559
560 XCamReturn
sofSync(RkAiqManager * aiqManager,SmartPtr<VideoBuffer> & sof_evt)561 RkAiqCamGroupManager::sofSync(RkAiqManager* aiqManager, SmartPtr<VideoBuffer>& sof_evt)
562 {
563 int camId = aiqManager->getCamPhyId();
564 uint32_t frameId = sof_evt->get_sequence();
565
566 if (mState != CAMGROUP_MANAGER_STARTED) {
567 LOGE_CAMGROUP("wrong state %d, ignore sofSync event \n", mState);
568 _sync_sof_running = false;
569 return XCAM_RETURN_NO_ERROR;
570 }
571
572 _sync_sof_running = true;
573
574 LOGD_CAMGROUP("sofSync event camId: %d, frameId: %u ...\n", camId, frameId);
575
576 rk_aiq_groupcam_sofsync_t* camGroupSofsync = getGroupCamSofsync(frameId);
577 if (!camGroupSofsync) {
578 LOGE_CAMGROUP("camgroup: get sofSync failed for camId: %d, frame: %u, igore", camId, frameId);
579 _sync_sof_running = false;
580 return XCAM_RETURN_NO_ERROR;
581 }
582 camGroupSofsync->_singleCamSofEvt[camId] = sof_evt;
583
584 bool sync_done = false;
585 {
586 SmartLock locker (mSofMutex);
587 camGroupSofsync->_validCamSofSyncBits |= ((uint8_t)1) << camId;
588 if (camGroupSofsync->_validCamSofSyncBits == mRequiredCamsResMask)
589 sync_done = true;
590 }
591
592 if (sync_done) {
593 for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
594 if ((camGroupSofsync->_validCamSofSyncBits >> i) & 1) {
595 mBindAiqsMap[i]->syncSofEvt(camGroupSofsync->_singleCamSofEvt[i]);
596 }
597 }
598 putGroupCamSofsync(camGroupSofsync);
599 clearGroupCamSofsync(frameId);
600 } else
601 putGroupCamSofsync(camGroupSofsync);
602
603 _sync_sof_running = false;
604
605 LOGD_CAMGROUP("sofSync event camId: %d, frameId: %u done\n", camId, frameId);
606
607 return XCAM_RETURN_NO_ERROR;
608 }
609
610 SmartPtr<RkAiqCamgroupHandle>
newAlgoHandle(RkAiqAlgoDesComm * algo,int hw_ver)611 RkAiqCamGroupManager::newAlgoHandle(RkAiqAlgoDesComm* algo, int hw_ver)
612 {
613 #define NEW_ALGO_HANDLE(lc, BC) \
614 if (algo->type == RK_AIQ_ALGO_TYPE_##BC) { \
615 if (hw_ver == 0) \
616 return new RkAiqCamGroup##lc##HandleInt(algo, this); \
617 }\
618
619 NEW_ALGO_HANDLE(Ae, AE);
620 NEW_ALGO_HANDLE(Awb, AWB);
621 NEW_ALGO_HANDLE(Accm, ACCM);
622 NEW_ALGO_HANDLE(A3dlut, A3DLUT);
623 NEW_ALGO_HANDLE(Agamma, AGAMMA);
624 NEW_ALGO_HANDLE(Amerge, AMERGE);
625 NEW_ALGO_HANDLE(Adrc, ADRC);
626 NEW_ALGO_HANDLE(Adehaze, ADHAZ);
627 #ifndef ISP_HW_V32_LITE
628 NEW_ALGO_HANDLE(Agic, AGIC);
629 #endif
630
631 #if defined(ISP_HW_V30)
632 NEW_ALGO_HANDLE(Ablc, ABLC);
633 NEW_ALGO_HANDLE(AynrV3, AYNR);
634 NEW_ALGO_HANDLE(AcnrV2, ACNR);
635 NEW_ALGO_HANDLE(Abayer2dnrV2, ARAWNR);
636 NEW_ALGO_HANDLE(AsharpV4, ASHARP);
637 NEW_ALGO_HANDLE(AbayertnrV2, AMFNR);
638 #endif
639
640
641 #if defined(ISP_HW_V32)
642 NEW_ALGO_HANDLE(AblcV32, ABLC);
643 NEW_ALGO_HANDLE(AynrV22, AYNR);
644 NEW_ALGO_HANDLE(AcnrV30, ACNR);
645 NEW_ALGO_HANDLE(Abayer2dnrV23, ARAWNR);
646 NEW_ALGO_HANDLE(AsharpV33, ASHARP);
647 NEW_ALGO_HANDLE(AbayertnrV23, AMFNR);
648 #elif defined(ISP_HW_V32_LITE)
649 NEW_ALGO_HANDLE(AblcV32, ABLC);
650 NEW_ALGO_HANDLE(AynrV22, AYNR);
651 NEW_ALGO_HANDLE(AcnrV30, ACNR);
652 NEW_ALGO_HANDLE(AsharpV33, ASHARP);
653 NEW_ALGO_HANDLE(AbayertnrV23, AMFNR);
654 #endif
655
656 NEW_ALGO_HANDLE(Alsc, ALSC);
657 NEW_ALGO_HANDLE(Adpcc, ADPCC);
658 #if defined(ISP_HW_V30) || defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
659 NEW_ALGO_HANDLE(AgainV2, AGAIN);
660 #endif
661 /* TODO: new the handle of other algo modules */
662
663 return new RkAiqCamgroupHandle(algo, this);
664 }
665
666 SmartPtr<RkAiqCamgroupHandle>
getDefAlgoTypeHandle(int algo_type)667 RkAiqCamGroupManager::getDefAlgoTypeHandle(int algo_type)
668 {
669 // get defalut algo handle(id == 0)
670 if (mDefAlgoHandleMap.find(algo_type) != mDefAlgoHandleMap.end())
671 return mDefAlgoHandleMap.at(algo_type);
672
673 LOG1_CAMGROUP("can't find algo handle %d", algo_type);
674 return NULL;
675 }
676
677 std::map<int, SmartPtr<RkAiqCamgroupHandle>>*
getAlgoTypeHandleMap(int algo_type)678 RkAiqCamGroupManager::getAlgoTypeHandleMap(int algo_type)
679 {
680 if (mAlgoHandleMaps.find(algo_type) != mAlgoHandleMaps.end())
681 return &mAlgoHandleMaps.at(algo_type);
682
683 LOG1_CAMGROUP("can't find algo map %d", algo_type);
684 return NULL;
685 }
686
687 void
addDefaultAlgos(const struct RkAiqAlgoDesCommExt * algoDes)688 RkAiqCamGroupManager::addDefaultAlgos(const struct RkAiqAlgoDesCommExt* algoDes)
689 {
690 if (mBindAiqsMap.empty()) {
691 LOGD_CAMGROUP("no group cam, bypass");
692 return ;
693 }
694
695 const auto* aiqManager = (mBindAiqsMap.begin())->second;
696 auto* aiqCore = aiqManager->mRkAiqAnalyzer.ptr();
697 const auto* sharedCom = &aiqCore->mAlogsComSharedParams;
698
699 mGroupAlgoCtxCfg.s_calibv2 = sharedCom->calibv2;
700 mGroupAlgoCtxCfg.pCamgroupCalib = mCamgroupCalib;
701 mGroupAlgoCtxCfg.cfg_com.isp_hw_version = aiqCore->mIspHwVer;
702 mGroupAlgoCtxCfg.cfg_com.calibv2 =
703 const_cast<CamCalibDbV2Context_t*>(sharedCom->calibv2);
704 mGroupAlgoCtxCfg.cfg_com.isGroupMode = true;
705
706 mGroupAlgoCtxCfg.camIdArrayLen = mBindAiqsMap.size();
707
708 int i = 0;
709 for (auto& it : mBindAiqsMap)
710 mGroupAlgoCtxCfg.camIdArray[i++] = it.first;
711
712 for (int i = 0; algoDes[i].des != NULL; i++) {
713 const auto* algo_des = algoDes[i].des;
714 auto* algo_map = aiqCore->getAlgoTypeHandleMap(algo_des->type);
715 if (!algo_map || algo_map->empty()) {
716 LOGE_CAMGROUP("Adding group algo %s without single algo is not supported yet!",
717 AlgoTypeToString(algo_des->type).c_str());
718 continue;
719 }
720 mGroupAlgoCtxCfg.cfg_com.module_hw_version = algoDes[i].module_hw_ver;
721
722 auto grpHandle =
723 newAlgoHandle(const_cast<RkAiqAlgoDesComm*>(algo_des), 0);
724 mDefAlgoHandleList.push_back(grpHandle);
725 mDefAlgoHandleMap[algo_des->type] = grpHandle;
726
727 std::map<int, SmartPtr<RkAiqCamgroupHandle>> hdlMaps;
728 hdlMaps[0] = grpHandle;
729 mAlgoHandleMaps[algo_des->type] = hdlMaps;
730
731 LOGD_CAMGROUP("camgroup: add algo: %d", algo_des->type);
732 }
733 }
734
735 XCamReturn
setCamgroupCalib(CamCalibDbCamgroup_t * camgroup_calib)736 RkAiqCamGroupManager::setCamgroupCalib(CamCalibDbCamgroup_t* camgroup_calib)
737 {
738 ENTER_CAMGROUP_FUNCTION();
739 if (mState == CAMGROUP_MANAGER_STARTED ||
740 mState == CAMGROUP_MANAGER_INVALID) {
741 LOGE_CAMGROUP("wrong state %d\n", mState);
742 return XCAM_RETURN_ERROR_FAILED;
743 }
744 // update groupcalib
745 mCamgroupCalib = camgroup_calib;
746 EXIT_CAMGROUP_FUNCTION();
747 return XCAM_RETURN_NO_ERROR;
748 }
749
750 XCamReturn
init()751 RkAiqCamGroupManager::init()
752 {
753 ENTER_CAMGROUP_FUNCTION();
754 addDefaultAlgos(mGroupAlgosDesArray);
755
756 if (mState != CAMGROUP_MANAGER_BINDED) {
757 LOGE_CAMGROUP("wrong state %d\n", mState);
758 return XCAM_RETURN_ERROR_FAILED;
759 }
760 mState = CAMGROUP_MANAGER_INITED;
761 EXIT_CAMGROUP_FUNCTION();
762 return XCAM_RETURN_NO_ERROR;
763 }
764
765 XCamReturn
deInit()766 RkAiqCamGroupManager::deInit()
767 {
768 ENTER_CAMGROUP_FUNCTION();
769 if (mState != CAMGROUP_MANAGER_UNBINDED) {
770 LOGE_CAMGROUP("wrong state %d\n", mState);
771 return XCAM_RETURN_ERROR_FAILED;
772 }
773
774 mDefAlgoHandleList.clear();
775 mDefAlgoHandleMap.clear();
776 mAlgoHandleMaps.clear();
777
778 /* clear the aysnc results after stop */
779 clearGroupCamResult(-1);
780 clearGroupCamSofsync(-1);
781
782 mState = CAMGROUP_MANAGER_INVALID;
783 EXIT_CAMGROUP_FUNCTION();
784 return XCAM_RETURN_NO_ERROR;
785 }
786
787 XCamReturn
start()788 RkAiqCamGroupManager::start()
789 {
790 ENTER_CAMGROUP_FUNCTION();
791 if (mState != CAMGROUP_MANAGER_PREPARED) {
792 LOGE_CAMGROUP("wrong state %d\n", mState);
793 return XCAM_RETURN_ERROR_FAILED;
794 }
795
796 mCamGroupReprocTh->triger_start();
797 mCamGroupReprocTh->start();
798
799 mState = CAMGROUP_MANAGER_STARTED;
800 EXIT_CAMGROUP_FUNCTION();
801 return XCAM_RETURN_NO_ERROR;
802 }
803
804 XCamReturn
stop()805 RkAiqCamGroupManager::stop()
806 {
807 ENTER_CAMGROUP_FUNCTION();
808 if (mState == CAMGROUP_MANAGER_INVALID) {
809 LOGE_CAMGROUP("wrong state %d\n", mState);
810 return XCAM_RETURN_ERROR_FAILED;
811 }
812
813 if (mState == CAMGROUP_MANAGER_STARTED) {
814 mState = CAMGROUP_MANAGER_PREPARED;
815 }
816
817 while (_sync_sof_running == true) {
818 std::this_thread::yield();
819 }
820
821 mCamGroupReprocTh->triger_stop();
822 mCamGroupReprocTh->stop();
823 clearGroupCamResult(-1);
824 clearGroupCamSofsync(-1);
825 mVicapReadyMask = 0;
826 mClearedSofId = 0;
827 mClearedResultId = 0;
828
829 EXIT_CAMGROUP_FUNCTION();
830 return XCAM_RETURN_NO_ERROR;
831 }
832
833 XCamReturn
prepare()834 RkAiqCamGroupManager::prepare()
835 {
836 ENTER_CAMGROUP_FUNCTION();
837 XCamReturn ret = XCAM_RETURN_NO_ERROR;
838
839 if (mState != CAMGROUP_MANAGER_INITED &&
840 mState != CAMGROUP_MANAGER_BINDED) {
841 LOGE_CAMGROUP("wrong state %d\n", mState);
842 return XCAM_RETURN_ERROR_FAILED;
843 }
844
845 if (mBindAiqsMap.empty()) {
846 LOGD_CAMGROUP("no group cam, bypass");
847 return XCAM_RETURN_NO_ERROR;
848 }
849
850 // assume all single cam runs same algos
851 RkAiqManager* aiqManager = (mBindAiqsMap.begin())->second;
852 RkAiqCore* aiqCore = aiqManager->mRkAiqAnalyzer.ptr();
853
854 // reprocess initial params
855
856 // TODO: should deal with the case of eanbled algos changed dynamically
857 mRequiredAlgoResMask = aiqCore->mAllReqAlgoResMask.to_ullong();
858
859 rk_aiq_groupcam_result_t* camGroupRes = getGroupCamResult(0);
860
861 LOGD_CAMGROUP("camgroup: prepare: relay init params ...");
862 for (auto it : mBindAiqsMap) {
863 RkAiqManager* sAiqManager = it.second;
864 RkAiqCore* sAiqCore = sAiqManager->mRkAiqAnalyzer.ptr();
865 // initial params has no stats
866 camGroupRes->_singleCamResultsStatus[it.first]._validCoreMsgsBits = mRequiredMsgsMask;
867 RelayAiqCoreResults(sAiqCore, sAiqCore->mAiqCurParams);
868 }
869
870 LOGD_CAMGROUP("camgroup: prepare: prepare algos ...");
871
872 for (auto algoHdl : mDefAlgoHandleList) {
873 RkAiqCamgroupHandle* curHdl = algoHdl.ptr();
874 while (curHdl) {
875 if (curHdl->getEnable()) {
876 /* update user initial params */
877 ret = curHdl->updateConfig(true);
878 RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d update initial user params failed", curHdl->getAlgoType());
879 ret = curHdl->prepare(aiqCore);
880 RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d prepare failed", curHdl->getAlgoType());
881 }
882 curHdl = curHdl->getNextHdl();
883 }
884 }
885
886
887 LOGD_CAMGROUP("camgroup: reprocess init params ...");
888
889 mInit = true;
890
891 ret = reProcess(camGroupRes);
892 if (ret < 0) {
893 LOGE_CAMGROUP("camgroup: reProcess failed");
894 goto failed;
895 }
896 mInit = false;
897
898 LOGD_CAMGROUP("camgroup: send init params to hwi ...");
899 relayToHwi(camGroupRes);
900
901 LOGD_CAMGROUP("camgroup: clear init params ...");
902 // delete the processed result
903 putGroupCamResult(camGroupRes);
904 /* clear the aysnc results after stop */
905 clearGroupCamResult(-1);
906 clearGroupCamSofsync(-1);
907
908 LOGD_CAMGROUP("camgroup: prepare done");
909
910 mState = CAMGROUP_MANAGER_PREPARED;
911 return XCAM_RETURN_NO_ERROR;
912 EXIT_CAMGROUP_FUNCTION();
913 failed:
914 putGroupCamResult(camGroupRes);
915 clearGroupCamResult(-1);
916 return ret;
917 }
918
919 XCamReturn
bind(RkAiqManager * ctx)920 RkAiqCamGroupManager::bind(RkAiqManager* ctx)
921 {
922 ENTER_CAMGROUP_FUNCTION();
923
924 if (mState != CAMGROUP_MANAGER_INVALID &&
925 mState != CAMGROUP_MANAGER_BINDED) {
926 LOGE_CAMGROUP("in error state %d", mState);
927 return XCAM_RETURN_ERROR_FAILED;
928 }
929
930 int camId = ctx->getCamPhyId();
931 std::map<uint8_t, RkAiqManager*>::iterator it =
932 mBindAiqsMap.find(camId);
933
934 LOGD_CAMGROUP("camgroup: bind camId: %d %p to group", camId, ctx);
935
936 if (it != mBindAiqsMap.end()) {
937 return XCAM_RETURN_NO_ERROR;
938 } else {
939 mBindAiqsMap[camId] = ctx;
940 mRequiredCamsResMask |= 1 << camId;
941 }
942
943 mState = CAMGROUP_MANAGER_BINDED;
944
945 LOGD_CAMGROUP("camgroup: binded cams mask: 0x%x", mRequiredCamsResMask);
946
947 EXIT_CAMGROUP_FUNCTION();
948 return XCAM_RETURN_NO_ERROR;
949 }
950
951 XCamReturn
unbind(int camId)952 RkAiqCamGroupManager::unbind(int camId)
953 {
954 ENTER_CAMGROUP_FUNCTION();
955
956 if (mState == CAMGROUP_MANAGER_STARTED) {
957 LOGE_CAMGROUP("in error state %d", mState);
958 return XCAM_RETURN_ERROR_FAILED;
959 }
960
961 LOGD_CAMGROUP("camgroup: unbind camId: %d from group", camId);
962
963 std::map<uint8_t, RkAiqManager*>::iterator it =
964 mBindAiqsMap.find(camId);
965
966 if (it != mBindAiqsMap.end()) {
967 mBindAiqsMap.erase(it);
968 mRequiredCamsResMask &= ~(1 << camId);
969 if (mBindAiqsMap.empty())
970 mState = CAMGROUP_MANAGER_UNBINDED;
971 } else {
972 return XCAM_RETURN_NO_ERROR;
973 }
974
975 LOGD_CAMGROUP("camgroup: binded cams mask: 0x%x", mRequiredCamsResMask);
976
977 EXIT_CAMGROUP_FUNCTION();
978 return XCAM_RETURN_NO_ERROR;
979 }
980
981 XCamReturn
reProcess(rk_aiq_groupcam_result_t * gc_res)982 RkAiqCamGroupManager::reProcess(rk_aiq_groupcam_result_t* gc_res)
983 {
984 ENTER_CAMGROUP_FUNCTION();
985 XCamReturn ret = XCAM_RETURN_NO_ERROR;
986 if (mBindAiqsMap.empty()) {
987 LOGW_CAMGROUP("no group cam, bypass");
988 return XCAM_RETURN_NO_ERROR;
989 }
990
991 // assume all single cam runs same algos
992 RkAiqManager* aiqManager = (mBindAiqsMap.begin())->second;
993 RkAiqCore* aiqCore = aiqManager->mRkAiqAnalyzer.ptr();
994 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &aiqCore->mAlogsComSharedParams;
995
996 LOGD_CAMGROUP("camgroup: set reprocess params ... ");
997
998 int arraySize = mBindAiqsMap.size();
999 rk_aiq_singlecam_3a_result_t* camgroupParmasArray[arraySize];
1000
1001 memset(camgroupParmasArray, 0, sizeof(camgroupParmasArray));
1002
1003 int i = 0, vaild_cam_ind = 0;
1004 rk_aiq_singlecam_3a_result_t* scam_3a_res = NULL;
1005 rk_aiq_singlecam_result_t* scam_res = NULL;
1006 RkAiqFullParams* aiqParams = NULL;
1007
1008 #define RET_FAILED() \
1009 do { \
1010 LOGE_CAMGROUP("re-process param failed at %d", __LINE__); \
1011 return XCAM_RETURN_ERROR_PARAM; \
1012 } while (0)
1013
1014 for (i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
1015 if ((gc_res->_validCamResBits >> i) & 1) {
1016 scam_res = &gc_res->_singleCamResultsStatus[i]._singleCamResults;
1017 scam_3a_res = &scam_res->_3aResults;
1018 if (!scam_res->_fullIspParam.ptr())
1019 return XCAM_RETURN_ERROR_FAILED;
1020 aiqParams = scam_res->_fullIspParam->data().ptr();
1021 // fill 3a params
1022 if ((aiqParams->mExposureParams.ptr())) {
1023 scam_3a_res->aec.exp_tbl = aiqParams->mExposureParams->data()->result.ae_proc_res_rk.exp_set_tbl;
1024 scam_3a_res->aec.exp_tbl_size = &aiqParams->mExposureParams->data()->result.ae_proc_res_rk.exp_set_cnt;
1025 scam_3a_res->aec.exp_i2c_params = &aiqParams->mExposureParams->data()->result.exp_i2c_params;
1026 } else {
1027 LOGW_CAMGROUP("camId:%d, framId:%u, exp is null", i, gc_res->_frameId);
1028 // frame 1,2 exp may be null now
1029 //if (gc_res->_frameId == 1)
1030 RET_FAILED();
1031 }
1032
1033 if (!aiqParams->mAecParams.ptr())
1034 RET_FAILED();
1035 scam_3a_res->aec._aeMeasParams = &aiqParams->mAecParams->data()->result;
1036
1037 if (!aiqParams->mHistParams.ptr())
1038 RET_FAILED();
1039 scam_3a_res->aec._aeHistMeasParams = &aiqParams->mHistParams->data()->result;
1040
1041 if (CHECK_ISP_HW_V21()) {
1042 if (!aiqParams->mAwbV21Params.ptr())
1043 RET_FAILED();
1044 scam_3a_res->awb._awbCfgV201 = &aiqParams->mAwbV21Params->data()->result;
1045 } else if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1046 if (!aiqParams->mAwbV32Params.ptr())
1047 RET_FAILED();
1048 scam_3a_res->awb._awbCfgV32 = &aiqParams->mAwbV32Params->data()->result;
1049 } else {
1050 if (!aiqParams->mAwbV3xParams.ptr())
1051 RET_FAILED();
1052 scam_3a_res->awb._awbCfgV3x = &aiqParams->mAwbV3xParams->data()->result;
1053 }
1054
1055 if (!aiqParams->mDehazeParams.ptr())
1056 RET_FAILED();
1057
1058 scam_3a_res->_adehazeConfig = &aiqParams->mDehazeParams->data()->result;
1059
1060 if (!aiqParams->mMergeParams.ptr())
1061 RET_FAILED();
1062 scam_3a_res->_amergeConfig = &aiqParams->mMergeParams->data()->result;
1063
1064 if (!aiqParams->mAgammaParams.ptr())
1065 RET_FAILED();
1066 scam_3a_res->_agammaConfig = &aiqParams->mAgammaParams->data()->result;
1067
1068 if (!aiqParams->mDrcParams.ptr())
1069 RET_FAILED();
1070 scam_3a_res->_adrcConfig = &aiqParams->mDrcParams->data()->result;
1071 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1072 if (!aiqParams->mAwbGainV32Params.ptr()) {
1073 RET_FAILED();
1074 }
1075 scam_3a_res->awb._awbGainV32Params = &aiqParams->mAwbGainV32Params->data()->result;
1076 } else {
1077 if (!aiqParams->mAwbGainParams.ptr())
1078 RET_FAILED();
1079 scam_3a_res->awb._awbGainParams = &aiqParams->mAwbGainParams->data()->result;
1080 }
1081
1082 if (!aiqParams->mLscParams.ptr())
1083 RET_FAILED();
1084 scam_3a_res->_lscConfig = &aiqParams->mLscParams->data()->result;
1085
1086 if (!aiqParams->mDpccParams.ptr())
1087 RET_FAILED();
1088 scam_3a_res->_dpccConfig = &aiqParams->mDpccParams->data()->result;
1089
1090 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1091 if (!aiqParams->mCcmV32Params.ptr())
1092 RET_FAILED();
1093 scam_3a_res->accm._ccmCfg_v2 = &aiqParams->mCcmV32Params->data()->result;
1094 } else {
1095 if (!aiqParams->mCcmParams.ptr())
1096 RET_FAILED();
1097 scam_3a_res->accm._ccmCfg = &aiqParams->mCcmParams->data()->result;
1098 }
1099
1100 if (!aiqParams->mLut3dParams.ptr())
1101 RET_FAILED();
1102 scam_3a_res->_lut3dCfg = &aiqParams->mLut3dParams->data()->result;
1103 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1104 if (!aiqParams->mBlcV32Params.ptr())
1105 RET_FAILED();
1106 scam_3a_res->ablc._blcConfig_v32 = &aiqParams->mBlcV32Params->data()->result;
1107 } else {
1108 if (!aiqParams->mBlcV21Params.ptr())
1109 RET_FAILED();
1110 scam_3a_res->ablc._blcConfig = &aiqParams->mBlcV21Params->data()->result;
1111 }
1112
1113 if (CHECK_ISP_HW_V21()) {
1114 if (!aiqParams->mYnrV21Params.ptr())
1115 RET_FAILED();
1116 scam_3a_res->aynr._aynr_procRes_v2 = &aiqParams->mYnrV21Params->data()->result;
1117 } else if (CHECK_ISP_HW_V30()) {
1118 if (!aiqParams->mYnrV3xParams.ptr())
1119 RET_FAILED();
1120 scam_3a_res->aynr._aynr_procRes_v3._stFix = &aiqParams->mYnrV3xParams->data()->result;
1121 } else if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1122 if (!aiqParams->mYnrV32Params.ptr())
1123 RET_FAILED();
1124 scam_3a_res->aynr._aynr_procRes_v22 = &aiqParams->mYnrV32Params->data()->result;
1125 }
1126
1127 if (CHECK_ISP_HW_V21()) {
1128 if (!aiqParams->mCnrV21Params.ptr())
1129 RET_FAILED();
1130 scam_3a_res->acnr._acnr_procRes_v1 = &aiqParams->mCnrV21Params->data()->result;
1131 } else if (CHECK_ISP_HW_V30()) {
1132 if (!aiqParams->mCnrV3xParams.ptr())
1133 RET_FAILED();
1134 scam_3a_res->acnr._acnr_procRes_v2 = &aiqParams->mCnrV3xParams->data()->result;
1135 } else if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1136 if (!aiqParams->mCnrV32Params.ptr())
1137 RET_FAILED();
1138 scam_3a_res->acnr._acnr_procRes_v30 = &aiqParams->mCnrV32Params->data()->result;
1139 }
1140
1141 if (CHECK_ISP_HW_V21()) {
1142 if (!aiqParams->mSharpenV21Params.ptr())
1143 RET_FAILED();
1144 scam_3a_res->asharp._asharp_procRes_v3 = &aiqParams->mSharpenV21Params->data()->result;
1145 } else if (CHECK_ISP_HW_V30()) {
1146 if (!aiqParams->mSharpenV3xParams.ptr())
1147 RET_FAILED();
1148 scam_3a_res->asharp._asharp_procRes_v4 = &aiqParams->mSharpenV3xParams->data()->result;
1149 } else if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1150 if (!aiqParams->mSharpV32Params.ptr())
1151 RET_FAILED();
1152 scam_3a_res->asharp._asharp_procRes_v33 = &aiqParams->mSharpV32Params->data()->result;
1153 }
1154
1155
1156 if (CHECK_ISP_HW_V21()) {
1157 if (!aiqParams->mBaynrV21Params.ptr())
1158 RET_FAILED();
1159 scam_3a_res->abayernr._abayernr_procRes_v1 = &aiqParams->mBaynrV21Params->data()->result;
1160 } else if (CHECK_ISP_HW_V30()) {
1161 if (!aiqParams->mBaynrV3xParams.ptr())
1162 RET_FAILED();
1163 scam_3a_res->abayernr._abayer2dnr_procRes_v2 = &aiqParams->mBaynrV3xParams->data()->result;
1164 } else if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1165 if (!aiqParams->mBaynrV32Params.ptr())
1166 RET_FAILED();
1167 scam_3a_res->abayernr._abayer2dnr_procRes_v23 = &aiqParams->mBaynrV32Params->data()->result;
1168 }
1169
1170 if (CHECK_ISP_HW_V30()) {
1171 if (!aiqParams->mTnrV3xParams.ptr())
1172 RET_FAILED();
1173 scam_3a_res->abayertnr._abayertnr_procRes_v2 = &aiqParams->mTnrV3xParams->data()->result;
1174 } else if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1175 if (!aiqParams->mTnrV32Params.ptr())
1176 RET_FAILED();
1177 scam_3a_res->abayertnr._abayertnr_procRes_v23 = &aiqParams->mTnrV32Params->data()->result;
1178 }
1179
1180 if (CHECK_ISP_HW_V30() || CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1181 if (!aiqParams->mGainV3xParams.ptr())
1182 RET_FAILED();
1183 scam_3a_res->again._again_procRes_v2 = &aiqParams->mGainV3xParams->data()->result;
1184 }
1185 camgroupParmasArray[vaild_cam_ind++] = scam_3a_res;
1186 }
1187 }
1188
1189 if (vaild_cam_ind == 0) {
1190 LOGE_CAMGROUP("vaild_cam_ind == 0!");
1191 return XCAM_RETURN_NO_ERROR;
1192 }
1193 if (vaild_cam_ind != arraySize) {
1194 LOGW_CAMGROUP("wrong num of valid cam res:%d,exp:%d",
1195 vaild_cam_ind, arraySize);
1196 }
1197
1198 uint32_t frameId = camgroupParmasArray[0]->_frameId;
1199 LOGD_CAMGROUP("camgroup: frameId:%u reprocessing ... ", frameId);
1200
1201 for (auto algoHdl : mDefAlgoHandleList) {
1202 RkAiqCamgroupHandle* curHdl = algoHdl.ptr();
1203 while (curHdl) {
1204 if (curHdl->getEnable()) {
1205 /* update user initial params */
1206 ret = curHdl->updateConfig(true);
1207 RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d update initial user params failed", curHdl->getAlgoType());
1208 ret = curHdl->processing(camgroupParmasArray);
1209 if (ret < 0) {
1210 LOGW_CAMGROUP("algoHdl %d processing failed", curHdl->getAlgoType());
1211 }
1212 }
1213 curHdl = curHdl->getNextHdl();
1214 }
1215 }
1216
1217
1218 EXIT_CAMGROUP_FUNCTION();
1219 return XCAM_RETURN_NO_ERROR;
1220 }
1221
1222 void
relayToHwi(rk_aiq_groupcam_result_t * gc_res)1223 RkAiqCamGroupManager::relayToHwi(rk_aiq_groupcam_result_t* gc_res)
1224 {
1225 rk_aiq_singlecam_result_t* singlecam_res = NULL;
1226 {
1227 int exp_tbl_size = -1;
1228 bool skip_apply_exp = false;
1229 for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
1230 if ((gc_res->_validCamResBits >> i) & 1) {
1231 singlecam_res = &gc_res->_singleCamResultsStatus[i]._singleCamResults;
1232 if (singlecam_res->_fullIspParam->data()->mExposureParams.ptr()) {
1233 int tmp_size = singlecam_res->_fullIspParam->data()->mExposureParams->data()->result.ae_proc_res_rk.exp_set_cnt;
1234 if (exp_tbl_size == -1)
1235 exp_tbl_size = tmp_size;
1236 else if (exp_tbl_size != tmp_size) {
1237 skip_apply_exp = true;
1238 break;
1239 }
1240 }
1241 }
1242 }
1243
1244 for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
1245 // apply exposure directly
1246 if ((gc_res->_validCamResBits >> i) & 1) {
1247 singlecam_res = &gc_res->_singleCamResultsStatus[i]._singleCamResults;
1248 if (!skip_apply_exp) {
1249 SmartPtr<RkAiqFullParams> fullParam = new RkAiqFullParams();
1250 XCAM_ASSERT(fullParam.ptr());
1251 SmartPtr<RkAiqFullParamsProxy> fullParamProxy = new RkAiqFullParamsProxy(fullParam );
1252 XCAM_ASSERT(fullParamProxy.ptr());
1253 fullParamProxy->data()->mExposureParams = singlecam_res->_fullIspParam->data()->mExposureParams;
1254 if (fullParamProxy->data()->mExposureParams.ptr()) {
1255 LOGD_CAMGROUP("camgroup: camId:%d, frameId:%u, exp_tbl_size:%d",
1256 i, gc_res->_frameId,
1257 fullParamProxy->data()->mExposureParams->data()->result.ae_proc_res_rk.exp_set_cnt);
1258 }
1259 mBindAiqsMap[i]->applyAnalyzerResult(fullParamProxy);
1260 }
1261 singlecam_res->_fullIspParam->data()->mExposureParams.release();
1262 }
1263 }
1264 }
1265
1266 for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
1267 if ((gc_res->_validCamResBits >> i) & 1) {
1268 singlecam_res = &gc_res->_singleCamResultsStatus[i]._singleCamResults;
1269 if (singlecam_res->_fullIspParam.ptr()) {
1270 if (mState == CAMGROUP_MANAGER_STARTED) {
1271 LOGD_CAMGROUP("camgroup: relay camId %d params to aiq manager %p para %p!", i,
1272 mBindAiqsMap[i], singlecam_res->_fullIspParam.ptr());
1273 mBindAiqsMap[i]->rkAiqCalcDone(singlecam_res->_fullIspParam);
1274 } else {
1275 LOGD_CAMGROUP("camgroup: apply camId %d params to hwi directly %p para %p!", i,
1276 mBindAiqsMap[i], singlecam_res->_fullIspParam.ptr());
1277 mBindAiqsMap[i]->applyAnalyzerResult(singlecam_res->_fullIspParam);
1278 }
1279 }
1280 }
1281 }
1282 }
1283
1284 XCamReturn
addAlgo(RkAiqAlgoDesComm & algo)1285 RkAiqCamGroupManager::addAlgo(RkAiqAlgoDesComm& algo)
1286 {
1287 ENTER_ANALYZER_FUNCTION();
1288
1289 std::map<int, SmartPtr<RkAiqCamgroupHandle>>* algo_map = getAlgoTypeHandleMap(algo.type);
1290
1291 if (!algo_map) {
1292 LOGE_ANALYZER("do not support this algo type %d !", algo.type);
1293 return XCAM_RETURN_ERROR_FAILED;
1294 }
1295 // TODO, check if exist befor insert ?
1296 std::map<int, SmartPtr<RkAiqCamgroupHandle>>::reverse_iterator rit = algo_map->rbegin();
1297
1298 algo.id = rit->first + 1;
1299
1300 // add to map
1301 SmartPtr<RkAiqCamgroupHandle> new_hdl;
1302 if (algo.type == RK_AIQ_ALGO_TYPE_AE ||
1303 algo.type == RK_AIQ_ALGO_TYPE_AWB) {
1304 new_hdl = new RkAiqCamgroupHandle(&algo, this);
1305 } else {
1306 LOGE_ANALYZER("not supported custom algo type: %d ", algo.type);
1307 return XCAM_RETURN_ERROR_FAILED;
1308 }
1309 new_hdl->setEnable(false);
1310 rit->second->setNextHdl(new_hdl.ptr());
1311 new_hdl->setParentHdl((*algo_map)[0].ptr());
1312
1313 (*algo_map)[algo.id] = new_hdl;
1314
1315 EXIT_ANALYZER_FUNCTION();
1316
1317 return XCAM_RETURN_NO_ERROR;
1318 }
1319
1320 XCamReturn
rmAlgo(int algoType,int id)1321 RkAiqCamGroupManager::rmAlgo(int algoType, int id)
1322 {
1323 ENTER_ANALYZER_FUNCTION();
1324
1325 // can't remove default algos
1326 if (id == 0)
1327 return XCAM_RETURN_NO_ERROR;
1328
1329 SmartPtr<RkAiqCamgroupHandle> def_algo_hdl = getDefAlgoTypeHandle(algoType);
1330 if (!def_algo_hdl.ptr()) {
1331 LOGE_ANALYZER("can't find current type %d algo", algoType);
1332 return XCAM_RETURN_ERROR_FAILED;
1333 }
1334 std::map<int, SmartPtr<RkAiqCamgroupHandle>>* algo_map = getAlgoTypeHandleMap(algoType);
1335 NULL_RETURN_RET(algo_map, XCAM_RETURN_ERROR_FAILED);
1336 std::map<int, SmartPtr<RkAiqCamgroupHandle>>::iterator it = algo_map->find(id);
1337
1338 if (it == algo_map->end()) {
1339 LOGE_ANALYZER("can't find type id <%d, %d> algo", algoType, id);
1340 return XCAM_RETURN_ERROR_FAILED;
1341 }
1342
1343 if (mState == CAMGROUP_MANAGER_STARTED) {
1344 LOGE_ANALYZER("can't remove algo in running state");
1345 return XCAM_RETURN_ERROR_FAILED;
1346 }
1347
1348 RkAiqCamgroupHandle* rmHdl = it->second.ptr();
1349 RkAiqCamgroupHandle* curHdl = def_algo_hdl.ptr();
1350 while (curHdl) {
1351 RkAiqCamgroupHandle* nextHdl = curHdl->getNextHdl();
1352 if (nextHdl == rmHdl) {
1353 curHdl->setNextHdl(nextHdl->getNextHdl());
1354 break;
1355 }
1356 curHdl = nextHdl;
1357 }
1358
1359 algo_map->erase(it);
1360
1361 EXIT_ANALYZER_FUNCTION();
1362
1363 return XCAM_RETURN_NO_ERROR;
1364 }
1365
1366 XCamReturn
enableAlgo(int algoType,int id,bool enable)1367 RkAiqCamGroupManager::enableAlgo(int algoType, int id, bool enable)
1368 {
1369 ENTER_ANALYZER_FUNCTION();
1370
1371 if (mState == CAMGROUP_MANAGER_STARTED) {
1372 LOGE_ANALYZER("can't enable algo in running state");
1373 return XCAM_RETURN_ERROR_FAILED;
1374 }
1375
1376 // get default algotype handle, id should be 0
1377 SmartPtr<RkAiqCamgroupHandle> def_algo_hdl = getDefAlgoTypeHandle(algoType);
1378 if (!def_algo_hdl.ptr()) {
1379 LOGE_ANALYZER("can't find current type %d algo", algoType);
1380 return XCAM_RETURN_ERROR_FAILED;
1381 }
1382 std::map<int, SmartPtr<RkAiqCamgroupHandle>>* algo_map = getAlgoTypeHandleMap(algoType);
1383 NULL_RETURN_RET(algo_map, XCAM_RETURN_ERROR_FAILED);
1384 std::map<int, SmartPtr<RkAiqCamgroupHandle>>::iterator it = algo_map->find(id);
1385
1386 if (it == algo_map->end()) {
1387 LOGE_ANALYZER("can't find type id <%d, %d> algo", algoType, id);
1388 return XCAM_RETURN_ERROR_FAILED;
1389 }
1390
1391 LOGI_ANALYZER("set algo type_id <%d,%d> to %d", algoType, id, enable);
1392
1393 it->second->setEnable(enable);
1394 /* WARNING:
1395 * Be careful when use SmartPtr<RkAiqxxxHandle> = SmartPtr<RkAiqHandle>
1396 * if RkAiqxxxHandle is derived from multiple RkAiqHandle,
1397 * the ptr of RkAiqxxxHandle and RkAiqHandle IS NOT the same
1398 * (RkAiqHandle ptr = RkAiqxxxHandle ptr + offset), but seams like
1399 * SmartPtr do not deal with this correctly.
1400 */
1401
1402 if (enable) {
1403 if (mState >= CAMGROUP_MANAGER_PREPARED) {
1404 RkAiqManager* aiqManager = (mBindAiqsMap.begin())->second;
1405 RkAiqCore* aiqCore = aiqManager->mRkAiqAnalyzer.ptr();
1406 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &aiqCore->mAlogsComSharedParams;
1407 it->second->prepare(aiqCore);
1408 }
1409 }
1410
1411 int enable_cnt = 0;
1412 RkAiqCamgroupHandle* curHdl = def_algo_hdl.ptr();
1413
1414 while (curHdl) {
1415 if (curHdl->getEnable()) {
1416 enable_cnt++;
1417 }
1418 curHdl = curHdl->getNextHdl();
1419 }
1420
1421 LOGI_ANALYZER("algo type %d enabled count :%d", algoType, enable_cnt);
1422
1423 EXIT_ANALYZER_FUNCTION();
1424
1425 return XCAM_RETURN_NO_ERROR;
1426 }
1427
1428 bool
getAxlibStatus(int algoType,int id)1429 RkAiqCamGroupManager::getAxlibStatus(int algoType, int id)
1430 {
1431 std::map<int, SmartPtr<RkAiqCamgroupHandle>>* algo_map = getAlgoTypeHandleMap(algoType);
1432 NULL_RETURN_RET(algo_map, false);
1433 std::map<int, SmartPtr<RkAiqCamgroupHandle>>::iterator it = algo_map->find(id);
1434
1435 if (it == algo_map->end()) {
1436 LOGE_ANALYZER("can't find type id <%d, %d> algo", algoType, id);
1437 return false;
1438 }
1439
1440 LOGD_ANALYZER("algo type id <%d,%d> status %s", algoType, id,
1441 it->second->getEnable() ? "enable" : "disable");
1442
1443 return it->second->getEnable();
1444 }
1445
1446 RkAiqAlgoContext*
getEnabledAxlibCtx(const int algo_type)1447 RkAiqCamGroupManager::getEnabledAxlibCtx(const int algo_type)
1448 {
1449 if (algo_type <= RK_AIQ_ALGO_TYPE_NONE ||
1450 algo_type >= RK_AIQ_ALGO_TYPE_MAX)
1451 return NULL;
1452
1453 std::map<int, SmartPtr<RkAiqCamgroupHandle>>* algo_map = getAlgoTypeHandleMap(algo_type);
1454 std::map<int, SmartPtr<RkAiqCamgroupHandle>>::reverse_iterator rit = algo_map->rbegin();
1455 if (rit != algo_map->rend() && rit->second->getEnable())
1456 return rit->second->getAlgoCtx();
1457 else
1458 return NULL;
1459 }
1460
1461 RkAiqAlgoContext*
getAxlibCtx(const int algo_type,const int lib_id)1462 RkAiqCamGroupManager::getAxlibCtx(const int algo_type, const int lib_id)
1463 {
1464 if (algo_type <= RK_AIQ_ALGO_TYPE_NONE ||
1465 algo_type >= RK_AIQ_ALGO_TYPE_MAX)
1466 return NULL;
1467
1468 std::map<int, SmartPtr<RkAiqCamgroupHandle>>* algo_map = getAlgoTypeHandleMap(algo_type);
1469
1470 std::map<int, SmartPtr<RkAiqCamgroupHandle>>::iterator it = algo_map->find(lib_id);
1471
1472 if (it != algo_map->end()) {
1473 return it->second->getAlgoCtx();
1474 }
1475
1476 EXIT_ANALYZER_FUNCTION();
1477
1478 return NULL;
1479 }
1480
1481 RkAiqCamgroupHandle*
getAiqCamgroupHandle(const int algo_type,const int lib_id)1482 RkAiqCamGroupManager::getAiqCamgroupHandle(const int algo_type, const int lib_id)
1483 {
1484 if (algo_type <= RK_AIQ_ALGO_TYPE_NONE ||
1485 algo_type >= RK_AIQ_ALGO_TYPE_MAX)
1486 return NULL;
1487
1488 std::map<int, SmartPtr<RkAiqCamgroupHandle>>* algo_map = getAlgoTypeHandleMap(algo_type);
1489
1490 if (!algo_map)
1491 return NULL;
1492
1493 std::map<int, SmartPtr<RkAiqCamgroupHandle>>::iterator it = algo_map->find(0);
1494
1495 if (it != algo_map->end()) {
1496 return it->second.ptr();
1497 }
1498
1499 EXIT_ANALYZER_FUNCTION();
1500
1501 return NULL;
1502 }
1503
1504 void
setVicapReady(rk_aiq_hwevt_t * hwevt)1505 RkAiqCamGroupManager::setVicapReady(rk_aiq_hwevt_t* hwevt) {
1506 SmartLock locker (mCamGroupApiSyncMutex);
1507 mVicapReadyMask |= 1 << hwevt->cam_id;
1508 }
1509
1510 bool
isAllVicapReady()1511 RkAiqCamGroupManager::isAllVicapReady() {
1512 SmartLock locker (mCamGroupApiSyncMutex);
1513 return (mVicapReadyMask == mRequiredCamsResMask) ? true : false;
1514 }
1515
1516 XCamReturn
rePrepare()1517 RkAiqCamGroupManager::rePrepare()
1518 {
1519 ENTER_CAMGROUP_FUNCTION();
1520 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1521
1522 if (!needReprepare) {
1523 return ret;
1524 }
1525
1526 if (mBindAiqsMap.empty()) {
1527 LOGD_CAMGROUP("no group cam, bypass");
1528 return XCAM_RETURN_NO_ERROR;
1529 }
1530
1531 // assume all single cam runs same algos
1532 RkAiqManager* aiqManager = (mBindAiqsMap.begin())->second;
1533 RkAiqCore* aiqCore = aiqManager->mRkAiqAnalyzer.ptr();
1534
1535 for (auto algoHdl : mDefAlgoHandleList) {
1536 RkAiqCamgroupHandle* curHdl = algoHdl.ptr();
1537 while (curHdl) {
1538 if (curHdl->getEnable()) {
1539 /* update user initial params */
1540 ret = curHdl->updateConfig(true);
1541 RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d update initial user params failed", curHdl->getAlgoType());
1542 ret = curHdl->prepare(aiqCore);
1543 RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d prepare failed", curHdl->getAlgoType());
1544 }
1545 curHdl = curHdl->getNextHdl();
1546 }
1547 }
1548
1549 needReprepare = false;
1550 _update_done_cond.broadcast();
1551
1552 return ret;
1553 }
1554
1555 XCamReturn
calibTuning(const CamCalibDbV2Context_t * aiqCalib,ModuleNameList & change_name_list)1556 RkAiqCamGroupManager::calibTuning(const CamCalibDbV2Context_t* aiqCalib,
1557 ModuleNameList& change_name_list)
1558 {
1559 ENTER_ANALYZER_FUNCTION();
1560 if (!aiqCalib) {
1561 LOGE_ANALYZER("invalied tuning param\n");
1562 return XCAM_RETURN_ERROR_PARAM;
1563 }
1564
1565 if (mBindAiqsMap.empty()) {
1566 LOGD_CAMGROUP("no group cam, bypass");
1567 return XCAM_RETURN_NO_ERROR;
1568 }
1569
1570 // assume all single cam runs same algos
1571 RkAiqManager* aiqManager = (mBindAiqsMap.begin())->second;
1572 RkAiqCore* aiqCore = aiqManager->mRkAiqAnalyzer.ptr();
1573 if (!aiqCore || !aiqCore->isRunningState()) {
1574 LOGE_ANALYZER("GroupCam not prepared, force update\n");
1575 mCalibv2 = *aiqCalib;
1576 mGroupAlgoCtxCfg.s_calibv2 = &mCalibv2;
1577 needReprepare = true;
1578 } else {
1579 SmartLock lock (_update_mutex);
1580
1581 mCalibv2 = *aiqCalib;
1582 mGroupAlgoCtxCfg.s_calibv2 = &mCalibv2;
1583 /* optimization the issue that first calibTuning don't take effect */
1584 aiqCore->mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_UPDATECALIB;
1585 needReprepare = true;
1586
1587 while (needReprepare == true) {
1588 _update_done_cond.timedwait(_update_mutex, 100000ULL);
1589 }
1590 }
1591
1592 return XCAM_RETURN_NO_ERROR;
1593 }
1594
1595 XCamReturn
syncSingleCamResultWithMaster(rk_aiq_groupcam_result_t * gc_res)1596 RkAiqCamGroupManager::syncSingleCamResultWithMaster(rk_aiq_groupcam_result_t* gc_res)
1597 {
1598 #define SYNC_WITH_MASTER(lc, BC) \
1599 { \
1600 if (!getAlgoTypeHandleMap(RK_AIQ_ALGO_TYPE_##BC)) { \
1601 if (scam_aiqParams->m##lc##Params.ptr() && \
1602 scam_aiqParams->m##lc##Params->data().ptr() && \
1603 masterCamAiqParams->m##lc##Params.ptr() && \
1604 masterCamAiqParams->m##lc##Params->data().ptr()) { \
1605 scam_aiqParams->m##lc##Params->data()->result = \
1606 masterCamAiqParams->m##lc##Params->data()->result; \
1607 } \
1608 } \
1609 } \
1610
1611 if (!gc_res)
1612 return XCAM_RETURN_ERROR_PARAM;
1613
1614 rk_aiq_singlecam_result_t* masterCam_res = \
1615 &gc_res->_singleCamResultsStatus[0]._singleCamResults;
1616 if (!masterCam_res->_fullIspParam.ptr() )
1617 return XCAM_RETURN_ERROR_PARAM;
1618 RkAiqFullParams* masterCamAiqParams = masterCam_res->_fullIspParam->data().ptr();
1619 if (!masterCamAiqParams)
1620 return XCAM_RETURN_ERROR_PARAM;
1621
1622 for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) {
1623 if (!((gc_res->_validCamResBits >> i) & 1))
1624 continue;
1625
1626 rk_aiq_singlecam_result_status_t* singleCamStatus = \
1627 &gc_res->_singleCamResultsStatus[i];
1628 rk_aiq_singlecam_result_t* singleCamRes = &singleCamStatus->_singleCamResults;
1629 if (!singleCamRes->_fullIspParam.ptr())
1630 continue;
1631 RkAiqFullParams* scam_aiqParams = singleCamRes->_fullIspParam->data().ptr();
1632 if (!scam_aiqParams)
1633 continue;
1634
1635 SYNC_WITH_MASTER(Aec, AE);
1636 SYNC_WITH_MASTER(Awb, AWB);
1637 // SYNC_WITH_MASTER(AwbGain, AWBGAIN);
1638 SYNC_WITH_MASTER(Af, AF);
1639 SYNC_WITH_MASTER(Dpcc, ADPCC);
1640 SYNC_WITH_MASTER(Merge, AMERGE);
1641 SYNC_WITH_MASTER(Blc, ABLC);
1642 SYNC_WITH_MASTER(Gic, AGIC);
1643 SYNC_WITH_MASTER(Debayer, ADEBAYER);
1644 SYNC_WITH_MASTER(Lut3d, A3DLUT);
1645 SYNC_WITH_MASTER(Dehaze, ADHAZ);
1646 SYNC_WITH_MASTER(Agamma, AGAMMA);
1647 SYNC_WITH_MASTER(Adegamma, ADEGAMMA);
1648 SYNC_WITH_MASTER(Wdr, AWDR);
1649 SYNC_WITH_MASTER(Csm, ACSM);
1650 SYNC_WITH_MASTER(Cgc, ACGC);
1651 SYNC_WITH_MASTER(Gain, AGAIN);
1652 SYNC_WITH_MASTER(Cp, ACP);
1653 SYNC_WITH_MASTER(Ie, AIE);
1654 SYNC_WITH_MASTER(Lsc, ALSC);
1655
1656 if (CHECK_ISP_HW_V20()) {
1657 SYNC_WITH_MASTER(Tnr, AMFNR);
1658 SYNC_WITH_MASTER(Ynr, AYNR);
1659 SYNC_WITH_MASTER(Uvnr, ACNR);
1660 SYNC_WITH_MASTER(Sharpen, ASHARP);
1661 // SYNC_WITH_MASTER(Edgeflt, AEDGEFLT);
1662 SYNC_WITH_MASTER(Fec, AFEC);
1663 SYNC_WITH_MASTER(Orb, AORB);
1664 SYNC_WITH_MASTER(Tmo, ATMO);
1665 SYNC_WITH_MASTER(Rawnr, ARAWNR);
1666 SYNC_WITH_MASTER(Fec, AFEC);
1667 }
1668
1669 // ispv21
1670 if (CHECK_ISP_HW_V21()) {
1671 SYNC_WITH_MASTER(Drc, ADRC);
1672 SYNC_WITH_MASTER(AwbV21, AWB);
1673 SYNC_WITH_MASTER(YnrV21, AYNR);
1674 SYNC_WITH_MASTER(CnrV21, ACNR);
1675 SYNC_WITH_MASTER(SharpenV21, ASHARP);
1676 SYNC_WITH_MASTER(BaynrV21, ARAWNR);
1677 }
1678
1679 // ispv3x
1680 if (CHECK_ISP_HW_V3X()) {
1681 SYNC_WITH_MASTER(Drc, ADRC);
1682 SYNC_WITH_MASTER(AwbV3x, AWB);
1683 SYNC_WITH_MASTER(BlcV21, ABLC);
1684 SYNC_WITH_MASTER(AfV3x, AF);
1685 SYNC_WITH_MASTER(BaynrV3x, ARAWNR);
1686 SYNC_WITH_MASTER(YnrV3x, AYNR);
1687 SYNC_WITH_MASTER(CnrV3x, ACNR);
1688 SYNC_WITH_MASTER(SharpenV3x, ASHARP);
1689 SYNC_WITH_MASTER(CacV3x, ACAC);
1690 SYNC_WITH_MASTER(GainV3x, AGAIN);
1691 SYNC_WITH_MASTER(TnrV3x, AMFNR);
1692 SYNC_WITH_MASTER(Fec, AFEC);
1693 }
1694
1695 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1696 SYNC_WITH_MASTER(BlcV32, ABLC);
1697 SYNC_WITH_MASTER(CacV32, ACAC);
1698 SYNC_WITH_MASTER(DebayerV32, ADEBAYER);
1699 SYNC_WITH_MASTER(CcmV32, ACCM);
1700 SYNC_WITH_MASTER(BaynrV32, ARAWNR);
1701 SYNC_WITH_MASTER(YnrV32, AYNR);
1702 SYNC_WITH_MASTER(CnrV32, ACNR);
1703 SYNC_WITH_MASTER(SharpV32, ASHARP);
1704 SYNC_WITH_MASTER(AwbV32, AWB);
1705 SYNC_WITH_MASTER(TnrV32, AMFNR);
1706 SYNC_WITH_MASTER(GainV3x, AGAIN);
1707 SYNC_WITH_MASTER(CcmV32, ACCM);
1708 } else {
1709 SYNC_WITH_MASTER(Ccm, ACCM);
1710 }
1711 }
1712
1713 return XCAM_RETURN_NO_ERROR;
1714 }
1715
1716 XCamReturn
updateCalibDb(const CamCalibDbV2Context_t * newCalibDb)1717 RkAiqCamGroupManager::updateCalibDb(const CamCalibDbV2Context_t* newCalibDb)
1718 {
1719 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1720 auto update_list = std::make_shared<std::list<std::string>>();
1721
1722 update_list->push_back("colorAsGrey");
1723
1724 calibTuning(newCalibDb, update_list);
1725
1726 EXIT_XCORE_FUNCTION();
1727 return XCAM_RETURN_NO_ERROR;
1728 }
1729
1730 } //namespace
1731