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 "RkAiqAbayer2dnrV2Handle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAbayer2dnrV2HandleInt);
23 
init()24 void RkAiqAbayer2dnrV2HandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAbayer2dnrV2());
29     mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAbayer2dnrV2());
30     mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAbayer2dnrV2());
31     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAbayer2dnrV2());
32     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAbayer2dnrV2());
33     mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAbayer2dnrV2());
34     mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAbayer2dnrV2());
35 
36     EXIT_ANALYZER_FUNCTION();
37 }
38 
updateConfig(bool needSync)39 XCamReturn RkAiqAbayer2dnrV2HandleInt::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_abayer2dnrV2_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_abayer2dnrV2_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_bayer2dnr_attrib_v2_t * att)67 XCamReturn RkAiqAbayer2dnrV2HandleInt::setAttrib(rk_aiq_bayer2dnr_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_abayer2dnrV2_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_bayer2dnr_attrib_v2_t * att)102 XCamReturn RkAiqAbayer2dnrV2HandleInt::getAttrib(rk_aiq_bayer2dnr_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_abayer2dnrV2_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_abayer2dnrV2_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_abayer2dnrV2_GetAttrib(mAlgoCtx, att);
125             att->sync.done = true;
126         }
127     }
128 #endif
129 
130 
131     EXIT_ANALYZER_FUNCTION();
132     return ret;
133 }
134 
135 
setStrength(rk_aiq_bayer2dnr_strength_v2_t * pStrength)136 XCamReturn RkAiqAbayer2dnrV2HandleInt::setStrength(rk_aiq_bayer2dnr_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_abayer2dnrV2_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     mCfgMutex.unlock();
161     EXIT_ANALYZER_FUNCTION();
162     return ret;
163 }
164 
getStrength(rk_aiq_bayer2dnr_strength_v2_t * pStrength)165 XCamReturn RkAiqAbayer2dnrV2HandleInt::getStrength(rk_aiq_bayer2dnr_strength_v2_t *pStrength) {
166     ENTER_ANALYZER_FUNCTION();
167 
168     XCamReturn ret = XCAM_RETURN_NO_ERROR;
169 #ifdef DISABLE_HANDLE_ATTRIB
170     mCfgMutex.lock();
171     rk_aiq_uapi_abayer2dnrV2_GetStrength(mAlgoCtx, pStrength);
172     mCfgMutex.unlock();
173 #else
174     if(pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
175         mCfgMutex.lock();
176         rk_aiq_uapi_abayer2dnrV2_GetStrength(mAlgoCtx, pStrength);
177         pStrength->sync.done = true;
178         mCfgMutex.unlock();
179     } else {
180         if(updateStrength) {
181             *pStrength = mNewStrength;
182             pStrength->sync.done = false;
183         } else {
184             rk_aiq_uapi_abayer2dnrV2_GetStrength(mAlgoCtx, pStrength);
185             pStrength->sync.done = true;
186         }
187     }
188 #endif
189 
190     EXIT_ANALYZER_FUNCTION();
191     return ret;
192 }
193 
194 
getInfo(rk_aiq_bayer2dnr_info_v2_t * pInfo)195 XCamReturn RkAiqAbayer2dnrV2HandleInt::getInfo(rk_aiq_bayer2dnr_info_v2_t *pInfo) {
196     ENTER_ANALYZER_FUNCTION();
197 
198     XCamReturn ret = XCAM_RETURN_NO_ERROR;
199 
200     if(pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
201         mCfgMutex.lock();
202         rk_aiq_uapi_abayer2dnrV2_GetInfo(mAlgoCtx, pInfo);
203         pInfo->sync.done = true;
204         mCfgMutex.unlock();
205     } else {
206         rk_aiq_uapi_abayer2dnrV2_GetInfo(mAlgoCtx, pInfo);
207         pInfo->sync.done = true;
208     }
209 
210     EXIT_ANALYZER_FUNCTION();
211     return ret;
212 }
213 
214 
prepare()215 XCamReturn RkAiqAbayer2dnrV2HandleInt::prepare() {
216     ENTER_ANALYZER_FUNCTION();
217 
218     XCamReturn ret = XCAM_RETURN_NO_ERROR;
219 
220     ret = RkAiqHandle::prepare();
221     RKAIQCORE_CHECK_RET(ret, "arawnr handle prepare failed");
222 
223     RkAiqAlgoConfigAbayer2dnrV2* aynr_config_int = (RkAiqAlgoConfigAbayer2dnrV2*)mConfig;
224 
225     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
226     ret                       = des->prepare(mConfig);
227     RKAIQCORE_CHECK_RET(ret, "arawnr algo prepare failed");
228 
229     EXIT_ANALYZER_FUNCTION();
230     return XCAM_RETURN_NO_ERROR;
231 }
232 
preProcess()233 XCamReturn RkAiqAbayer2dnrV2HandleInt::preProcess() {
234     ENTER_ANALYZER_FUNCTION();
235 
236     XCamReturn ret = XCAM_RETURN_NO_ERROR;
237 
238     RkAiqAlgoPreAbayer2dnrV2* arawnr_pre_int = (RkAiqAlgoPreAbayer2dnrV2*)mPreInParam;
239     RkAiqAlgoPreResAbayer2dnrV2* arawnr_pre_res_int =
240         (RkAiqAlgoPreResAbayer2dnrV2*)mPreOutParam;
241     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
242         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
243     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
244 
245     ret = RkAiqHandle::preProcess();
246     if (ret) {
247         RKAIQCORE_CHECK_RET(ret, "arawnr handle preProcess failed");
248     }
249 
250     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
251     ret                       = des->pre_process(mPreInParam, mPreOutParam);
252     RKAIQCORE_CHECK_RET(ret, "arawnr algo pre_process failed");
253     // set result to mAiqCore
254 
255     EXIT_ANALYZER_FUNCTION();
256     return XCAM_RETURN_NO_ERROR;
257 }
258 
processing()259 XCamReturn RkAiqAbayer2dnrV2HandleInt::processing() {
260     ENTER_ANALYZER_FUNCTION();
261 
262     XCamReturn ret = XCAM_RETURN_NO_ERROR;
263 
264     RkAiqAlgoProcAbayer2dnrV2* arawnr_proc_int = (RkAiqAlgoProcAbayer2dnrV2*)mProcInParam;
265     RkAiqAlgoProcResAbayer2dnrV2* arawnr_proc_res_int =
266         (RkAiqAlgoProcResAbayer2dnrV2*)mProcOutParam;
267     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
268         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
269     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
270 
271     arawnr_proc_res_int->stArawnrProcResult.st2DFix = &shared->fullParams->mBaynrV3xParams->data()->result;
272 
273     ret = RkAiqHandle::processing();
274     if (ret) {
275         RKAIQCORE_CHECK_RET(ret, "aynr handle processing failed");
276     }
277 
278     // TODO: fill procParam
279     arawnr_proc_int->iso      = sharedCom->iso;
280     arawnr_proc_int->hdr_mode = sharedCom->working_mode;
281 
282 #ifdef DISABLE_HANDLE_ATTRIB
283     mCfgMutex.lock();
284 #endif
285     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
286     ret                       = des->processing(mProcInParam, mProcOutParam);
287 #ifdef DISABLE_HANDLE_ATTRIB
288     mCfgMutex.unlock();
289 #endif
290     RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
291 
292     EXIT_ANALYZER_FUNCTION();
293     return ret;
294 }
295 
postProcess()296 XCamReturn RkAiqAbayer2dnrV2HandleInt::postProcess() {
297     ENTER_ANALYZER_FUNCTION();
298 
299     XCamReturn ret = XCAM_RETURN_NO_ERROR;
300 
301     RkAiqAlgoPostAbayer2dnrV2* arawnr_post_int = (RkAiqAlgoPostAbayer2dnrV2*)mPostInParam;
302     RkAiqAlgoPostResAbayer2dnrV2* arawnr_post_res_int =
303         (RkAiqAlgoPostResAbayer2dnrV2*)mPostOutParam;
304     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
305         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
306     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
307 
308     ret = RkAiqHandle::postProcess();
309     if (ret) {
310         RKAIQCORE_CHECK_RET(ret, "arawnr handle postProcess failed");
311         return ret;
312     }
313 
314     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
315     ret                       = des->post_process(mPostInParam, mPostOutParam);
316     RKAIQCORE_CHECK_RET(ret, "arawnr algo post_process failed");
317 
318     EXIT_ANALYZER_FUNCTION();
319     return ret;
320 }
321 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)322 XCamReturn RkAiqAbayer2dnrV2HandleInt::genIspResult(RkAiqFullParams* params,
323         RkAiqFullParams* cur_params) {
324     ENTER_ANALYZER_FUNCTION();
325 
326     XCamReturn ret                = XCAM_RETURN_NO_ERROR;
327     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
328         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
329     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
330     RkAiqAlgoProcResAbayer2dnrV2* arawnr_rk = (RkAiqAlgoProcResAbayer2dnrV2*)mProcOutParam;
331 
332     if (!arawnr_rk) {
333         LOGD_ANALYZER("no arawnr result");
334         return XCAM_RETURN_NO_ERROR;
335     }
336 
337     if (!this->getAlgoId()) {
338         LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
339         rk_aiq_isp_baynr_params_v3x_t* rawnr_param = params->mBaynrV3xParams->data().ptr();
340         if (sharedCom->init) {
341             rawnr_param->frame_id = 0;
342         } else {
343             rawnr_param->frame_id = shared->frameId;
344         }
345 
346         if (arawnr_rk->res_com.cfg_update) {
347             mSyncFlag = shared->frameId;
348             rawnr_param->sync_flag = mSyncFlag;
349             // copy from algo result
350             // set as the latest result
351             cur_params->mBaynrV3xParams = params->mBaynrV3xParams;
352             rawnr_param->is_update = true;
353             LOGD_ANR("[%d] params from algo", mSyncFlag);
354         } else if (mSyncFlag != rawnr_param->sync_flag) {
355             rawnr_param->sync_flag = mSyncFlag;
356             // copy from latest result
357             if (cur_params->mBaynrV3xParams.ptr()) {
358                 rawnr_param->result = cur_params->mBaynrV3xParams->data()->result;
359                 rawnr_param->is_update = true;
360             } else {
361                 LOGE_ANR("no latest params !");
362                 rawnr_param->is_update = false;
363             }
364             LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
365         } else {
366             // do nothing, result in buf needn't update
367             rawnr_param->is_update = false;
368             LOGD_ANR("[%d] params needn't update", shared->frameId);
369         }
370         LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
371     }
372 
373     EXIT_ANALYZER_FUNCTION();
374 
375     return ret;
376 }
377 
378 }  // namespace RkCam
379