xref: /OK3568_Linux_fs/external/camera_engine_rkaiq/rkaiq/aiq_core/algo_handlers/RkAiqAdrcHandle.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 "RkAiqAdrcHandle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAdrcHandleInt);
23 
prepare()24 XCamReturn RkAiqAdrcHandleInt::prepare() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     XCamReturn ret = XCAM_RETURN_NO_ERROR;
28 
29     ret = RkAiqHandle::prepare();
30     RKAIQCORE_CHECK_RET(ret, "adrc handle prepare failed");
31 
32     RkAiqAlgoConfigAdrc* adrc_config_int     = (RkAiqAlgoConfigAdrc*)mConfig;
33     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
34 
35     adrc_config_int->rawHeight    = sharedCom->snsDes.isp_acq_height;
36     adrc_config_int->rawWidth     = sharedCom->snsDes.isp_acq_width;
37     adrc_config_int->working_mode = sharedCom->working_mode;
38 
39     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
40     ret                       = des->prepare(mConfig);
41     RKAIQCORE_CHECK_RET(ret, "adrc algo prepare failed");
42 
43     EXIT_ANALYZER_FUNCTION();
44     return XCAM_RETURN_NO_ERROR;
45 }
46 
init()47 void RkAiqAdrcHandleInt::init() {
48     ENTER_ANALYZER_FUNCTION();
49 
50     RkAiqHandle::deInit();
51     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAdrc());
52     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAdrc());
53     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAdrc());
54 
55     EXIT_ANALYZER_FUNCTION();
56 }
57 
updateConfig(bool needSync)58 XCamReturn RkAiqAdrcHandleInt::updateConfig(bool needSync) {
59     ENTER_ANALYZER_FUNCTION();
60 
61     XCamReturn ret = XCAM_RETURN_NO_ERROR;
62 #ifndef DISABLE_HANDLE_ATTRIB
63     if (needSync) mCfgMutex.lock();
64     // if something changed
65     if (updateAtt) {
66 #if RKAIQ_HAVE_DRC_V10
67         mCurAttV10 = mNewAttV10;
68         rk_aiq_uapi_adrc_v10_SetAttrib(mAlgoCtx, &mCurAttV10, true);
69         updateAtt = false;
70         sendSignal(mCurAttV10.sync.sync_mode);
71 #endif
72 #if RKAIQ_HAVE_DRC_V11
73         mCurAttV11 = mNewAttV11;
74         rk_aiq_uapi_adrc_v11_SetAttrib(mAlgoCtx, &mCurAttV11, true);
75         updateAtt = false;
76         sendSignal(mCurAttV11.sync.sync_mode);
77 #endif
78 #if RKAIQ_HAVE_DRC_V12
79         mCurAttV12 = mNewAttV12;
80         rk_aiq_uapi_adrc_v12_SetAttrib(mAlgoCtx, &mCurAttV12, true);
81         updateAtt = false;
82         sendSignal(mCurAttV12.sync.sync_mode);
83 #endif
84 #if RKAIQ_HAVE_DRC_V12_LITE
85         mCurAttV12Lite = mNewAttV12Lite;
86         rk_aiq_uapi_adrc_v12_lite_SetAttrib(mAlgoCtx, &mCurAttV12Lite, true);
87         updateAtt = false;
88         sendSignal(mCurAttV12Lite.sync.sync_mode);
89 #endif
90     }
91 
92     if (needSync) mCfgMutex.unlock();
93 #endif
94 
95     EXIT_ANALYZER_FUNCTION();
96     return ret;
97 }
98 
99 #if RKAIQ_HAVE_DRC_V10
setAttribV10(const drcAttrV10_t * att)100 XCamReturn RkAiqAdrcHandleInt::setAttribV10(const drcAttrV10_t* att) {
101     ENTER_ANALYZER_FUNCTION();
102 
103     XCamReturn ret = XCAM_RETURN_NO_ERROR;
104     mCfgMutex.lock();
105 
106 #ifdef DISABLE_HANDLE_ATTRIB
107     ret = rk_aiq_uapi_adrc_v10_SetAttrib(mAlgoCtx, att, true);
108 #else
109     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
110     // if something changed, set att to mNewAtt, and
111     // the new params will be effective later when updateConfig
112     // called by RkAiqCore
113     bool isChanged = false;
114     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
115         memcmp(&mNewAttV10, att, sizeof(drcAttrV10_t)))
116         isChanged = true;
117     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
118              memcmp(&mCurAttV10, att, sizeof(drcAttrV10_t)))
119         isChanged = true;
120 
121     // if something changed
122     if (isChanged) {
123         mNewAttV10 = *att;
124         updateAtt  = true;
125         waitSignal(att->sync.sync_mode);
126     }
127 #endif
128     mCfgMutex.unlock();
129 
130     EXIT_ANALYZER_FUNCTION();
131     return ret;
132 }
getAttribV10(drcAttrV10_t * att)133 XCamReturn RkAiqAdrcHandleInt::getAttribV10(drcAttrV10_t* att) {
134     ENTER_ANALYZER_FUNCTION();
135 
136     XCamReturn ret = XCAM_RETURN_NO_ERROR;
137 
138 #ifdef DISABLE_HANDLE_ATTRIB
139     mCfgMutex.lock();
140     rk_aiq_uapi_adrc_v10_GetAttrib(mAlgoCtx, att);
141     att->sync.done = true;
142     mCfgMutex.unlock();
143 #else
144     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
145         mCfgMutex.lock();
146         rk_aiq_uapi_adrc_v10_GetAttrib(mAlgoCtx, att);
147         att->sync.done = true;
148         mCfgMutex.unlock();
149     } else {
150         if (updateAtt) {
151             memcpy(att, &mNewAttV10, sizeof(drcAttrV10_t));
152             att->sync.done = false;
153         } else {
154             rk_aiq_uapi_adrc_v10_GetAttrib(mAlgoCtx, att);
155             att->sync.sync_mode = mNewAttV10.sync.sync_mode;
156             att->sync.done      = true;
157         }
158     }
159 #endif
160     EXIT_ANALYZER_FUNCTION();
161     return ret;
162 }
163 #endif
164 #if RKAIQ_HAVE_DRC_V11
setAttribV11(const drcAttrV11_t * att)165 XCamReturn RkAiqAdrcHandleInt::setAttribV11(const drcAttrV11_t* att) {
166     ENTER_ANALYZER_FUNCTION();
167 
168     XCamReturn ret = XCAM_RETURN_NO_ERROR;
169     mCfgMutex.lock();
170 
171 #ifdef DISABLE_HANDLE_ATTRIB
172     ret = rk_aiq_uapi_adrc_v11_SetAttrib(mAlgoCtx, att, true);
173 #else
174     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
175     // if something changed, set att to mNewAtt, and
176     // the new params will be effective later when updateConfig
177     // called by RkAiqCore
178     bool isChanged = false;
179     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
180         memcmp(&mNewAttV11, att, sizeof(drcAttrV11_t)))
181         isChanged = true;
182     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
183              memcmp(&mCurAttV11, att, sizeof(drcAttrV11_t)))
184         isChanged = true;
185 
186     // if something changed
187     if (isChanged) {
188         mNewAttV11 = *att;
189         updateAtt  = true;
190         waitSignal(att->sync.sync_mode);
191     }
192 #endif
193     mCfgMutex.unlock();
194 
195     EXIT_ANALYZER_FUNCTION();
196     return ret;
197 }
getAttribV11(drcAttrV11_t * att)198 XCamReturn RkAiqAdrcHandleInt::getAttribV11(drcAttrV11_t* att) {
199     ENTER_ANALYZER_FUNCTION();
200 
201     XCamReturn ret = XCAM_RETURN_NO_ERROR;
202 
203 #ifdef DISABLE_HANDLE_ATTRIB
204     mCfgMutex.lock();
205     rk_aiq_uapi_adrc_v11_GetAttrib(mAlgoCtx, att);
206     att->sync.done = true;
207     mCfgMutex.unlock();
208 #else
209     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
210         mCfgMutex.lock();
211         rk_aiq_uapi_adrc_v11_GetAttrib(mAlgoCtx, att);
212         att->sync.done = true;
213         mCfgMutex.unlock();
214     } else {
215         if (updateAtt) {
216             memcpy(att, &mNewAttV11, sizeof(drcAttrV11_t));
217             att->sync.done = false;
218         } else {
219             rk_aiq_uapi_adrc_v11_GetAttrib(mAlgoCtx, att);
220             att->sync.sync_mode = mNewAttV11.sync.sync_mode;
221             att->sync.done      = true;
222         }
223     }
224 #endif
225     EXIT_ANALYZER_FUNCTION();
226     return ret;
227 }
228 #endif
229 #if RKAIQ_HAVE_DRC_V12
setAttribV12(const drcAttrV12_t * att)230 XCamReturn RkAiqAdrcHandleInt::setAttribV12(const drcAttrV12_t* att) {
231     ENTER_ANALYZER_FUNCTION();
232 
233     XCamReturn ret = XCAM_RETURN_NO_ERROR;
234     mCfgMutex.lock();
235 
236 #ifdef DISABLE_HANDLE_ATTRIB
237     ret = rk_aiq_uapi_adrc_v12_SetAttrib(mAlgoCtx, att, true);
238 #else
239     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
240     // if something changed, set att to mNewAtt, and
241     // the new params will be effective later when updateConfig
242     // called by RkAiqCore
243     bool isChanged = false;
244     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
245         memcmp(&mNewAttV12, att, sizeof(drcAttrV12_t)))
246         isChanged = true;
247     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
248              memcmp(&mCurAttV12, att, sizeof(drcAttrV12_t)))
249         isChanged = true;
250 
251     // if something changed
252     if (isChanged) {
253         mNewAttV12 = *att;
254         updateAtt = true;
255         waitSignal(att->sync.sync_mode);
256     }
257 #endif
258     mCfgMutex.unlock();
259 
260     EXIT_ANALYZER_FUNCTION();
261     return ret;
262 }
getAttribV12(drcAttrV12_t * att)263 XCamReturn RkAiqAdrcHandleInt::getAttribV12(drcAttrV12_t* att) {
264     ENTER_ANALYZER_FUNCTION();
265 
266     XCamReturn ret = XCAM_RETURN_NO_ERROR;
267 
268 #ifdef DISABLE_HANDLE_ATTRIB
269     mCfgMutex.lock();
270     rk_aiq_uapi_adrc_v12_GetAttrib(mAlgoCtx, att);
271     att->sync.done = true;
272     mCfgMutex.unlock();
273 #else
274     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
275         mCfgMutex.lock();
276         rk_aiq_uapi_adrc_v12_GetAttrib(mAlgoCtx, att);
277         att->sync.done = true;
278         mCfgMutex.unlock();
279     } else {
280         if (updateAtt) {
281             memcpy(att, &mNewAttV12, sizeof(drcAttrV12_t));
282             att->sync.done = false;
283         } else {
284             rk_aiq_uapi_adrc_v12_GetAttrib(mAlgoCtx, att);
285             att->sync.sync_mode = mNewAttV12.sync.sync_mode;
286             att->sync.done      = true;
287         }
288     }
289 #endif
290     EXIT_ANALYZER_FUNCTION();
291     return ret;
292 }
293 #endif
294 #if RKAIQ_HAVE_DRC_V12_LITE
setAttribV12Lite(const drcAttrV12Lite_t * att)295 XCamReturn RkAiqAdrcHandleInt::setAttribV12Lite(const drcAttrV12Lite_t* att) {
296     ENTER_ANALYZER_FUNCTION();
297 
298     XCamReturn ret = XCAM_RETURN_NO_ERROR;
299     mCfgMutex.lock();
300 
301 #ifdef DISABLE_HANDLE_ATTRIB
302     ret = rk_aiq_uapi_adrc_v12_lite_SetAttrib(mAlgoCtx, att, true);
303 #else
304     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
305     // if something changed, set att to mNewAtt, and
306     // the new params will be effective later when updateConfig
307     // called by RkAiqCore
308     bool isChanged = false;
309     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
310         memcmp(&mNewAttV12Lite, att, sizeof(drcAttrV12Lite_t)))
311         isChanged = true;
312     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
313              memcmp(&mCurAttV12Lite, att, sizeof(drcAttrV12Lite_t)))
314         isChanged = true;
315 
316     // if something changed
317     if (isChanged) {
318         mNewAttV12Lite = *att;
319         updateAtt      = true;
320         waitSignal(att->sync.sync_mode);
321     }
322 #endif
323     mCfgMutex.unlock();
324 
325     EXIT_ANALYZER_FUNCTION();
326     return ret;
327 }
getAttribV12Lite(drcAttrV12Lite_t * att)328 XCamReturn RkAiqAdrcHandleInt::getAttribV12Lite(drcAttrV12Lite_t* att) {
329     ENTER_ANALYZER_FUNCTION();
330 
331     XCamReturn ret = XCAM_RETURN_NO_ERROR;
332 
333 #ifdef DISABLE_HANDLE_ATTRIB
334     mCfgMutex.lock();
335     rk_aiq_uapi_adrc_v12_lite_GetAttrib(mAlgoCtx, att);
336     att->sync.done = true;
337     mCfgMutex.unlock();
338 #else
339     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
340         mCfgMutex.lock();
341         rk_aiq_uapi_adrc_v12_lite_GetAttrib(mAlgoCtx, att);
342         att->sync.done = true;
343         mCfgMutex.unlock();
344     } else {
345         if (updateAtt) {
346             memcpy(att, &mNewAttV12Lite, sizeof(drcAttrV12Lite_t));
347             att->sync.done = false;
348         } else {
349             rk_aiq_uapi_adrc_v12_lite_GetAttrib(mAlgoCtx, att);
350             att->sync.sync_mode = mNewAttV12Lite.sync.sync_mode;
351             att->sync.done      = true;
352         }
353     }
354 #endif
355 
356     EXIT_ANALYZER_FUNCTION();
357     return ret;
358 }
359 #endif
360 
preProcess()361 XCamReturn RkAiqAdrcHandleInt::preProcess() {
362     ENTER_ANALYZER_FUNCTION();
363 
364     XCamReturn ret = XCAM_RETURN_NO_ERROR;
365 #if 0
366     RkAiqAlgoPreAdrc* adrc_pre_int        = (RkAiqAlgoPreAdrc*)mPreInParam;
367     RkAiqAlgoPreResAdrc* adrc_pre_res_int = (RkAiqAlgoPreResAdrc*)mPreOutParam;
368     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
369         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
370     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
371 
372     ret = RkAiqHandle::preProcess();
373     if (ret) {
374         RKAIQCORE_CHECK_RET(ret, "adrc handle preProcess failed");
375     }
376 
377     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
378     ret                       = des->pre_process(mPreInParam, mPreOutParam);
379     RKAIQCORE_CHECK_RET(ret, "adrc algo pre_process failed");
380 
381     EXIT_ANALYZER_FUNCTION();
382 #endif
383     return XCAM_RETURN_NO_ERROR;
384 }
385 
processing()386 XCamReturn RkAiqAdrcHandleInt::processing() {
387     ENTER_ANALYZER_FUNCTION();
388 
389     XCamReturn ret = XCAM_RETURN_NO_ERROR;
390 
391     RkAiqAlgoProcAdrc* adrc_proc_int        = (RkAiqAlgoProcAdrc*)mProcInParam;
392     RkAiqAlgoProcResAdrc* adrc_proc_res_int = (RkAiqAlgoProcResAdrc*)mProcOutParam;
393     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
394         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
395     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
396 
397     adrc_proc_res_int->AdrcProcRes = &shared->fullParams->mDrcParams->data()->result;
398     adrc_proc_int->LongFrmMode = mAeProcRes.LongFrmMode;
399 
400 #if RKAIQ_HAVE_DRC_V12 || RKAIQ_HAVE_DRC_V12_LITE
401     adrc_proc_int->ablcV32_proc_res.blc_ob_enable = shared->res_comb.ablcV32_proc_res->blc_ob_enable;
402     adrc_proc_int->ablcV32_proc_res.isp_ob_predgain =
403         shared->res_comb.ablcV32_proc_res->isp_ob_predgain;
404 #endif
405 
406     ret = RkAiqHandle::processing();
407     if (ret) {
408         RKAIQCORE_CHECK_RET(ret, "adrc handle processing failed");
409     }
410 
411 #ifdef DISABLE_HANDLE_ATTRIB
412     mCfgMutex.lock();
413 #endif
414     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
415     ret                       = des->processing(mProcInParam, mProcOutParam);
416 #ifdef DISABLE_HANDLE_ATTRIB
417     mCfgMutex.unlock();
418 #endif
419     RKAIQCORE_CHECK_RET(ret, "adrc algo processing failed");
420 
421     EXIT_ANALYZER_FUNCTION();
422     return ret;
423 }
424 
postProcess()425 XCamReturn RkAiqAdrcHandleInt::postProcess() {
426     ENTER_ANALYZER_FUNCTION();
427 
428     XCamReturn ret = XCAM_RETURN_NO_ERROR;
429 #if 0
430     RkAiqAlgoPostAdrc* adrc_post_int        = (RkAiqAlgoPostAdrc*)mPostInParam;
431     RkAiqAlgoPostResAdrc* adrc_post_res_int = (RkAiqAlgoPostResAdrc*)mPostOutParam;
432     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
433         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
434     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
435 
436     ret = RkAiqHandle::postProcess();
437     if (ret) {
438         RKAIQCORE_CHECK_RET(ret, "adrc handle postProcess failed");
439         return ret;
440     }
441 
442     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
443     ret                       = des->post_process(mPostInParam, mPostOutParam);
444     RKAIQCORE_CHECK_RET(ret, "adrc algo post_process failed");
445 
446     EXIT_ANALYZER_FUNCTION();
447 #endif
448     return ret;
449 }
450 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)451 XCamReturn RkAiqAdrcHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
452     ENTER_ANALYZER_FUNCTION();
453 
454     XCamReturn ret = XCAM_RETURN_NO_ERROR;
455     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
456         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
457     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
458     RkAiqAlgoProcResAdrc* adrc_com = (RkAiqAlgoProcResAdrc*)mProcOutParam;
459 
460     if (!adrc_com) {
461         LOGD_ANALYZER("no adrc result");
462         return XCAM_RETURN_NO_ERROR;
463     }
464 
465     RkAiqAlgoProcResAdrc* adrc_rk = (RkAiqAlgoProcResAdrc*)adrc_com;
466     if (!this->getAlgoId()) {
467         RkAiqAlgoProcResAdrc* ahdr_rk = (RkAiqAlgoProcResAdrc*)adrc_com;
468 
469         rk_aiq_isp_drc_params_v21_t* drc_param = params->mDrcParams->data().ptr();
470         if (sharedCom->init) {
471             drc_param->frame_id = 0;
472         } else {
473             drc_param->frame_id = shared->frameId;
474         }
475 
476         if (adrc_com->res_com.cfg_update) {
477             mSyncFlag = shared->frameId;
478             drc_param->sync_flag = mSyncFlag;
479             // copy from algo result
480             // set as the latest result
481             cur_params->mDrcParams = params->mDrcParams;
482             drc_param->is_update = true;
483             LOGD_ATMO("[%d] params from algo", mSyncFlag);
484         } else if (mSyncFlag != drc_param->sync_flag) {
485             drc_param->sync_flag = mSyncFlag;
486             // copy from latest result
487             if (cur_params->mDrcParams.ptr()) {
488                 drc_param->result = cur_params->mDrcParams->data()->result;
489                 drc_param->is_update = true;
490             } else {
491                 LOGE_ATMO("no latest params !");
492                 drc_param->is_update = false;
493             }
494             LOGD_ATMO("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
495         } else {
496             // do nothing, result in buf needn't update
497             drc_param->is_update = false;
498             LOGD_ATMO("[%d] params needn't update", shared->frameId);
499         }
500     }
501 
502     EXIT_ANALYZER_FUNCTION();
503 
504     return ret;
505 
506 }
507 
508 }  // namespace RkCam
509