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