xref: /OK3568_Linux_fs/external/camera_engine_rkaiq/rkaiq/aiq_core/algo_handlers/RkAiqAcnrV2Handle.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 "RkAiqAcnrV2Handle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAcnrV2HandleInt);
23 
init()24 void RkAiqAcnrV2HandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAcnrV2());
29     mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAcnrV2());
30     mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAcnrV2());
31     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAcnrV2());
32     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAcnrV2());
33     mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAcnrV2());
34     mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAcnrV2());
35 
36 
37     EXIT_ANALYZER_FUNCTION();
38 }
39 
updateConfig(bool needSync)40 XCamReturn RkAiqAcnrV2HandleInt::updateConfig(bool needSync) {
41     ENTER_ANALYZER_FUNCTION();
42 
43     XCamReturn ret = XCAM_RETURN_NO_ERROR;
44 #ifndef DISABLE_HANDLE_ATTRIB
45     if (needSync) mCfgMutex.lock();
46     // if something changed
47     if (updateAtt) {
48         mCurAtt   = mNewAtt;
49         rk_aiq_uapi_acnrV2_SetAttrib(mAlgoCtx, &mCurAtt, false);
50         sendSignal(mCurAtt.sync.sync_mode);
51         updateAtt = false;
52     }
53 
54     if (updateStrength) {
55         mCurStrength   = mNewStrength;
56         rk_aiq_uapi_acnrV2_SetChromaSFStrength(mAlgoCtx, &mCurStrength);
57         sendSignal(mCurStrength.sync.sync_mode);
58         updateStrength = false;
59     }
60 
61     if (needSync) mCfgMutex.unlock();
62 #endif
63 
64     EXIT_ANALYZER_FUNCTION();
65     return ret;
66 }
67 
setAttrib(rk_aiq_cnr_attrib_v2_t * att)68 XCamReturn RkAiqAcnrV2HandleInt::setAttrib(rk_aiq_cnr_attrib_v2_t* att) {
69     ENTER_ANALYZER_FUNCTION();
70 
71     XCamReturn ret = XCAM_RETURN_NO_ERROR;
72     mCfgMutex.lock();
73 #ifdef DISABLE_HANDLE_ATTRIB
74     ret = rk_aiq_uapi_acnrV2_SetAttrib(mAlgoCtx, att, false);
75 #else
76 
77     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
78     // if something changed, set att to mNewAtt, and
79     // the new params will be effective later when updateConfig
80     // called by RkAiqCore
81     bool isChanged = false;
82     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
83             memcmp(&mNewAtt, att, sizeof(*att)))
84         isChanged = true;
85     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
86              memcmp(&mCurAtt, att, sizeof(*att)))
87         isChanged = true;
88 
89     // if something changed
90     if (isChanged) {
91         mNewAtt   = *att;
92         updateAtt = true;
93         waitSignal(att->sync.sync_mode);
94     }
95 #endif
96 
97     mCfgMutex.unlock();
98 
99     EXIT_ANALYZER_FUNCTION();
100     return ret;
101 }
102 
getAttrib(rk_aiq_cnr_attrib_v2_t * att)103 XCamReturn RkAiqAcnrV2HandleInt::getAttrib(rk_aiq_cnr_attrib_v2_t* att) {
104     ENTER_ANALYZER_FUNCTION();
105 
106     XCamReturn ret = XCAM_RETURN_NO_ERROR;
107 #ifdef DISABLE_HANDLE_ATTRIB
108     mCfgMutex.lock();
109     rk_aiq_uapi_acnrV2_GetAttrib(mAlgoCtx, att);
110     mCfgMutex.unlock();
111 #else
112 
113     if(att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
114         mCfgMutex.lock();
115         rk_aiq_uapi_acnrV2_GetAttrib(mAlgoCtx, att);
116         att->sync.done = true;
117         mCfgMutex.unlock();
118     } else {
119         if(updateAtt) {
120             memcpy(att, &mNewAtt, sizeof(mNewAtt));
121             att->sync.done = false;
122         } else {
123             rk_aiq_uapi_acnrV2_GetAttrib(mAlgoCtx, att);
124             att->sync.done = true;
125         }
126     }
127 #endif
128 
129     EXIT_ANALYZER_FUNCTION();
130     return ret;
131 }
132 
setStrength(rk_aiq_cnr_strength_v2_t * pStrength)133 XCamReturn RkAiqAcnrV2HandleInt::setStrength(rk_aiq_cnr_strength_v2_t *pStrength) {
134     ENTER_ANALYZER_FUNCTION();
135 
136     XCamReturn ret = XCAM_RETURN_NO_ERROR;
137 
138     mCfgMutex.lock();
139 
140 #ifdef DISABLE_HANDLE_ATTRIB
141     ret = rk_aiq_uapi_acnrV2_SetChromaSFStrength(mAlgoCtx, pStrength);
142 #else
143     bool isChanged = false;
144     if (pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
145             memcmp(&mNewStrength, pStrength, sizeof(*pStrength)))
146         isChanged = true;
147     else if (pStrength->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
148              memcmp(&mCurStrength, pStrength, sizeof(*pStrength)))
149         isChanged = true;
150 
151     if (isChanged) {
152         mNewStrength   = *pStrength;
153         updateStrength = true;
154         waitSignal(pStrength->sync.sync_mode);
155     }
156 #endif
157 
158     mCfgMutex.unlock();
159 
160     EXIT_ANALYZER_FUNCTION();
161 
162     return ret;
163 }
164 
getStrength(rk_aiq_cnr_strength_v2_t * pStrength)165 XCamReturn RkAiqAcnrV2HandleInt::getStrength(rk_aiq_cnr_strength_v2_t *pStrength) {
166     ENTER_ANALYZER_FUNCTION();
167 
168     XCamReturn ret = XCAM_RETURN_NO_ERROR;
169 
170 
171 #ifdef DISABLE_HANDLE_ATTRIB
172     mCfgMutex.lock();
173     rk_aiq_uapi_acnrV2_GetChromaSFStrength(mAlgoCtx, pStrength);
174     mCfgMutex.unlock();
175 #else
176     if(pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
177         mCfgMutex.lock();
178         rk_aiq_uapi_acnrV2_GetChromaSFStrength(mAlgoCtx, pStrength);
179         pStrength->sync.done = true;
180         mCfgMutex.unlock();
181     } else {
182         if(updateStrength) {
183             *pStrength = mNewStrength;
184             pStrength->sync.done = false;
185         } else {
186             rk_aiq_uapi_acnrV2_GetChromaSFStrength(mAlgoCtx, pStrength);
187             pStrength->sync.done = true;
188         }
189     }
190 #endif
191 
192     EXIT_ANALYZER_FUNCTION();
193     return ret;
194 }
195 
getInfo(rk_aiq_cnr_info_v2_t * pInfo)196 XCamReturn RkAiqAcnrV2HandleInt::getInfo(rk_aiq_cnr_info_v2_t *pInfo) {
197     ENTER_ANALYZER_FUNCTION();
198 
199     XCamReturn ret = XCAM_RETURN_NO_ERROR;
200 
201 
202     if(pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
203         mCfgMutex.lock();
204         rk_aiq_uapi_acnrV2_GetInfo(mAlgoCtx, pInfo);
205         pInfo->sync.done = true;
206         mCfgMutex.unlock();
207     } else {
208         rk_aiq_uapi_acnrV2_GetInfo(mAlgoCtx, pInfo);
209         pInfo->sync.done = true;
210 
211     }
212 
213     EXIT_ANALYZER_FUNCTION();
214     return ret;
215 }
216 
prepare()217 XCamReturn RkAiqAcnrV2HandleInt::prepare() {
218     ENTER_ANALYZER_FUNCTION();
219 
220     XCamReturn ret = XCAM_RETURN_NO_ERROR;
221 
222     ret = RkAiqHandle::prepare();
223     RKAIQCORE_CHECK_RET(ret, "acnr handle prepare failed");
224 
225     RkAiqAlgoConfigAcnrV1* acnr_config_int = (RkAiqAlgoConfigAcnrV1*)mConfig;
226 
227     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
228     ret                       = des->prepare(mConfig);
229     RKAIQCORE_CHECK_RET(ret, "acnr algo prepare failed");
230 
231     EXIT_ANALYZER_FUNCTION();
232     return XCAM_RETURN_NO_ERROR;
233 }
234 
preProcess()235 XCamReturn RkAiqAcnrV2HandleInt::preProcess() {
236     ENTER_ANALYZER_FUNCTION();
237 
238     XCamReturn ret = XCAM_RETURN_NO_ERROR;
239 
240     RkAiqAlgoPreAcnrV2* acnr_pre_int        = (RkAiqAlgoPreAcnrV2*)mPreInParam;
241     RkAiqAlgoPreResAcnrV2* acnr_pre_res_int = (RkAiqAlgoPreResAcnrV2*)mPreOutParam;
242     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
243         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
244     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
245 
246     ret = RkAiqHandle::preProcess();
247     if (ret) {
248         RKAIQCORE_CHECK_RET(ret, "acnr handle preProcess failed");
249     }
250 
251     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
252     ret                       = des->pre_process(mPreInParam, mPreOutParam);
253     RKAIQCORE_CHECK_RET(ret, "acnr algo pre_process failed");
254 
255     EXIT_ANALYZER_FUNCTION();
256     return XCAM_RETURN_NO_ERROR;
257 }
258 
processing()259 XCamReturn RkAiqAcnrV2HandleInt::processing() {
260     ENTER_ANALYZER_FUNCTION();
261 
262     XCamReturn ret = XCAM_RETURN_NO_ERROR;
263 
264     RkAiqAlgoProcAcnrV2* acnr_proc_int        = (RkAiqAlgoProcAcnrV2*)mProcInParam;
265     RkAiqAlgoProcResAcnrV2* acnr_proc_res_int = (RkAiqAlgoProcResAcnrV2*)mProcOutParam;
266     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
267         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
268     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
269 
270     acnr_proc_res_int->stAcnrProcResult.stFix = &shared->fullParams->mCnrV3xParams->data()->result;
271 
272     ret = RkAiqHandle::processing();
273     if (ret) {
274         RKAIQCORE_CHECK_RET(ret, "acnr handle processing failed");
275     }
276 
277     // TODO: fill procParam
278     acnr_proc_int->iso      = sharedCom->iso;
279     acnr_proc_int->hdr_mode = sharedCom->working_mode;
280 
281 #ifdef DISABLE_HANDLE_ATTRIB
282     mCfgMutex.lock();
283 #endif
284     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
285     ret                       = des->processing(mProcInParam, mProcOutParam);
286 #ifdef DISABLE_HANDLE_ATTRIB
287     mCfgMutex.unlock();
288 #endif
289     RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
290 
291     EXIT_ANALYZER_FUNCTION();
292     return ret;
293 }
294 
postProcess()295 XCamReturn RkAiqAcnrV2HandleInt::postProcess() {
296     ENTER_ANALYZER_FUNCTION();
297 
298     XCamReturn ret = XCAM_RETURN_NO_ERROR;
299 
300     RkAiqAlgoPostAcnrV2* acnr_post_int        = (RkAiqAlgoPostAcnrV2*)mPostInParam;
301     RkAiqAlgoPostResAcnrV2* acnr_post_res_int = (RkAiqAlgoPostResAcnrV2*)mPostOutParam;
302     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
303         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
304     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
305 
306     ret = RkAiqHandle::postProcess();
307     if (ret) {
308         RKAIQCORE_CHECK_RET(ret, "acnr handle postProcess failed");
309         return ret;
310     }
311 
312     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
313     ret                       = des->post_process(mPostInParam, mPostOutParam);
314     RKAIQCORE_CHECK_RET(ret, "acnr algo post_process failed");
315 
316     EXIT_ANALYZER_FUNCTION();
317     return ret;
318 }
319 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)320 XCamReturn RkAiqAcnrV2HandleInt::genIspResult(RkAiqFullParams* params,
321         RkAiqFullParams* cur_params) {
322     ENTER_ANALYZER_FUNCTION();
323 
324     XCamReturn ret                = XCAM_RETURN_NO_ERROR;
325     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
326         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
327     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
328     RkAiqAlgoProcResAcnrV2* acnr_rk = (RkAiqAlgoProcResAcnrV2*)mProcOutParam;
329 
330     if (!acnr_rk) {
331         LOGD_ANALYZER("no aynr result");
332         return XCAM_RETURN_NO_ERROR;
333     }
334 
335     if (!this->getAlgoId()) {
336         LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
337         rk_aiq_isp_cnr_params_v3x_t* cnr_param = params->mCnrV3xParams->data().ptr();
338         if (sharedCom->init) {
339             cnr_param->frame_id = 0;
340         } else {
341             cnr_param->frame_id = shared->frameId;
342         }
343 
344         if (acnr_rk->res_com.cfg_update) {
345             mSyncFlag = shared->frameId;
346             cnr_param->sync_flag = mSyncFlag;
347             // copy from algo result
348             // set as the latest result
349             cur_params->mCnrV3xParams = params->mCnrV3xParams;
350             cnr_param->is_update = true;
351             LOGD_ANR("[%d] params from algo", mSyncFlag);
352         } else if (mSyncFlag != cnr_param->sync_flag) {
353             cnr_param->sync_flag = mSyncFlag;
354             // copy from latest result
355             if (cur_params->mCnrV3xParams.ptr()) {
356                 cnr_param->result = cur_params->mCnrV3xParams->data()->result;
357                 cnr_param->is_update = true;
358             } else {
359                 LOGE_ANR("no latest params !");
360                 cnr_param->is_update = false;
361             }
362             LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
363         } else {
364             // do nothing, result in buf needn't update
365             cnr_param->is_update = false;
366             LOGD_ANR("[%d] params needn't update", shared->frameId);
367         }
368         LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
369     }
370 
371     EXIT_ANALYZER_FUNCTION();
372 
373     return ret;
374 }
375 
376 }  // namespace RkCam
377