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 "RkAiqAbayertnrV23Handle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAbayertnrV23HandleInt);
23 
init()24 void RkAiqAbayertnrV23HandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAbayertnrV23());
29     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAbayertnrV23());
30     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAbayertnrV23());
31 
32     EXIT_ANALYZER_FUNCTION();
33 }
34 
updateConfig(bool needSync)35 XCamReturn RkAiqAbayertnrV23HandleInt::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_abayertnrV23_SetAttrib(mAlgoCtx, &mCurAtt, false);
45         sendSignal(mCurAtt.sync.sync_mode);
46         updateAtt = false;
47     }
48 
49     if (updateAttLite) {
50         mCurAttLite = mNewAttLite;
51         rk_aiq_uapi_abayertnrV23Lite_SetAttrib(mAlgoCtx, &mCurAttLite, false);
52         sendSignal(mCurAttLite.sync.sync_mode);
53         updateAttLite = false;
54     }
55 
56     if (updateStrength) {
57         mCurStrength   = mNewStrength;
58         rk_aiq_uapi_abayertnrV23_SetStrength(mAlgoCtx, &mCurStrength);
59         sendSignal(mCurStrength.sync.sync_mode);
60         updateStrength = false;
61     }
62 
63     if (needSync) mCfgMutex.unlock();
64 #endif
65 
66     EXIT_ANALYZER_FUNCTION();
67     return ret;
68 }
69 
setAttrib(const rk_aiq_bayertnr_attrib_v23_t * att)70 XCamReturn RkAiqAbayertnrV23HandleInt::setAttrib(const rk_aiq_bayertnr_attrib_v23_t* att) {
71     ENTER_ANALYZER_FUNCTION();
72 
73     XCamReturn ret = XCAM_RETURN_NO_ERROR;
74     mCfgMutex.lock();
75     // TODO
76     // check if there is different between att & mCurAtt
77     // if something changed, set att to mNewAtt, and
78     // the new params will be effective later when updateConfig
79     // called by RkAiqCore
80 
81 #ifdef DISABLE_HANDLE_ATTRIB
82     ret = rk_aiq_uapi_abayertnrV23_SetAttrib(mAlgoCtx, att, false);
83 #else
84     // if something changed
85     if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_bayertnr_attrib_v23_t))) {
86         mNewAtt   = *att;
87         updateAtt = true;
88         waitSignal(att->sync.sync_mode);
89     }
90 #endif
91 
92     mCfgMutex.unlock();
93 
94     EXIT_ANALYZER_FUNCTION();
95     return ret;
96 }
97 
getAttrib(rk_aiq_bayertnr_attrib_v23_t * att)98 XCamReturn RkAiqAbayertnrV23HandleInt::getAttrib(rk_aiq_bayertnr_attrib_v23_t* att) {
99     ENTER_ANALYZER_FUNCTION();
100 
101     XCamReturn ret = XCAM_RETURN_NO_ERROR;
102 #ifdef DISABLE_HANDLE_ATTRIB
103       mCfgMutex.lock();
104       ret = rk_aiq_uapi_abayertnrV23_GetAttrib(mAlgoCtx, att);
105       mCfgMutex.unlock();
106 #else
107     if(att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
108         mCfgMutex.lock();
109         rk_aiq_uapi_abayertnrV23_GetAttrib(mAlgoCtx, att);
110         att->sync.done = true;
111         mCfgMutex.unlock();
112     } else {
113         if(updateAtt) {
114             memcpy(att, &mNewAtt, sizeof(mNewAtt));
115             mCfgMutex.unlock();
116             att->sync.done = false;
117         } else {
118             mCfgMutex.unlock();
119             rk_aiq_uapi_abayertnrV23_GetAttrib(mAlgoCtx, att);
120             att->sync.done = true;
121         }
122     }
123 #endif
124 
125     EXIT_ANALYZER_FUNCTION();
126     return ret;
127 }
128 
setAttribLite(const rk_aiq_bayertnr_attrib_v23L_t * att)129 XCamReturn RkAiqAbayertnrV23HandleInt::setAttribLite(const rk_aiq_bayertnr_attrib_v23L_t* att) {
130     ENTER_ANALYZER_FUNCTION();
131 
132     XCamReturn ret = XCAM_RETURN_NO_ERROR;
133     mCfgMutex.lock();
134     // TODO
135     // check if there is different between att & mCurAtt
136     // if something changed, set att to mNewAtt, and
137     // the new params will be effective later when updateConfig
138     // called by RkAiqCore
139 
140 #ifdef DISABLE_HANDLE_ATTRIB
141     ret = rk_aiq_uapi_abayertnrV23Lite_SetAttrib(mAlgoCtx, att, false);
142 #else
143     // if something changed
144     if (0 != memcmp(&mCurAttLite, att, sizeof(rk_aiq_bayertnr_attrib_v23L_t))) {
145         mNewAttLite   = *att;
146         updateAttLite = true;
147         waitSignal(att->sync.sync_mode);
148     }
149 #endif
150     mCfgMutex.unlock();
151 
152     EXIT_ANALYZER_FUNCTION();
153     return ret;
154 }
155 
getAttribLite(rk_aiq_bayertnr_attrib_v23L_t * att)156 XCamReturn RkAiqAbayertnrV23HandleInt::getAttribLite(rk_aiq_bayertnr_attrib_v23L_t* att) {
157     ENTER_ANALYZER_FUNCTION();
158 
159     XCamReturn ret = XCAM_RETURN_NO_ERROR;
160 #ifdef DISABLE_HANDLE_ATTRIB
161       mCfgMutex.lock();
162       ret = rk_aiq_uapi_abayertnrV23Lite_GetAttrib(mAlgoCtx, att);
163       mCfgMutex.unlock();
164 #else
165     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
166         mCfgMutex.lock();
167         rk_aiq_uapi_abayertnrV23Lite_GetAttrib(mAlgoCtx, att);
168         att->sync.done = true;
169         mCfgMutex.unlock();
170     } else {
171         if (updateAttLite) {
172             memcpy(att, &mNewAttLite, sizeof(mNewAttLite));
173             mCfgMutex.unlock();
174             att->sync.done = false;
175         } else {
176             mCfgMutex.unlock();
177             rk_aiq_uapi_abayertnrV23Lite_GetAttrib(mAlgoCtx, att);
178             att->sync.done = true;
179         }
180     }
181 #endif
182 
183     EXIT_ANALYZER_FUNCTION();
184     return ret;
185 }
186 
setStrength(const rk_aiq_bayertnr_strength_v23_t * pStrength)187 XCamReturn RkAiqAbayertnrV23HandleInt::setStrength(const rk_aiq_bayertnr_strength_v23_t *pStrength) {
188     ENTER_ANALYZER_FUNCTION();
189 
190     XCamReturn ret = XCAM_RETURN_NO_ERROR;
191     mCfgMutex.lock();
192 #ifdef DISABLE_HANDLE_ATTRIB
193     ret = rk_aiq_uapi_abayertnrV23_SetStrength(mAlgoCtx, pStrength);
194 #else
195 
196     if (0 != memcmp(&mCurStrength, pStrength, sizeof(mCurStrength))) {
197         mNewStrength   = *pStrength;
198         updateStrength = true;
199         waitSignal(pStrength->sync.sync_mode);
200     }
201 #endif
202 
203 
204     mCfgMutex.unlock();
205     EXIT_ANALYZER_FUNCTION();
206     return ret;
207 }
208 
getStrength(rk_aiq_bayertnr_strength_v23_t * pStrength)209 XCamReturn RkAiqAbayertnrV23HandleInt::getStrength(rk_aiq_bayertnr_strength_v23_t *pStrength) {
210     ENTER_ANALYZER_FUNCTION();
211 
212     XCamReturn ret = XCAM_RETURN_NO_ERROR;
213 
214 #ifdef DISABLE_HANDLE_ATTRIB
215         mCfgMutex.lock();
216         ret = rk_aiq_uapi_abayertnrV23_GetStrength(mAlgoCtx, pStrength);
217         mCfgMutex.unlock();
218 #else
219     if(pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
220         mCfgMutex.lock();
221         rk_aiq_uapi_abayertnrV23_GetStrength(mAlgoCtx, pStrength);
222         pStrength->sync.done = true;
223         mCfgMutex.unlock();
224     } else {
225         if(updateStrength) {
226             pStrength->percent = mNewStrength.percent;
227             pStrength->sync.done = false;
228         } else {
229             rk_aiq_uapi_abayertnrV23_GetStrength(mAlgoCtx, pStrength);
230             pStrength->sync.done = true;
231         }
232     }
233 #endif
234 
235     EXIT_ANALYZER_FUNCTION();
236     return ret;
237 }
238 
getInfo(rk_aiq_bayertnr_info_v23_t * pInfo)239 XCamReturn RkAiqAbayertnrV23HandleInt::getInfo(rk_aiq_bayertnr_info_v23_t *pInfo) {
240     ENTER_ANALYZER_FUNCTION();
241 
242     XCamReturn ret = XCAM_RETURN_NO_ERROR;
243 
244     if(pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
245         mCfgMutex.lock();
246         rk_aiq_uapi_abayertnrV23_GetInfo(mAlgoCtx, pInfo);
247         pInfo->sync.done = true;
248         mCfgMutex.unlock();
249     } else {
250         rk_aiq_uapi_abayertnrV23_GetInfo(mAlgoCtx, pInfo);
251         pInfo->sync.done = true;
252     }
253 
254     EXIT_ANALYZER_FUNCTION();
255     return ret;
256 }
257 
258 
prepare()259 XCamReturn RkAiqAbayertnrV23HandleInt::prepare() {
260     ENTER_ANALYZER_FUNCTION();
261 
262     XCamReturn ret = XCAM_RETURN_NO_ERROR;
263 
264     ret = RkAiqHandle::prepare();
265     RKAIQCORE_CHECK_RET(ret, "arawnr handle prepare failed");
266 
267     RkAiqAlgoConfigAbayertnrV23* abayertnr_config_int = (RkAiqAlgoConfigAbayertnrV23*)mConfig;
268 
269     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
270     ret                       = des->prepare(mConfig);
271     RKAIQCORE_CHECK_RET(ret, "arawnr algo prepare failed");
272 
273     EXIT_ANALYZER_FUNCTION();
274     return XCAM_RETURN_NO_ERROR;
275 }
276 
preProcess()277 XCamReturn RkAiqAbayertnrV23HandleInt::preProcess() {
278     ENTER_ANALYZER_FUNCTION();
279 
280     XCamReturn ret = XCAM_RETURN_NO_ERROR;
281 #if 0
282     RkAiqAlgoPreAbayertnrV23* abayertnr_pre_int = (RkAiqAlgoPreAbayertnrV23*)mPreInParam;
283     RkAiqAlgoPreResAbayertnrV23* abayertnr_pre_res_int =
284         (RkAiqAlgoPreResAbayertnrV23*)mPreOutParam;
285     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
286         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
287     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
288 
289     ret = RkAiqHandle::preProcess();
290     if (ret) {
291         RKAIQCORE_CHECK_RET(ret, "arawnr handle preProcess failed");
292     }
293 
294     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
295     ret                       = des->pre_process(mPreInParam, mPreOutParam);
296     RKAIQCORE_CHECK_RET(ret, "arawnr algo pre_process failed");
297     // set result to mAiqCore
298 
299     EXIT_ANALYZER_FUNCTION();
300 #endif
301     return XCAM_RETURN_NO_ERROR;
302 }
303 
processing()304 XCamReturn RkAiqAbayertnrV23HandleInt::processing() {
305     ENTER_ANALYZER_FUNCTION();
306 
307     XCamReturn ret = XCAM_RETURN_NO_ERROR;
308 
309     RkAiqAlgoProcAbayertnrV23* abayertnr_proc_int = (RkAiqAlgoProcAbayertnrV23*)mProcInParam;
310     RkAiqAlgoProcResAbayertnrV23* abayertnr_proc_res_int =
311         (RkAiqAlgoProcResAbayertnrV23*)mProcOutParam;
312     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
313         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
314     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
315 
316     abayertnr_proc_res_int->stAbayertnrProcResult.st3DFix = &shared->fullParams->mTnrV32Params->data()->result;
317 
318     ret = RkAiqHandle::processing();
319     if (ret) {
320         RKAIQCORE_CHECK_RET(ret, "aynr handle processing failed");
321     }
322 
323     // TODO: fill procParam
324     abayertnr_proc_int->iso      = sharedCom->iso;
325     abayertnr_proc_int->hdr_mode = sharedCom->working_mode;
326 
327 
328 
329 #ifdef DISABLE_HANDLE_ATTRIB
330     mCfgMutex.lock();
331 #endif
332     abayertnr_proc_int->stAblcV32_proc_res = shared->res_comb.ablcV32_proc_res;
333     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
334     ret                       = des->processing(mProcInParam, mProcOutParam);
335 #ifdef DISABLE_HANDLE_ATTRIB
336     mCfgMutex.unlock();
337 #endif
338     RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
339 
340     shared->res_comb.bayernr3d_en = !abayertnr_proc_res_int->stAbayertnrProcResult.st3DFix->bay3d_en ? false : true;
341 
342     EXIT_ANALYZER_FUNCTION();
343     return ret;
344 }
345 
postProcess()346 XCamReturn RkAiqAbayertnrV23HandleInt::postProcess() {
347     ENTER_ANALYZER_FUNCTION();
348 
349     XCamReturn ret = XCAM_RETURN_NO_ERROR;
350 #if 0
351     RkAiqAlgoPostAbayer2dnrV23* abayertnr_post_int = (RkAiqAlgoPostAbayer2dnrV23*)mPostInParam;
352     RkAiqAlgoPostResAbayer2dnrV23* abayertnr_post_res_int =
353         (RkAiqAlgoPostResAbayer2dnrV23*)mPostOutParam;
354     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
355         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
356     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
357 
358     ret = RkAiqHandle::postProcess();
359     if (ret) {
360         RKAIQCORE_CHECK_RET(ret, "arawnr handle postProcess failed");
361         return ret;
362     }
363 
364     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
365     ret                       = des->post_process(mPostInParam, mPostOutParam);
366     RKAIQCORE_CHECK_RET(ret, "arawnr algo post_process failed");
367     // set result to mAiqCore
368 
369     EXIT_ANALYZER_FUNCTION();
370 #endif
371     return ret;
372 }
373 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)374 XCamReturn RkAiqAbayertnrV23HandleInt::genIspResult(RkAiqFullParams* params,
375         RkAiqFullParams* cur_params) {
376     ENTER_ANALYZER_FUNCTION();
377 
378     XCamReturn ret                = XCAM_RETURN_NO_ERROR;
379     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
380         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
381     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
382     RkAiqAlgoProcResAbayertnrV23* atnr_rk = (RkAiqAlgoProcResAbayertnrV23*)mProcOutParam;
383 
384     if (!atnr_rk) {
385         LOGD_ANALYZER("no abayertnr result");
386         return XCAM_RETURN_NO_ERROR;
387     }
388 
389     if (!this->getAlgoId()) {
390         LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
391         rk_aiq_isp_tnr_params_v32_t* tnr_param = params->mTnrV32Params->data().ptr();
392         if (sharedCom->init) {
393             tnr_param->frame_id = 0;
394         } else {
395             tnr_param->frame_id = shared->frameId;
396         }
397 
398         if (atnr_rk->res_com.cfg_update) {
399             mSyncFlag = shared->frameId;
400             tnr_param->sync_flag = mSyncFlag;
401             // copy from algo result
402             // set as the latest result
403             cur_params->mTnrV32Params = params->mTnrV32Params;
404             tnr_param->is_update = true;
405             LOGD_ANR("[%d] params from algo", mSyncFlag);
406         } else if (mSyncFlag != tnr_param->sync_flag) {
407             tnr_param->sync_flag = mSyncFlag;
408             // copy from latest result
409             if (cur_params->mTnrV32Params.ptr()) {
410                 tnr_param->result = cur_params->mTnrV32Params->data()->result;
411                 tnr_param->is_update = true;
412             } else {
413                 LOGE_ANR("no latest params !");
414                 tnr_param->is_update = false;
415             }
416             LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
417         } else {
418             // do nothing, result in buf needn't update
419             tnr_param->is_update = false;
420             LOGD_ANR("[%d] params needn't update", shared->frameId);
421         }
422         LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
423     }
424 
425     EXIT_ANALYZER_FUNCTION();
426 
427     return ret;
428 }
429 
430 }  // namespace RkCam
431