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 "RkAiqAnalyzeGroupManager.h"
17
18 #include <algorithm>
19 #include <functional>
20 #include <sstream>
21
22 #include "smart_buffer_priv.h"
23
24 #define ANALYZER_SUBM (0x1)
25
26 namespace RkCam {
27
RkAiqAnalyzerGroup(RkAiqCore * aiqCore,enum rk_aiq_core_analyze_type_e type,const uint64_t flag,const RkAiqGrpConditions_t * grpConds,const bool singleThrd)28 RkAiqAnalyzerGroup::RkAiqAnalyzerGroup(RkAiqCore* aiqCore, enum rk_aiq_core_analyze_type_e type,
29 const uint64_t flag, const RkAiqGrpConditions_t* grpConds,
30 const bool singleThrd)
31 : mAiqCore(aiqCore), mGroupType(type), mDepsFlag(flag) {
32 mUserSetDelayCnts = INT8_MAX;
33 if (grpConds)
34 mGrpConds = *grpConds;
35 if (!singleThrd) {
36 std::stringstream ss;
37 ss << "g-" << std::hex << mGroupType << std::hex << ":" << mDepsFlag;
38 mRkAiqGroupMsgHdlTh = new RkAiqAnalyzeGroupMsgHdlThread(ss.str().c_str(), this);
39 } else {
40 mRkAiqGroupMsgHdlTh = nullptr;
41 }
42 }
43
start()44 XCamReturn RkAiqAnalyzerGroup::start() {
45 if (mRkAiqGroupMsgHdlTh.ptr()) {
46 mRkAiqGroupMsgHdlTh->triger_start();
47 mRkAiqGroupMsgHdlTh->start();
48 }
49
50 return XCAM_RETURN_NO_ERROR;
51 }
52
msgReduction(std::map<uint32_t,GroupMessage> & msgMap)53 void RkAiqAnalyzerGroup::msgReduction(std::map<uint32_t, GroupMessage>& msgMap) {
54 // TODO(Cody): Workaround for current implementation
55 // Should let message thread handle the reduction
56 if (!mGroupMsgMap.empty()) {
57 const auto originalSize = mGroupMsgMap.size();
58 const int numToErase = originalSize - 2;
59 if (numToErase > 0) {
60 int32_t unreadyFlag = mDepsFlag & ~mGroupMsgMap.begin()->second.msg_flags;
61 // print missing params
62 std::string missing_conds;
63 uint32_t i = 0;
64 while (unreadyFlag) {
65 if (unreadyFlag % 2) {
66 missing_conds.append(MessageType2Str[i]);
67 missing_conds.append(",");
68 }
69 unreadyFlag >>= 1;
70 i++;
71 }
72 LOGW_ANALYZER_SUBM(ANALYZER_SUBM,
73 "camId: %d, group(%s): id[%d] map size is %d, erase %d, element, missing conditions: %s",
74 mAiqCore->mAlogsComSharedParams.mCamPhyId,
75 AnalyzerGroupType2Str[mGroupType], mGroupMsgMap.begin()->first,
76 originalSize, numToErase,
77 missing_conds.c_str());
78
79 auto eraseIter = mGroupMsgMap.begin();
80 std::advance(eraseIter, numToErase);
81 mGroupMsgMap.erase(mGroupMsgMap.begin(), eraseIter);
82 }
83 }
84 }
85
pushMsg(RkAiqCoreVdBufMsg & msg)86 bool RkAiqAnalyzerGroup::pushMsg(RkAiqCoreVdBufMsg& msg) {
87 //msgReduction(mGroupMsgMap);
88 if (mRkAiqGroupMsgHdlTh.ptr()) {
89 mRkAiqGroupMsgHdlTh->push_msg(msg);
90 }
91 return true;
92 }
93
getMsgDelayCnt(XCamMessageType & msg_id)94 int8_t RkAiqAnalyzerGroup::getMsgDelayCnt(XCamMessageType &msg_id) {
95 uint32_t i = 0;
96 int8_t delayCnt = 0;
97 for (i = 0; i < mGrpConds.size; i++) {
98 if (mGrpConds.conds[i].cond == msg_id) {
99 delayCnt = mGrpConds.conds[i].delay;
100 if (delayCnt != 0 && mUserSetDelayCnts != INT8_MAX)
101 delayCnt = mUserSetDelayCnts;
102 return delayCnt;
103 }
104 }
105
106 if (i == mGrpConds.size)
107 LOGE_ANALYZER_SUBM(ANALYZER_SUBM, "don't match msgId(0x%x) in mGrpConds", msg_id);
108
109 return 0;
110 }
111
setDelayCnts(int8_t delayCnts)112 void RkAiqAnalyzerGroup::setDelayCnts(int8_t delayCnts) {
113 mUserSetDelayCnts = delayCnts;
114 }
115
setVicapScaleFlag(bool mode)116 void RkAiqAnalyzerGroup::setVicapScaleFlag(bool mode) {
117 mVicapScaleStart = mode;
118 }
119
msgHandle(RkAiqCoreVdBufMsg * msg)120 bool RkAiqAnalyzerGroup::msgHandle(RkAiqCoreVdBufMsg* msg) {
121 if (!((1ULL << msg->msg_id) & mDepsFlag)) {
122 return true;
123 }
124
125 XCamMessageType msg_id = msg->msg_id;
126 uint32_t delayCnt = getMsgDelayCnt(msg_id);
127 if (msg->frame_id == 0 && getAiqCore()->getTbInfo()->is_pre_aiq) {
128 delayCnt = 0;
129 }
130 uint32_t userId = msg->frame_id + delayCnt;
131 GroupMessage& msgWrapper = mGroupMsgMap[userId];
132
133 msgWrapper.msg_flags |= 1ULL << msg->msg_id;
134 //msgWrapper.msgList.push_back(msg);
135 int& msg_cnts = msgWrapper.msg_cnts;
136 msgWrapper.msgList[msg_cnts++] = *msg;
137
138 LOGD_ANALYZER_SUBM(ANALYZER_SUBM,
139 "camId: %d, group(%s): id[%d] push msg(%s), msg delayCnt(%d), map size is %d",
140 mAiqCore->mAlogsComSharedParams.mCamPhyId,
141 AnalyzerGroupType2Str[mGroupType], msg->frame_id,
142 MessageType2Str[msg->msg_id], delayCnt, mGroupMsgMap.size());
143
144 uint64_t msg_flags = msgWrapper.msg_flags;
145 if (!(msg_flags ^ mDepsFlag)) {
146 std::array<RkAiqCoreVdBufMsg, MAX_MESSAGES>& msgList = msgWrapper.msgList;
147 mHandler(msgList, msg_cnts, userId, getType());
148 #if 0
149 for (auto it = mGroupMsgMap.begin(); it != mGroupMsgMap.end();) {
150 if ((*it).first <= userId) {
151 it = mGroupMsgMap.erase(it);
152 } else {
153 break;//it++;
154 }
155 }
156 #else
157 std::map<uint32_t, GroupMessage>::iterator itup = mGroupMsgMap.upper_bound(userId);
158 mGroupMsgMap.erase(mGroupMsgMap.begin(), itup);
159 #endif
160 LOGD_ANALYZER("%s, group %s erase frame(%d) msg map\n", __FUNCTION__, AnalyzerGroupType2Str[mGroupType], userId);
161 } else {
162 msgReduction(mGroupMsgMap);
163 return true;
164 }
165
166 return true;
167 }
168
stop()169 XCamReturn RkAiqAnalyzerGroup::stop() {
170 if (mRkAiqGroupMsgHdlTh.ptr()) {
171 mRkAiqGroupMsgHdlTh->triger_stop();
172 mRkAiqGroupMsgHdlTh->stop();
173 }
174 mGroupMsgMap.clear();
175
176 return XCAM_RETURN_NO_ERROR;
177 }
178
setDepsFlagAndClearMap(uint64_t new_deps)179 void RkAiqAnalyzerGroup::setDepsFlagAndClearMap(uint64_t new_deps)
180 {
181 mDepsFlag = new_deps;
182 if (mGroupMsgMap.size()) {
183 mGroupMsgMap.clear();
184 }
185 }
186
loop()187 bool RkAiqAnalyzeGroupMsgHdlThread::loop() {
188 ENTER_ANALYZER_FUNCTION();
189
190 const static int32_t timeout = -1;
191 bool res = false;
192
193 //XCAM_STATIC_FPS_CALCULATION(GROUPMSGTH, 100);
194 RkAiqCoreVdBufMsg msg;
195 XCamReturn ret = mMsgsQueue.pop(msg, timeout);
196 if (ret) {
197 LOGW_ANALYZER_SUBM(ANALYZER_SUBM, "RkAiqAnalyzeGroupMsgHdlThread got empty msg, stop thread");
198 return false;
199 }
200
201 for (auto& grp : mHandlerGroups) {
202 handleCalibUpdate(grp);
203 }
204
205 for (auto& grp : mHandlerGroups) {
206 res = grp->msgHandle(&msg);
207 }
208
209 EXIT_ANALYZER_FUNCTION();
210
211 return res;
212 }
213
handleCalibUpdate(RkAiqAnalyzerGroup * grp)214 XCamReturn RkAiqAnalyzeGroupMsgHdlThread::handleCalibUpdate(RkAiqAnalyzerGroup* grp)
215 {
216 ENTER_ANALYZER_FUNCTION();
217 XCamReturn ret = XCAM_RETURN_NO_ERROR;
218
219 if (grp && grp->getAiqCore()) {
220 grp->getAiqCore()->updateCalib(grp->getType());
221 }
222
223 EXIT_ANALYZER_FUNCTION();
224 return ret;
225 }
226
RkAiqAnalyzeGroupManager(RkAiqCore * aiqCore,bool single_thread)227 RkAiqAnalyzeGroupManager::RkAiqAnalyzeGroupManager(RkAiqCore* aiqCore, bool single_thread)
228 : mAiqCore(aiqCore), mSingleThreadMode(single_thread), mMsgThrd(nullptr) {}
229
getGrpDeps(rk_aiq_core_analyze_type_e group)230 uint64_t RkAiqAnalyzeGroupManager::getGrpDeps(rk_aiq_core_analyze_type_e group) {
231 auto res = std::find_if(std::begin(mGroupMap), std::end(mGroupMap),
232 [&group](const std::pair<uint64_t, SmartPtr<RkAiqAnalyzerGroup>>& grp) {
233 return group == grp.second->getType();
234 });
235 if (res != std::end(mGroupMap)) {
236 return res->second->getDepsFlag();
237 }
238
239 return 0;
240 }
241
setGrpDeps(rk_aiq_core_analyze_type_e group,uint64_t new_deps)242 XCamReturn RkAiqAnalyzeGroupManager::setGrpDeps(rk_aiq_core_analyze_type_e group,
243 uint64_t new_deps) {
244 auto res = std::find_if(std::begin(mGroupMap), std::end(mGroupMap),
245 [&group](const std::pair<uint64_t, SmartPtr<RkAiqAnalyzerGroup>>& grp) {
246 return group == grp.second->getType();
247 });
248 if (res != std::end(mGroupMap)) {
249 uint64_t old_deps = res->second->getDepsFlag();
250
251 if (old_deps == new_deps)
252 return XCAM_RETURN_NO_ERROR;
253
254 res->second->setDepsFlag(new_deps);
255 return XCAM_RETURN_NO_ERROR;
256 }
257
258 return XCAM_RETURN_ERROR_PARAM;
259 }
260
firstAnalyze()261 XCamReturn RkAiqAnalyzeGroupManager::firstAnalyze() {
262
263 RkAiqCore::RkAiqAlgosGroupShared_t* shared = nullptr;
264 for (auto& it : mGroupMap) {
265 uint64_t grpMask = mAiqCore->grpId2GrpMask(it.second->getType());
266 mAiqCore->getGroupSharedParams(grpMask, shared);
267 XCAM_ASSERT(shared != nullptr);
268 mAiqCore->groupAnalyze(it.second->getType(), shared);
269 }
270 return XCAM_RETURN_NO_ERROR;
271 }
272
start()273 XCamReturn RkAiqAnalyzeGroupManager::start() {
274 if (mSingleThreadMode) {
275 mMsgThrd->triger_start();
276 mMsgThrd->start();
277 } else {
278 for (auto& it : mGroupMap) {
279 it.second->start();
280 }
281 }
282
283 return XCAM_RETURN_NO_ERROR;
284 }
285
stop()286 XCamReturn RkAiqAnalyzeGroupManager::stop() {
287 if (mSingleThreadMode) {
288 mMsgThrd->triger_stop();
289 mMsgThrd->stop();
290 }
291
292 for (auto& it : mGroupMap) {
293 it.second->stop();
294 }
295
296 return XCAM_RETURN_NO_ERROR;
297 }
298
groupMessageHandler(std::array<RkAiqCoreVdBufMsg,MAX_MESSAGES> & msgs,int msg_cnts,uint32_t id,uint64_t grpId)299 XCamReturn RkAiqAnalyzeGroupManager::groupMessageHandler(std::array<RkAiqCoreVdBufMsg, MAX_MESSAGES>& msgs,
300 int msg_cnts, uint32_t id, uint64_t grpId) {
301 uint64_t grpMask = mAiqCore->grpId2GrpMask(grpId);
302 RkAiqCore::RkAiqAlgosGroupShared_t* shared = nullptr;
303 mAiqCore->getGroupSharedParams(grpMask, shared);
304 XCAM_ASSERT(shared != nullptr);
305 RkAiqCoreVdBufMsg* vdBufMsg = NULL;
306 shared->frameId = id;
307 RkAiqSofInfoWrapperProxy* sofInfoMsg = nullptr;
308 for (int i = 0; i < msg_cnts; i++) {
309 vdBufMsg = &msgs[i];
310 if (!vdBufMsg || !vdBufMsg->msg.ptr()) continue;
311 switch (vdBufMsg->msg_id) {
312 case XCAM_MESSAGE_SOF_INFO_OK:
313 sofInfoMsg =
314 vdBufMsg->msg.get_cast_ptr<RkAiqSofInfoWrapperProxy>();
315 shared->curExp = sofInfoMsg->data()->curExp->data()->aecExpInfo;
316 shared->preExp = sofInfoMsg->data()->preExp->data()->aecExpInfo;
317 shared->nxtExp = sofInfoMsg->data()->nxtExp->data()->aecExpInfo;
318 shared->sof = sofInfoMsg->data()->sof;
319 break;
320 case XCAM_MESSAGE_ISP_STATS_OK:
321 shared->ispStats = convert_to_XCamVideoBuffer(vdBufMsg->msg);
322 break;
323 case XCAM_MESSAGE_AEC_STATS_OK:
324 {
325 RkAiqAecStatsProxy* aecStats = vdBufMsg->msg.get_cast_ptr<RkAiqAecStatsProxy>();
326 if (aecStats)
327 shared->aecStatsBuf = aecStats->data().ptr();
328 }
329 break;
330 case XCAM_MESSAGE_AWB_STATS_OK:
331 {
332 RkAiqAwbStatsProxy* awbStats = vdBufMsg->msg.get_cast_ptr<RkAiqAwbStatsProxy>();
333 if (awbStats)
334 shared->awbStatsBuf = awbStats->data().ptr();
335 }
336 break;
337 case XCAM_MESSAGE_AF_STATS_OK:
338 {
339 RkAiqAfStatsProxy* afStats = vdBufMsg->msg.get_cast_ptr<RkAiqAfStatsProxy>();
340 if (afStats)
341 shared->afStatsBuf = afStats->data().ptr();
342 }
343 break;
344 case XCAM_MESSAGE_ISP_POLL_SP_OK:
345 shared->sp = convert_to_XCamVideoBuffer(vdBufMsg->msg);
346 break;
347 case XCAM_MESSAGE_ISP_GAIN_OK:
348 shared->ispGain = convert_to_XCamVideoBuffer(vdBufMsg->msg);
349 break;
350 case XCAM_MESSAGE_ISP_POLL_TX_OK:
351 shared->tx = convert_to_XCamVideoBuffer(vdBufMsg->msg);
352 break;
353 case XCAM_MESSAGE_ISPP_GAIN_KG_OK:
354 shared->kgGain = convert_to_XCamVideoBuffer(vdBufMsg->msg);
355 break;
356 case XCAM_MESSAGE_ISPP_GAIN_WR_OK:
357 shared->wrGain = convert_to_XCamVideoBuffer(vdBufMsg->msg);
358 break;
359 case XCAM_MESSAGE_ORB_STATS_OK:
360 shared->orbStats = convert_to_XCamVideoBuffer(vdBufMsg->msg);
361 break;
362 case XCAM_MESSAGE_NR_IMG_OK:
363 shared->nrImg = convert_to_XCamVideoBuffer(vdBufMsg->msg);
364 break;
365 case XCAM_MESSAGE_PDAF_STATS_OK:
366 {
367 RkAiqPdafStatsProxy* pdafStats = vdBufMsg->msg.get_cast_ptr<RkAiqPdafStatsProxy>();
368 if (pdafStats)
369 shared->pdafStatsBuf = pdafStats->data().ptr();
370 }
371 break;
372 case XCAM_MESSAGE_AE_PRE_RES_OK:
373 shared->res_comb.ae_pre_res = convert_to_XCamVideoBuffer(vdBufMsg->msg);
374 break;
375 case XCAM_MESSAGE_AE_PROC_RES_OK:
376 shared->res_comb.ae_proc_res = convert_to_XCamVideoBuffer(vdBufMsg->msg);
377 break;
378 case XCAM_MESSAGE_AWB_PROC_RES_OK:
379 shared->res_comb.awb_proc_res = convert_to_XCamVideoBuffer(vdBufMsg->msg);
380 break;
381 case XCAM_MESSAGE_AMD_PROC_RES_OK:
382 // xCamAmdProcRes = convert_to_XCamVideoBuffer(vdBufMsg->msg);
383 break;
384 case XCAM_MESSAGE_BLC_PROC_RES_OK:
385 shared->res_comb.ablc_proc_res =
386 ((RkAiqAlgoProcResAblc*)vdBufMsg->msg->map())->ablc_proc_res;
387 LOGD_ANALYZER_SUBM(
388 ANALYZER_SUBM, "camId: %d, group: %s: id: %d, blc_r: %d, blc1_r: %d",
389 mAiqCore->mAlogsComSharedParams.mCamPhyId, AnalyzerGroupType2Str[grpId],
390 vdBufMsg->msg->get_sequence(), shared->res_comb.ablc_proc_res->blc_r,
391 shared->res_comb.ablc_proc_res->blc1_r);
392 break;
393 case XCAM_MESSAGE_BLC_V32_PROC_RES_OK:
394 shared->res_comb.ablcV32_proc_res =
395 ((RkAiqAlgoProcResAblcV32*)vdBufMsg->msg->map())->ablcV32_proc_res;
396 LOGD_ANALYZER_SUBM(
397 ANALYZER_SUBM,
398 "camId: %d, group: %s: id: %d, ob_offset: %d, ob_predgain: %f",
399 mAiqCore->mAlogsComSharedParams.mCamPhyId, AnalyzerGroupType2Str[grpId],
400 vdBufMsg->msg->get_sequence(),
401 shared->res_comb.ablcV32_proc_res->isp_ob_offset,
402 shared->res_comb.ablcV32_proc_res->isp_ob_predgain);
403 break;
404 case XCAM_MESSAGE_YNR_V3_PROC_RES_OK:
405 shared->res_comb.aynrV3_proc_res =
406 &((RkAiqAlgoProcResAynrV3*)vdBufMsg->msg->map())->stAynrProcResult;
407 LOGD_ANALYZER_SUBM(ANALYZER_SUBM,
408 "camId: %d, group: %s: id: %d, sigma: %f %f %f %f %f %f %f "
409 "%f %f %f %f %f %f %f %f %f %f ",
410 mAiqCore->mAlogsComSharedParams.mCamPhyId,
411 AnalyzerGroupType2Str[grpId],
412 vdBufMsg->msg->get_sequence(),
413 shared->res_comb.aynrV3_proc_res->stSelect->sigma[0],
414 shared->res_comb.aynrV3_proc_res->stSelect->sigma[1],
415 shared->res_comb.aynrV3_proc_res->stSelect->sigma[2],
416 shared->res_comb.aynrV3_proc_res->stSelect->sigma[3],
417 shared->res_comb.aynrV3_proc_res->stSelect->sigma[4],
418 shared->res_comb.aynrV3_proc_res->stSelect->sigma[5],
419 shared->res_comb.aynrV3_proc_res->stSelect->sigma[6],
420 shared->res_comb.aynrV3_proc_res->stSelect->sigma[7],
421 shared->res_comb.aynrV3_proc_res->stSelect->sigma[8],
422 shared->res_comb.aynrV3_proc_res->stSelect->sigma[9],
423 shared->res_comb.aynrV3_proc_res->stSelect->sigma[10],
424 shared->res_comb.aynrV3_proc_res->stSelect->sigma[11],
425 shared->res_comb.aynrV3_proc_res->stSelect->sigma[12],
426 shared->res_comb.aynrV3_proc_res->stSelect->sigma[13],
427 shared->res_comb.aynrV3_proc_res->stSelect->sigma[14],
428 shared->res_comb.aynrV3_proc_res->stSelect->sigma[15],
429 shared->res_comb.aynrV3_proc_res->stSelect->sigma[16]);
430 break;
431 case XCAM_MESSAGE_YNR_V22_PROC_RES_OK:
432 shared->res_comb.aynrV22_proc_res =
433 &((RkAiqAlgoProcResAynrV22*)vdBufMsg->msg->map())->stAynrProcResult;
434 LOGD_ANALYZER_SUBM(ANALYZER_SUBM,
435 "camId: %d, group: %s: id: %d, sigma: %f %f %f %f %f %f %f "
436 "%f %f %f %f %f %f %f %f %f %f ",
437 mAiqCore->mAlogsComSharedParams.mCamPhyId,
438 AnalyzerGroupType2Str[grpId],
439 vdBufMsg->msg->get_sequence(),
440 shared->res_comb.aynrV22_proc_res->stSelect->sigma[0],
441 shared->res_comb.aynrV22_proc_res->stSelect->sigma[1],
442 shared->res_comb.aynrV22_proc_res->stSelect->sigma[2],
443 shared->res_comb.aynrV22_proc_res->stSelect->sigma[3],
444 shared->res_comb.aynrV22_proc_res->stSelect->sigma[4],
445 shared->res_comb.aynrV22_proc_res->stSelect->sigma[5],
446 shared->res_comb.aynrV22_proc_res->stSelect->sigma[6],
447 shared->res_comb.aynrV22_proc_res->stSelect->sigma[7],
448 shared->res_comb.aynrV22_proc_res->stSelect->sigma[8],
449 shared->res_comb.aynrV22_proc_res->stSelect->sigma[9],
450 shared->res_comb.aynrV22_proc_res->stSelect->sigma[10],
451 shared->res_comb.aynrV22_proc_res->stSelect->sigma[11],
452 shared->res_comb.aynrV22_proc_res->stSelect->sigma[12],
453 shared->res_comb.aynrV22_proc_res->stSelect->sigma[13],
454 shared->res_comb.aynrV22_proc_res->stSelect->sigma[14],
455 shared->res_comb.aynrV22_proc_res->stSelect->sigma[15],
456 shared->res_comb.aynrV22_proc_res->stSelect->sigma[16]);
457 break;
458 case XCAM_MESSAGE_ADEHAZE_STATS_OK:
459 {
460 RkAiqAdehazeStatsProxy* dehazeStats = vdBufMsg->msg.get_cast_ptr<RkAiqAdehazeStatsProxy>();
461 if (dehazeStats)
462 shared->adehazeStatsBuf = dehazeStats->data().ptr();
463 }
464 break;
465 case XCAM_MESSAGE_VICAP_POLL_SCL_OK:
466 {
467 RkAiqVicapRawBufInfo_t *buf_info = (RkAiqVicapRawBufInfo_t *)vdBufMsg->msg->map();
468 shared->scaleRawInfo.bpp = buf_info->bpp;
469 if (buf_info->flags == RK_AIQ_VICAP_SCALE_HDR_MODE_NORMAL) {
470 shared->scaleRawInfo.raw_s = convert_to_XCamVideoBuffer(buf_info->raw_s);
471 } else if (buf_info->flags == RK_AIQ_VICAP_SCALE_HDR_MODE_2_HDR) {
472 shared->scaleRawInfo.raw_l = convert_to_XCamVideoBuffer(buf_info->raw_l);
473 shared->scaleRawInfo.raw_s = convert_to_XCamVideoBuffer(buf_info->raw_s);
474 } else if (buf_info->flags == RK_AIQ_VICAP_SCALE_HDR_MODE_3_HDR) {
475 shared->scaleRawInfo.raw_l = convert_to_XCamVideoBuffer(buf_info->raw_l);
476 shared->scaleRawInfo.raw_s = convert_to_XCamVideoBuffer(buf_info->raw_s);
477 shared->scaleRawInfo.raw_m = convert_to_XCamVideoBuffer(buf_info->raw_m);
478 }
479 break;
480 }
481 default:
482 break;
483 }
484 }
485 //msgs.clear();
486
487 mAiqCore->groupAnalyze(grpId, shared);
488 //msgs.clear();
489
490 if (shared->aecStatsBuf) {
491 shared->aecStatsBuf = nullptr;
492 }
493 if (shared->awbStatsBuf) {
494 shared->awbStatsBuf = nullptr;
495 }
496 if (shared->afStatsBuf) {
497 shared->afStatsBuf = nullptr;
498 }
499 if (shared->ispStats) {
500 shared->ispStats->unref(shared->ispStats);
501 shared->ispStats = nullptr;
502 }
503 if (shared->tx) {
504 shared->tx->unref(shared->tx);
505 shared->tx = nullptr;
506 }
507 if (shared->sp) {
508 shared->sp->unref(shared->sp);
509 shared->sp = nullptr;
510 }
511 if (shared->ispGain) {
512 shared->ispGain->unref(shared->ispGain);
513 shared->ispGain = nullptr;
514 }
515 if (shared->kgGain) {
516 shared->kgGain->unref(shared->kgGain);
517 shared->kgGain = nullptr;
518 }
519 if (shared->wrGain) {
520 shared->wrGain->unref(shared->wrGain);
521 shared->wrGain = nullptr;
522 }
523 if (shared->orbStats) {
524 shared->orbStats->unref(shared->orbStats);
525 shared->orbStats = nullptr;
526 }
527 if (shared->nrImg) {
528 shared->nrImg->unref(shared->nrImg);
529 shared->nrImg = nullptr;
530 }
531 if (shared->pdafStatsBuf) {
532 shared->pdafStatsBuf = nullptr;
533 }
534 if (shared->res_comb.ae_pre_res) {
535 shared->res_comb.ae_pre_res->unref(shared->res_comb.ae_pre_res);
536 shared->res_comb.ae_pre_res = nullptr;
537 }
538 if (shared->res_comb.ae_proc_res) {
539 shared->res_comb.ae_proc_res->unref(shared->res_comb.ae_proc_res);
540 shared->res_comb.ae_proc_res = nullptr;
541 }
542 if (shared->res_comb.awb_proc_res) {
543 shared->res_comb.awb_proc_res->unref(shared->res_comb.awb_proc_res);
544 shared->res_comb.awb_proc_res = nullptr;
545 }
546 if (shared->adehazeStatsBuf) {
547 shared->adehazeStatsBuf = nullptr;
548 }
549 if (shared->scaleRawInfo.raw_l) {
550 shared->scaleRawInfo.raw_l->unref(shared->scaleRawInfo.raw_l);
551 shared->scaleRawInfo.raw_l = nullptr;
552 }
553 if (shared->scaleRawInfo.raw_m) {
554 shared->scaleRawInfo.raw_m->unref(shared->scaleRawInfo.raw_m);
555 shared->scaleRawInfo.raw_m = nullptr;
556 }
557 if (shared->scaleRawInfo.raw_s) {
558 shared->scaleRawInfo.raw_s->unref(shared->scaleRawInfo.raw_s);
559 shared->scaleRawInfo.raw_s = nullptr;
560 }
561
562 return XCAM_RETURN_NO_ERROR;
563 }
564
565 #if defined(RKAIQ_HAVE_THUMBNAILS)
thumbnailsGroupMessageHandler(std::array<RkAiqCoreVdBufMsg,MAX_MESSAGES> & msgs,int msg_cnts,uint32_t id,uint64_t grpId)566 XCamReturn RkAiqAnalyzeGroupManager::thumbnailsGroupMessageHandler(
567 std::array<RkAiqCoreVdBufMsg, MAX_MESSAGES>& msgs, int msg_cnts, uint32_t id, uint64_t grpId) {
568 //XCAM_STATIC_FPS_CALCULATION(THUMBHANDLER, 100);
569 rkaiq_image_source_t thumbnailsSrc;
570 RkAiqCoreVdBufMsg* vdBufMsg = &msgs.front();
571
572 if (!vdBufMsg) return XCAM_RETURN_BYPASS;
573
574 if (vdBufMsg->msg_id == XCAM_MESSAGE_ISP_POLL_SP_OK) {
575 XCamVideoBuffer* sp = NULL;
576 sp = convert_to_XCamVideoBuffer(vdBufMsg->msg);
577
578 thumbnailsSrc.frame_id = vdBufMsg->frame_id;
579 thumbnailsSrc.src_type = RKISP20_STREAM_SP;
580 thumbnailsSrc.image_source = sp;
581 } else if (vdBufMsg->msg_id == XCAM_MESSAGE_NR_IMG_OK) {
582 XCamVideoBuffer* nrImg = NULL;
583 nrImg = convert_to_XCamVideoBuffer(vdBufMsg->msg);
584
585 thumbnailsSrc.frame_id = vdBufMsg->frame_id;
586 thumbnailsSrc.src_type = RKISP20_STREAM_NR;
587 thumbnailsSrc.image_source = nrImg;
588 }
589
590 mAiqCore->thumbnailsGroupAnalyze(thumbnailsSrc);
591
592 return XCAM_RETURN_NO_ERROR;
593 }
594 #endif
595
parseAlgoGroup(const struct RkAiqAlgoDesCommExt * algoDes)596 void RkAiqAnalyzeGroupManager::parseAlgoGroup(const struct RkAiqAlgoDesCommExt* algoDes) {
597 uint64_t disAlgosMask = mAiqCore->getInitDisAlgosMask();
598 if (mSingleThreadMode) {
599 mMsgThrd = new RkAiqAnalyzeGroupMsgHdlThread("GrpMsgThrd", nullptr);
600 XCAM_ASSERT(mMsgThrd.ptr() != nullptr);
601 }
602 for (size_t i = 0; algoDes[i].des != NULL; i++) {
603 int algo_type = algoDes[i].des->type;
604 if ((1ULL << algo_type) & disAlgosMask)
605 continue;
606
607 if (algoDes[i].grpConds.size > MAX_MESSAGES)
608 LOGE("group conds > %d, should increase MAX_MESSAGES", MAX_MESSAGES);
609
610 uint64_t deps_flag = 0;
611 for (size_t j = 0; j < algoDes[i].grpConds.size; j++)
612 deps_flag |= 1ULL << algoDes[i].grpConds.conds[j].cond;
613 rk_aiq_core_analyze_type_e group = algoDes[i].group;
614 if (mAiqCore->getCurAlgoTypeHandle(algo_type)) {
615 mGroupAlgoListMap[group].push_back(*mAiqCore->getCurAlgoTypeHandle(algo_type));
616 mGroupAlgoListMap[RK_AIQ_CORE_ANALYZE_ALL].push_back(*mAiqCore->getCurAlgoTypeHandle(algo_type));
617 }
618 if (mGroupMap.count(group)) {
619 continue;
620 }
621 mGroupMap[group] = new RkAiqAnalyzerGroup(mAiqCore, group, deps_flag,
622 &algoDes[i].grpConds, mSingleThreadMode);
623 if (mSingleThreadMode) mMsgThrd->add_group(mGroupMap[group].ptr());
624 #if defined(RKAIQ_HAVE_THUMBNAILS)
625 if (group == RK_AIQ_CORE_ANALYZE_THUMBNAILS) {
626 mGroupMap[group]->setConcreteHandler(
627 std::bind(&RkAiqAnalyzeGroupManager::thumbnailsGroupMessageHandler, this,
628 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
629 } else {
630 mGroupMap[group]->setConcreteHandler(
631 std::bind(&RkAiqAnalyzeGroupManager::groupMessageHandler, this,
632 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
633 }
634 #else
635 mGroupMap[group]->setConcreteHandler(
636 std::bind(&RkAiqAnalyzeGroupManager::groupMessageHandler, this, std::placeholders::_1,
637 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
638 #endif
639 LOGD_ANALYZER_SUBM(ANALYZER_SUBM, "Created group %" PRIx64 " for dep flags %" PRIx64"", (uint64_t)group, deps_flag);
640 }
641 }
642
handleMessage(RkAiqCoreVdBufMsg & msg)643 XCamReturn RkAiqAnalyzeGroupManager::handleMessage(RkAiqCoreVdBufMsg& msg) {
644 //XCAM_STATIC_FPS_CALCULATION(HANDLEMSG, 100);
645 if (mSingleThreadMode) {
646 mMsgThrd->push_msg(msg);
647 LOGD_ANALYZER_SUBM(ANALYZER_SUBM, "camId: %d, Handle message(%s) id[%d]",
648 mAiqCore->mAlogsComSharedParams.mCamPhyId,
649 MessageType2Str[msg.msg_id],
650 msg.frame_id);
651 } else {
652 for (auto& it : mGroupMap) {
653 if ((it.second->getDepsFlag() & (1ULL << msg.msg_id)) != 0) {
654 LOGD_ANALYZER_SUBM(ANALYZER_SUBM,
655 "camId: %d, Handle message(%s) id[%d] on group(%s), flags %" PRIx64 "",
656 mAiqCore->mAlogsComSharedParams.mCamPhyId,
657 MessageType2Str[msg.msg_id], msg.frame_id,
658 AnalyzerGroupType2Str[it.second->getType()], it.second->getDepsFlag());
659
660 it.second->pushMsg(msg);
661 }
662 }
663 }
664 return XCAM_RETURN_NO_ERROR;
665 }
666
setDelayCnts(int delayCnts)667 void RkAiqAnalyzeGroupManager::setDelayCnts(int delayCnts) {
668 for (auto& it : mGroupMap) {
669 it.second->setDelayCnts(delayCnts);
670 }
671 }
672
673 } // namespace RkCam
674