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 "RkAiqAbayer2dnrV23Handle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAbayer2dnrV23HandleInt);
23 
init()24 void RkAiqAbayer2dnrV23HandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAbayer2dnrV23());
29     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAbayer2dnrV23());
30     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAbayer2dnrV23());
31 
32     EXIT_ANALYZER_FUNCTION();
33 }
34 
updateConfig(bool needSync)35 XCamReturn RkAiqAbayer2dnrV23HandleInt::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_abayer2dnrV23_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_abayer2dnrV23_SetStrength(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_bayer2dnr_attrib_v23_t * att)63 XCamReturn RkAiqAbayer2dnrV23HandleInt::setAttrib(const rk_aiq_bayer2dnr_attrib_v23_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_abayer2dnrV23_SetAttrib(mAlgoCtx, att, false);
76 #else
77     // if something changed
78     if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_bayer2dnr_attrib_v23_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_bayer2dnr_attrib_v23_t * att)91 XCamReturn RkAiqAbayer2dnrV23HandleInt::getAttrib(rk_aiq_bayer2dnr_attrib_v23_t* att) {
92     ENTER_ANALYZER_FUNCTION();
93 
94     XCamReturn ret = XCAM_RETURN_NO_ERROR;
95 
96 #ifdef DISABLE_HANDLE_ATTRIB
97       mCfgMutex.lock();
98       ret = rk_aiq_uapi_abayer2dnrV23_GetAttrib(mAlgoCtx, att);
99       mCfgMutex.unlock();
100 #else
101     if(att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
102         mCfgMutex.lock();
103         rk_aiq_uapi_abayer2dnrV23_GetAttrib(mAlgoCtx, att);
104         att->sync.done = true;
105         mCfgMutex.unlock();
106     } else {
107         if(updateAtt) {
108             memcpy(att, &mNewAtt, sizeof(mNewAtt));
109             mCfgMutex.unlock();
110             att->sync.done = false;
111         } else {
112             mCfgMutex.unlock();
113             rk_aiq_uapi_abayer2dnrV23_GetAttrib(mAlgoCtx, att);
114             att->sync.done = true;
115         }
116     }
117 #endif
118 
119 
120     EXIT_ANALYZER_FUNCTION();
121     return ret;
122 }
123 
124 
setStrength(const rk_aiq_bayer2dnr_strength_v23_t * pStrength)125 XCamReturn RkAiqAbayer2dnrV23HandleInt::setStrength(const rk_aiq_bayer2dnr_strength_v23_t *pStrength) {
126     ENTER_ANALYZER_FUNCTION();
127 
128 
129     XCamReturn ret = XCAM_RETURN_NO_ERROR;
130     mCfgMutex.lock();
131 
132 #ifdef DISABLE_HANDLE_ATTRIB
133     ret = rk_aiq_uapi_abayer2dnrV23_SetStrength(mAlgoCtx, pStrength);
134 #else
135     if (0 != memcmp(&mCurStrength, pStrength, sizeof(mCurStrength))) {
136         mNewStrength   = *pStrength;
137         updateStrength = true;
138         waitSignal(pStrength->sync.sync_mode);
139     }
140 #endif
141 
142     mCfgMutex.unlock();
143     EXIT_ANALYZER_FUNCTION();
144     return ret;
145 }
146 
getStrength(rk_aiq_bayer2dnr_strength_v23_t * pStrength)147 XCamReturn RkAiqAbayer2dnrV23HandleInt::getStrength(rk_aiq_bayer2dnr_strength_v23_t *pStrength) {
148     ENTER_ANALYZER_FUNCTION();
149 
150     XCamReturn ret = XCAM_RETURN_NO_ERROR;
151 
152 #ifdef DISABLE_HANDLE_ATTRIB
153         mCfgMutex.lock();
154         ret = rk_aiq_uapi_abayer2dnrV23_GetStrength(mAlgoCtx, pStrength);
155         mCfgMutex.unlock();
156 #else
157     if(pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
158         mCfgMutex.lock();
159         rk_aiq_uapi_abayer2dnrV23_GetStrength(mAlgoCtx, pStrength);
160         pStrength->sync.done = true;
161         mCfgMutex.unlock();
162     } else {
163         if(updateStrength) {
164             pStrength->percent = mNewStrength.percent;
165             pStrength->sync.done = false;
166         } else {
167             rk_aiq_uapi_abayer2dnrV23_GetStrength(mAlgoCtx, pStrength);
168             pStrength->sync.done = true;
169         }
170     }
171 #endif
172 
173     EXIT_ANALYZER_FUNCTION();
174     return ret;
175 }
176 
getInfo(rk_aiq_bayer2dnr_info_v23_t * pInfo)177 XCamReturn RkAiqAbayer2dnrV23HandleInt::getInfo(rk_aiq_bayer2dnr_info_v23_t *pInfo) {
178     ENTER_ANALYZER_FUNCTION();
179 
180     XCamReturn ret = XCAM_RETURN_NO_ERROR;
181 
182     if(pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
183         mCfgMutex.lock();
184         rk_aiq_uapi_abayer2dnrV23_GetInfo(mAlgoCtx, pInfo);
185         pInfo->sync.done = true;
186         mCfgMutex.unlock();
187     } else {
188         rk_aiq_uapi_abayer2dnrV23_GetInfo(mAlgoCtx, pInfo);
189         pInfo->sync.done = true;
190     }
191 
192     EXIT_ANALYZER_FUNCTION();
193     return ret;
194 }
195 
196 
prepare()197 XCamReturn RkAiqAbayer2dnrV23HandleInt::prepare() {
198     ENTER_ANALYZER_FUNCTION();
199 
200     XCamReturn ret = XCAM_RETURN_NO_ERROR;
201 
202     ret = RkAiqHandle::prepare();
203     RKAIQCORE_CHECK_RET(ret, "arawnr handle prepare failed");
204 
205     RkAiqAlgoConfigAbayer2dnrV23* aynr_config_int = (RkAiqAlgoConfigAbayer2dnrV23*)mConfig;
206 
207     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
208     ret                       = des->prepare(mConfig);
209     RKAIQCORE_CHECK_RET(ret, "arawnr algo prepare failed");
210 
211     EXIT_ANALYZER_FUNCTION();
212     return XCAM_RETURN_NO_ERROR;
213 }
214 
preProcess()215 XCamReturn RkAiqAbayer2dnrV23HandleInt::preProcess() {
216     ENTER_ANALYZER_FUNCTION();
217 
218     XCamReturn ret = XCAM_RETURN_NO_ERROR;
219 #if 0
220 
221     RkAiqAlgoPreAbayer2dnrV23* arawnr_pre_int = (RkAiqAlgoPreAbayer2dnrV23*)mPreInParam;
222     RkAiqAlgoPreResAbayer2dnrV23* arawnr_pre_res_int =
223         (RkAiqAlgoPreResAbayer2dnrV23*)mPreOutParam;
224     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
225         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
226     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
227 
228     ret = RkAiqHandle::preProcess();
229     if (ret) {
230         RKAIQCORE_CHECK_RET(ret, "arawnr handle preProcess failed");
231     }
232 
233     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
234     ret                       = des->pre_process(mPreInParam, mPreOutParam);
235     RKAIQCORE_CHECK_RET(ret, "arawnr algo pre_process failed");
236     // set result to mAiqCore
237 
238     EXIT_ANALYZER_FUNCTION();
239 #endif
240     return XCAM_RETURN_NO_ERROR;
241 }
242 
processing()243 XCamReturn RkAiqAbayer2dnrV23HandleInt::processing() {
244     ENTER_ANALYZER_FUNCTION();
245 
246     XCamReturn ret = XCAM_RETURN_NO_ERROR;
247 
248     RkAiqAlgoProcAbayer2dnrV23* arawnr_proc_int = (RkAiqAlgoProcAbayer2dnrV23*)mProcInParam;
249     RkAiqAlgoProcResAbayer2dnrV23* arawnr_proc_res_int =
250         (RkAiqAlgoProcResAbayer2dnrV23*)mProcOutParam;
251     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
252         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
253     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
254 
255     arawnr_proc_res_int->stArawnrProcResult.st2DFix = &shared->fullParams->mBaynrV32Params->data()->result;
256 
257     ret = RkAiqHandle::processing();
258     if (ret) {
259         RKAIQCORE_CHECK_RET(ret, "aynr handle processing failed");
260     }
261 
262     // TODO: fill procParam
263     arawnr_proc_int->iso      = sharedCom->iso;
264     arawnr_proc_int->hdr_mode = sharedCom->working_mode;
265 
266     arawnr_proc_int->stAblcV32_proc_res = shared->res_comb.ablcV32_proc_res;
267     arawnr_proc_int->bayertnr_en = shared->res_comb.bayernr3d_en;
268 
269 #ifdef DISABLE_HANDLE_ATTRIB
270     mCfgMutex.lock();
271 #endif
272     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
273     ret                       = des->processing(mProcInParam, mProcOutParam);
274 #ifdef DISABLE_HANDLE_ATTRIB
275     mCfgMutex.unlock();
276 #endif
277     RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
278 
279     EXIT_ANALYZER_FUNCTION();
280     return ret;
281 }
282 
postProcess()283 XCamReturn RkAiqAbayer2dnrV23HandleInt::postProcess() {
284     ENTER_ANALYZER_FUNCTION();
285 
286     XCamReturn ret = XCAM_RETURN_NO_ERROR;
287 #if 0
288     RkAiqAlgoPostAbayer2dnrV23* arawnr_post_int = (RkAiqAlgoPostAbayer2dnrV23*)mPostInParam;
289     RkAiqAlgoPostResAbayer2dnrV23* arawnr_post_res_int =
290         (RkAiqAlgoPostResAbayer2dnrV23*)mPostOutParam;
291     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
292         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
293     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
294 
295     ret = RkAiqHandle::postProcess();
296     if (ret) {
297         RKAIQCORE_CHECK_RET(ret, "arawnr handle postProcess failed");
298         return ret;
299     }
300 
301     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
302     ret                       = des->post_process(mPostInParam, mPostOutParam);
303     RKAIQCORE_CHECK_RET(ret, "arawnr algo post_process failed");
304 
305     EXIT_ANALYZER_FUNCTION();
306 #endif
307     return ret;
308 }
309 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)310 XCamReturn RkAiqAbayer2dnrV23HandleInt::genIspResult(RkAiqFullParams* params,
311         RkAiqFullParams* cur_params) {
312     ENTER_ANALYZER_FUNCTION();
313 
314     XCamReturn ret                = XCAM_RETURN_NO_ERROR;
315     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
316         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
317     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
318     RkAiqAlgoProcResAbayer2dnrV23* arawnr_rk = (RkAiqAlgoProcResAbayer2dnrV23*)mProcOutParam;
319 
320     if (!arawnr_rk) {
321         LOGD_ANALYZER("no arawnr result");
322         return XCAM_RETURN_NO_ERROR;
323     }
324 
325     if (!this->getAlgoId()) {
326         LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
327         rk_aiq_isp_baynr_params_v32_t* rawnr_param = params->mBaynrV32Params->data().ptr();
328         if (sharedCom->init) {
329             rawnr_param->frame_id = 0;
330         } else {
331             rawnr_param->frame_id = shared->frameId;
332         }
333 
334         if (arawnr_rk->res_com.cfg_update) {
335             mSyncFlag = shared->frameId;
336             rawnr_param->sync_flag = mSyncFlag;
337             // copy from algo result
338             // set as the latest result
339             cur_params->mBaynrV32Params = params->mBaynrV32Params;
340             rawnr_param->is_update = true;
341             LOGD_ANR("[%d] params from algo", mSyncFlag);
342         } else if (mSyncFlag != rawnr_param->sync_flag) {
343             rawnr_param->sync_flag = mSyncFlag;
344             // copy from latest result
345             if (cur_params->mBaynrV32Params.ptr()) {
346                 rawnr_param->result = cur_params->mBaynrV32Params->data()->result;
347                 rawnr_param->is_update = true;
348             } else {
349                 LOGE_ANR("no latest params !");
350                 rawnr_param->is_update = false;
351             }
352             LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
353         } else {
354             // do nothing, result in buf needn't update
355             rawnr_param->is_update = false;
356             LOGD_ANR("[%d] params needn't update", shared->frameId);
357         }
358         LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
359     }
360 
361     EXIT_ANALYZER_FUNCTION();
362 
363     return ret;
364 }
365 
366 }  // namespace RkCam
367