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