xref: /OK3568_Linux_fs/external/camera_engine_rkaiq/rkaiq/aiq_core/algo_handlers/RkAiqAgicHandle.cpp (revision 4882a59341e53eb6f0b4789bf948001014eff981) 
1 /*
2  * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #include "RkAiqAgicHandle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAgicHandleInt);
23 
init()24 void RkAiqAgicHandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAgic());
29     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAgic());
30     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAgic());
31 
32     EXIT_ANALYZER_FUNCTION();
33 }
34 
updateConfig(bool needSync)35 XCamReturn RkAiqAgicHandleInt::updateConfig(bool needSync) {
36     ENTER_ANALYZER_FUNCTION();
37 
38     XCamReturn ret = XCAM_RETURN_NO_ERROR;
39 #ifndef DISABLE_HANDLE_ATTRIB
40     if (needSync) mCfgMutex.lock();
41     // if something changed
42     if (updateAttV1) {
43         mCurAttV1   = mNewAttV1;
44         rk_aiq_uapi_agic_v1_SetAttrib(mAlgoCtx, &mCurAttV1, false);
45         updateAttV1 = false;
46         sendSignal(mCurAttV1.sync.sync_mode);
47     }
48     if (updateAttV2) {
49         mCurAttV2   = mNewAttV2;
50         rk_aiq_uapi_agic_v2_SetAttrib(mAlgoCtx, &mCurAttV2, false);
51         updateAttV2 = false;
52         sendSignal(mCurAttV2.sync.sync_mode);
53     }
54     if (needSync) mCfgMutex.unlock();
55 #endif
56     EXIT_ANALYZER_FUNCTION();
57     return ret;
58 }
59 
setAttribV1(const rkaiq_gic_v1_api_attr_t * att)60 XCamReturn RkAiqAgicHandleInt::setAttribV1(const rkaiq_gic_v1_api_attr_t* att) {
61     ENTER_ANALYZER_FUNCTION();
62 
63     XCamReturn ret = XCAM_RETURN_NO_ERROR;
64     mCfgMutex.lock();
65 
66 #ifdef DISABLE_HANDLE_ATTRIB
67     ret = rk_aiq_uapi_agic_v1_SetAttrib(mAlgoCtx, att, false);
68 #else
69     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
70     // if something changed, set att to mNewAtt, and
71     // the new params will be effective later when updateConfig
72     // called by RkAiqCore
73     bool isChanged = false;
74     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
75         memcmp(&mNewAttV1, att, sizeof(*att)))
76         isChanged = true;
77     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
78              memcmp(&mCurAttV1, att, sizeof(*att)))
79         isChanged = true;
80 
81     // if something changed
82     if (isChanged) {
83         mNewAttV1   = *att;
84         updateAttV1 = true;
85         waitSignal(att->sync.sync_mode);
86     }
87 #endif
88 
89     mCfgMutex.unlock();
90 
91     EXIT_ANALYZER_FUNCTION();
92     return ret;
93 }
94 
getAttribV1(rkaiq_gic_v1_api_attr_t * att)95 XCamReturn RkAiqAgicHandleInt::getAttribV1(rkaiq_gic_v1_api_attr_t* att) {
96     ENTER_ANALYZER_FUNCTION();
97 
98     XCamReturn ret = XCAM_RETURN_NO_ERROR;
99 
100 #ifdef DISABLE_HANDLE_ATTRIB
101     mCfgMutex.lock();
102     rk_aiq_uapi_agic_v1_GetAttrib(mAlgoCtx, att);
103     att->sync.done = true;
104     mCfgMutex.unlock();
105 #else
106     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
107         mCfgMutex.lock();
108         rk_aiq_uapi_agic_v1_GetAttrib(mAlgoCtx, att);
109         att->sync.done = true;
110         mCfgMutex.unlock();
111     } else {
112         if (updateAttV1) {
113             memcpy(att, &mNewAttV1, sizeof(mNewAttV1));
114             att->sync.done = false;
115         } else {
116             rk_aiq_uapi_agic_v1_GetAttrib(mAlgoCtx, att);
117             att->sync.sync_mode = mNewAttV1.sync.sync_mode;
118             att->sync.done = true;
119         }
120     }
121 #endif
122 
123     EXIT_ANALYZER_FUNCTION();
124     return ret;
125 }
126 
setAttribV2(const rkaiq_gic_v2_api_attr_t * att)127 XCamReturn RkAiqAgicHandleInt::setAttribV2(const rkaiq_gic_v2_api_attr_t* att) {
128     ENTER_ANALYZER_FUNCTION();
129 
130     XCamReturn ret = XCAM_RETURN_NO_ERROR;
131     mCfgMutex.lock();
132 
133 #ifdef DISABLE_HANDLE_ATTRIB
134     ret = rk_aiq_uapi_agic_v2_SetAttrib(mAlgoCtx, att, false);
135 #else
136     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
137     // if something changed, set att to mNewAtt, and
138     // the new params will be effective later when updateConfig
139     // called by RkAiqCore
140     bool isChanged = false;
141     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
142         memcmp(&mNewAttV2, att, sizeof(*att)))
143         isChanged = true;
144     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
145              memcmp(&mCurAttV2, att, sizeof(*att)))
146         isChanged = true;
147 
148     // if something changed
149     if (isChanged) {
150         mNewAttV2   = *att;
151         updateAttV2 = true;
152         waitSignal(att->sync.sync_mode);
153     }
154 #endif
155 
156     mCfgMutex.unlock();
157 
158     EXIT_ANALYZER_FUNCTION();
159     return ret;
160 }
161 
getAttribV2(rkaiq_gic_v2_api_attr_t * att)162 XCamReturn RkAiqAgicHandleInt::getAttribV2(rkaiq_gic_v2_api_attr_t* att) {
163     ENTER_ANALYZER_FUNCTION();
164 
165     XCamReturn ret = XCAM_RETURN_NO_ERROR;
166 
167 #ifdef DISABLE_HANDLE_ATTRIB
168     mCfgMutex.lock();
169     rk_aiq_uapi_agic_v2_GetAttrib(mAlgoCtx, att);
170     att->sync.done = true;
171     mCfgMutex.unlock();
172 #else
173     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
174         mCfgMutex.lock();
175         rk_aiq_uapi_agic_v2_GetAttrib(mAlgoCtx, att);
176         att->sync.done = true;
177         mCfgMutex.unlock();
178     } else {
179         if (updateAttV2) {
180             memcpy(att, &mNewAttV2, sizeof(mNewAttV2));
181             att->sync.done = false;
182         } else {
183             rk_aiq_uapi_agic_v2_GetAttrib(mAlgoCtx, att);
184             att->sync.sync_mode = mNewAttV2.sync.sync_mode;
185             att->sync.done = true;
186         }
187     }
188 #endif
189 
190     EXIT_ANALYZER_FUNCTION();
191     return ret;
192 }
193 
prepare()194 XCamReturn RkAiqAgicHandleInt::prepare() {
195     ENTER_ANALYZER_FUNCTION();
196 
197     XCamReturn ret = XCAM_RETURN_NO_ERROR;
198 
199     ret = RkAiqHandle::prepare();
200     RKAIQCORE_CHECK_RET(ret, "agic handle prepare failed");
201 
202     RkAiqAlgoConfigAgic* agic_config_int = (RkAiqAlgoConfigAgic*)mConfig;
203     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
204         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
205 
206     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
207     ret                       = des->prepare(mConfig);
208     RKAIQCORE_CHECK_RET(ret, "agic algo prepare failed");
209 
210     EXIT_ANALYZER_FUNCTION();
211     return XCAM_RETURN_NO_ERROR;
212 }
213 
preProcess()214 XCamReturn RkAiqAgicHandleInt::preProcess() {
215     ENTER_ANALYZER_FUNCTION();
216 
217     XCamReturn ret = XCAM_RETURN_NO_ERROR;
218 #if 0
219     RkAiqAlgoPreAgic* agic_pre_int        = (RkAiqAlgoPreAgic*)mPreInParam;
220     RkAiqAlgoPreResAgic* agic_pre_res_int = (RkAiqAlgoPreResAgic*)mPreOutParam;
221     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
222         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
223     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
224 
225     ret = RkAiqHandle::preProcess();
226     if (ret) {
227         RKAIQCORE_CHECK_RET(ret, "agic handle preProcess failed");
228     }
229 
230     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
231     ret                       = des->pre_process(mPreInParam, mPreOutParam);
232     RKAIQCORE_CHECK_RET(ret, "agic algo pre_process failed");
233 
234     EXIT_ANALYZER_FUNCTION();
235 #endif
236     return XCAM_RETURN_NO_ERROR;
237 }
238 
processing()239 XCamReturn RkAiqAgicHandleInt::processing() {
240     ENTER_ANALYZER_FUNCTION();
241 
242     XCamReturn ret = XCAM_RETURN_NO_ERROR;
243 
244     RkAiqAlgoProcAgic* agic_proc_int        = (RkAiqAlgoProcAgic*)mProcInParam;
245     RkAiqAlgoProcResAgic* agic_proc_res_int = (RkAiqAlgoProcResAgic*)mProcOutParam;
246     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
247         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
248     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
249 
250     if (!shared->fullParams || !shared->fullParams->mGicParams.ptr()) {
251         LOGE_ALSC("[%d]: no gic buf !", shared->frameId);
252         return XCAM_RETURN_BYPASS;
253     }
254 
255     agic_proc_res_int->gicRes = &shared->fullParams->mGicParams->data()->result;
256 
257     ret = RkAiqHandle::processing();
258     if (ret) {
259         RKAIQCORE_CHECK_RET(ret, "agic handle processing failed");
260     }
261 
262     agic_proc_int->hdr_mode = sharedCom->working_mode;
263     switch (sharedCom->snsDes.sensor_pixelformat) {
264         case V4L2_PIX_FMT_SBGGR14:
265         case V4L2_PIX_FMT_SGBRG14:
266         case V4L2_PIX_FMT_SGRBG14:
267         case V4L2_PIX_FMT_SRGGB14:
268             agic_proc_int->raw_bits = 14;
269             break;
270         case V4L2_PIX_FMT_SBGGR12:
271         case V4L2_PIX_FMT_SGBRG12:
272         case V4L2_PIX_FMT_SGRBG12:
273         case V4L2_PIX_FMT_SRGGB12:
274             agic_proc_int->raw_bits = 12;
275             break;
276         case V4L2_PIX_FMT_SBGGR10:
277         case V4L2_PIX_FMT_SGBRG10:
278         case V4L2_PIX_FMT_SGRBG10:
279         case V4L2_PIX_FMT_SRGGB10:
280             agic_proc_int->raw_bits = 10;
281             break;
282         default:
283             agic_proc_int->raw_bits = 8;
284     }
285 
286     RKAiqAecExpInfo_t* aeCurExp = &shared->curExp;
287     if (aeCurExp != NULL) {
288         if((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
289             agic_proc_int->iso = aeCurExp->LinearExp.exp_real_params.analog_gain * aeCurExp->LinearExp.exp_real_params.isp_dgain * 50;
290             LOGD_AGIC("%s:NORMAL:iso=%d,again=%f\n", __FUNCTION__, agic_proc_int->iso,
291                       aeCurExp->LinearExp.exp_real_params.analog_gain);
292         } else if ((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_ISP_HDR2) {
293             agic_proc_int->iso = aeCurExp->HdrExp[1].exp_real_params.analog_gain * 50;
294             LOGD_AGIC("%s:HDR2:iso=%d,again=%f\n", __FUNCTION__, agic_proc_int->iso,
295                       aeCurExp->HdrExp[1].exp_real_params.analog_gain);
296         } else if ((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_ISP_HDR3) {
297             agic_proc_int->iso = aeCurExp->HdrExp[2].exp_real_params.analog_gain * 50;
298             LOGD_AGIC("%s:HDR3:iso=%d,again=%f\n", __FUNCTION__, agic_proc_int->iso,
299                       aeCurExp->HdrExp[2].exp_real_params.analog_gain);
300         }
301     } else {
302         agic_proc_int->iso = 50;
303         LOGE_AGIC("%s: pAEPreRes is NULL, so use default instead \n", __FUNCTION__);
304     }
305 
306 #ifdef DISABLE_HANDLE_ATTRIB
307     mCfgMutex.lock();
308 #endif
309     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
310     ret                       = des->processing(mProcInParam, mProcOutParam);
311 #ifdef DISABLE_HANDLE_ATTRIB
312     mCfgMutex.unlock();
313 #endif
314     RKAIQCORE_CHECK_RET(ret, "agic algo processing failed");
315 
316     EXIT_ANALYZER_FUNCTION();
317     return ret;
318 }
319 
postProcess()320 XCamReturn RkAiqAgicHandleInt::postProcess() {
321     ENTER_ANALYZER_FUNCTION();
322 
323     XCamReturn ret = XCAM_RETURN_NO_ERROR;
324 #if 0
325     RkAiqAlgoPostAgic* agic_post_int        = (RkAiqAlgoPostAgic*)mPostInParam;
326     RkAiqAlgoPostResAgic* agic_post_res_int = (RkAiqAlgoPostResAgic*)mPostOutParam;
327     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
328         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
329     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
330 
331     ret = RkAiqHandle::postProcess();
332     if (ret) {
333         RKAIQCORE_CHECK_RET(ret, "agic handle postProcess failed");
334         return ret;
335     }
336 
337     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
338     ret                       = des->post_process(mPostInParam, mPostOutParam);
339     RKAIQCORE_CHECK_RET(ret, "agic algo post_process failed");
340 
341     EXIT_ANALYZER_FUNCTION();
342 #endif
343     return ret;
344 }
345 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)346 XCamReturn RkAiqAgicHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
347     ENTER_ANALYZER_FUNCTION();
348 
349     XCamReturn ret = XCAM_RETURN_NO_ERROR;
350     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
351         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
352     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
353     RkAiqAlgoProcResAgic* agic_com              = (RkAiqAlgoProcResAgic*)mProcOutParam;
354     rk_aiq_isp_gic_params_v20_t* gic_param = params->mGicParams->data().ptr();
355 
356     if (!agic_com) {
357         LOGD_ANALYZER("no agic result");
358         return XCAM_RETURN_NO_ERROR;
359     }
360 
361     if (!this->getAlgoId()) {
362         RkAiqAlgoProcResAgic* agic_rk = (RkAiqAlgoProcResAgic*)agic_com;
363         if (sharedCom->init) {
364             gic_param->frame_id = 0;
365         } else {
366             gic_param->frame_id = shared->frameId;
367         }
368 
369         if (agic_com->res_com.cfg_update) {
370             mSyncFlag = shared->frameId;
371             gic_param->sync_flag = mSyncFlag;
372             // copy from algo result
373             // set as the latest result
374             cur_params->mGicParams = params->mGicParams;
375             gic_param->is_update = true;
376             LOGD_AGIC("[%d] params from algo", mSyncFlag);
377         } else if (mSyncFlag != gic_param->sync_flag) {
378             gic_param->sync_flag = mSyncFlag;
379             // copy from latest result
380             if (cur_params->mGicParams.ptr()) {
381                 gic_param->result = cur_params->mGicParams->data()->result;
382                 gic_param->is_update = true;
383             } else {
384                 LOGE_AGIC("no latest params !");
385                 gic_param->is_update = false;
386             }
387             LOGD_AGIC("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
388         } else {
389             // do nothing, result in buf needn't update
390             gic_param->is_update = false;
391             LOGD_AGIC("[%d] params needn't update", shared->frameId);
392         }
393 #if 0//moved to processing out params
394         memcpy(&gic_param->result, &agic_rk->gicRes, sizeof(AgicProcResult_t));
395 #endif
396     }
397 
398     EXIT_ANALYZER_FUNCTION();
399 
400     return ret;
401 }
402 
403 }  // namespace RkCam
404