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