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 
17 #include "RkAiqAdebayerHandle.h"
18 
19 #include "RkAiqCore.h"
20 
21 namespace RkCam {
22 
23 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAdebayerHandleInt);
24 
init()25 void RkAiqAdebayerHandleInt::init() {
26     ENTER_ANALYZER_FUNCTION();
27 
28     RkAiqHandle::deInit();
29     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAdebayer());
30     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAdebayer());
31     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAdebayer());
32 
33     EXIT_ANALYZER_FUNCTION();
34 }
35 
updateConfig(bool needSync)36 XCamReturn RkAiqAdebayerHandleInt::updateConfig(bool needSync) {
37     ENTER_ANALYZER_FUNCTION();
38 
39     XCamReturn ret = XCAM_RETURN_NO_ERROR;
40 #ifndef DISABLE_HANDLE_ATTRIB
41     if (needSync) mCfgMutex.lock();
42     // if something changed
43     if (updateAtt) {
44 #if RKAIQ_HAVE_DEBAYER_V1
45         mCurAtt   = mNewAtt;
46         rk_aiq_uapi_adebayer_SetAttrib(mAlgoCtx, mCurAtt, false);
47         sendSignal(mCurAtt.sync.sync_mode);
48         updateAtt = false;
49 #endif
50 
51 #if RKAIQ_HAVE_DEBAYER_V2
52         mCurAttV2 = mNewAttV2;
53         rk_aiq_uapi_adebayer_v2_SetAttrib(mAlgoCtx, mCurAttV2, false);
54         sendSignal(mCurAttV2.sync.sync_mode);
55         updateAtt = false;
56 #endif
57 
58 #if RKAIQ_HAVE_DEBAYER_V2_LITE
59         mCurAttV2Lite = mNewAttV2Lite;
60         rk_aiq_uapi_adebayer_v2lite_SetAttrib(mAlgoCtx, mCurAttV2Lite, false);
61         sendSignal(mCurAttV2Lite.sync.sync_mode);
62         updateAtt = false;
63 #endif
64 
65     }
66 
67     if (needSync) mCfgMutex.unlock();
68 #endif
69     EXIT_ANALYZER_FUNCTION();
70     return ret;
71 }
72 #if RKAIQ_HAVE_DEBAYER_V1
setAttrib(adebayer_attrib_t att)73 XCamReturn RkAiqAdebayerHandleInt::setAttrib(adebayer_attrib_t att) {
74     ENTER_ANALYZER_FUNCTION();
75 
76     XCamReturn ret = XCAM_RETURN_NO_ERROR;
77     mCfgMutex.lock();
78 
79 #ifdef DISABLE_HANDLE_ATTRIB
80     ret = rk_aiq_uapi_adebayer_SetAttrib(mAlgoCtx, att, false);
81 #else
82     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
83     // if something changed, set att to mNewAtt, and
84     // the new params will be effective later when updateConfig
85     // called by RkAiqCore
86     bool isChanged = false;
87     if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
88             memcmp(&mNewAtt, &att, sizeof(att)))
89         isChanged = true;
90     else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
91              memcmp(&mCurAtt, &att, sizeof(att)))
92         isChanged = true;
93 
94     // if something changed
95     if (isChanged) {
96         mNewAtt   = att;
97         updateAtt = true;
98         waitSignal(att.sync.sync_mode);
99     }
100 #endif
101     mCfgMutex.unlock();
102 
103     EXIT_ANALYZER_FUNCTION();
104     return ret;
105 }
106 
getAttrib(adebayer_attrib_t * att)107 XCamReturn RkAiqAdebayerHandleInt::getAttrib(adebayer_attrib_t* att) {
108     ENTER_ANALYZER_FUNCTION();
109 
110     XCamReturn ret = XCAM_RETURN_NO_ERROR;
111 
112 #ifdef DISABLE_HANDLE_ATTRIB
113     mCfgMutex.lock();
114     rk_aiq_uapi_adebayer_GetAttrib(mAlgoCtx, att);
115     att->sync.done = true;
116     mCfgMutex.unlock();
117 #else
118     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
119         mCfgMutex.lock();
120         rk_aiq_uapi_adebayer_GetAttrib(mAlgoCtx, att);
121         att->sync.done = true;
122         mCfgMutex.unlock();
123     } else {
124         if (updateAtt) {
125             memcpy(att, &mNewAtt, sizeof(mNewAtt));
126             att->sync.done = false;
127         } else {
128             rk_aiq_uapi_adebayer_GetAttrib(mAlgoCtx, att);
129             att->sync.sync_mode = mNewAtt.sync.sync_mode;
130             att->sync.done      = true;
131         }
132     }
133 #endif
134     EXIT_ANALYZER_FUNCTION();
135     return ret;
136 }
137 #endif
138 
139 #if RKAIQ_HAVE_DEBAYER_V2
setAttribV2(adebayer_v2_attrib_t att)140 XCamReturn RkAiqAdebayerHandleInt::setAttribV2(adebayer_v2_attrib_t att) {
141     ENTER_ANALYZER_FUNCTION();
142 
143     XCamReturn ret = XCAM_RETURN_NO_ERROR;
144     mCfgMutex.lock();
145 
146 #ifdef DISABLE_HANDLE_ATTRIB
147     ret = rk_aiq_uapi_adebayer_v2_SetAttrib(mAlgoCtx, att, false);
148 #else
149     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
150     // if something changed, set att to mNewAtt, and
151     // the new params will be effective later when updateConfig
152     // called by RkAiqCore
153     bool isChanged = false;
154     if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
155             memcmp(&mNewAttV2, &att, sizeof(att)))
156         isChanged = true;
157     else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
158              memcmp(&mCurAttV2, &att, sizeof(att)))
159         isChanged = true;
160 
161     // if something changed
162     if (isChanged) {
163         mNewAttV2   = att;
164         updateAtt = true;
165         waitSignal(att.sync.sync_mode);
166     }
167 #endif
168     mCfgMutex.unlock();
169 
170     EXIT_ANALYZER_FUNCTION();
171     return ret;
172 }
173 
getAttribV2(adebayer_v2_attrib_t * att)174 XCamReturn RkAiqAdebayerHandleInt::getAttribV2(adebayer_v2_attrib_t* att) {
175     ENTER_ANALYZER_FUNCTION();
176 
177     XCamReturn ret = XCAM_RETURN_NO_ERROR;
178 
179 #ifdef DISABLE_HANDLE_ATTRIB
180     mCfgMutex.lock();
181     rk_aiq_uapi_adebayer_v2_GetAttrib(mAlgoCtx, att);
182     att->sync.done = true;
183     mCfgMutex.unlock();
184 #else
185     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
186         mCfgMutex.lock();
187         rk_aiq_uapi_adebayer_v2_GetAttrib(mAlgoCtx, att);
188         att->sync.done = true;
189         mCfgMutex.unlock();
190     } else {
191         if (updateAtt) {
192             memcpy(att, &mNewAttV2, sizeof(mNewAttV2));
193             att->sync.done = false;
194         } else {
195             rk_aiq_uapi_adebayer_v2_GetAttrib(mAlgoCtx, att);
196             att->sync.sync_mode = mNewAttV2.sync.sync_mode;
197             att->sync.done      = true;
198         }
199     }
200 #endif
201     EXIT_ANALYZER_FUNCTION();
202     return ret;
203 }
204 #endif
205 
206 #if RKAIQ_HAVE_DEBAYER_V2_LITE
setAttribV2(adebayer_v2lite_attrib_t att)207 XCamReturn RkAiqAdebayerHandleInt::setAttribV2(adebayer_v2lite_attrib_t att) {
208     ENTER_ANALYZER_FUNCTION();
209 
210     XCamReturn ret = XCAM_RETURN_NO_ERROR;
211     mCfgMutex.lock();
212 
213 #ifdef DISABLE_HANDLE_ATTRIB
214     ret = rk_aiq_uapi_adebayer_v2lite_SetAttrib(mAlgoCtx, att, false);
215 #else
216     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
217     // if something changed, set att to mNewAtt, and
218     // the new params will be effective later when updateConfig
219     // called by RkAiqCore
220     bool isChanged = false;
221     if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
222             memcmp(&mNewAttV2Lite, &att, sizeof(att)))
223         isChanged = true;
224     else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
225              memcmp(&mCurAttV2Lite, &att, sizeof(att)))
226         isChanged = true;
227 
228     // if something changed
229     if (isChanged) {
230         mNewAttV2Lite = att;
231         updateAtt = true;
232         waitSignal(att.sync.sync_mode);
233     }
234 #endif
235     mCfgMutex.unlock();
236 
237     EXIT_ANALYZER_FUNCTION();
238     return ret;
239 }
240 
getAttribV2(adebayer_v2lite_attrib_t * att)241 XCamReturn RkAiqAdebayerHandleInt::getAttribV2(adebayer_v2lite_attrib_t* att) {
242     ENTER_ANALYZER_FUNCTION();
243 
244     XCamReturn ret = XCAM_RETURN_NO_ERROR;
245 
246 #ifdef DISABLE_HANDLE_ATTRIB
247     mCfgMutex.lock();
248     rk_aiq_uapi_adebayer_v2lite_GetAttrib(mAlgoCtx, att);
249     att->sync.done = true;
250     mCfgMutex.unlock();
251 #else
252     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
253         mCfgMutex.lock();
254         rk_aiq_uapi_adebayer_v2lite_GetAttrib(mAlgoCtx, att);
255         att->sync.done = true;
256         mCfgMutex.unlock();
257     } else {
258         if (updateAtt) {
259             memcpy(att, &mNewAttV2Lite, sizeof(mNewAttV2Lite));
260             att->sync.done = false;
261         } else {
262             rk_aiq_uapi_adebayer_v2lite_GetAttrib(mAlgoCtx, att);
263             att->sync.sync_mode = mNewAttV2Lite.sync.sync_mode;
264             att->sync.done      = true;
265         }
266     }
267 #endif
268     EXIT_ANALYZER_FUNCTION();
269     return ret;
270 }
271 #endif
272 
prepare()273 XCamReturn RkAiqAdebayerHandleInt::prepare() {
274     ENTER_ANALYZER_FUNCTION();
275 
276     XCamReturn ret = XCAM_RETURN_NO_ERROR;
277 
278     ret = RkAiqHandle::prepare();
279     RKAIQCORE_CHECK_RET(ret, "adebayer handle prepare failed");
280 
281     RkAiqAlgoConfigAdebayer* adebayer_config_int = (RkAiqAlgoConfigAdebayer*)mConfig;
282     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
283         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
284 
285     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
286     ret                       = des->prepare(mConfig);
287     RKAIQCORE_CHECK_RET(ret, "adebayer algo prepare failed");
288 
289     EXIT_ANALYZER_FUNCTION();
290     return XCAM_RETURN_NO_ERROR;
291 }
292 
preProcess()293 XCamReturn RkAiqAdebayerHandleInt::preProcess() {
294     ENTER_ANALYZER_FUNCTION();
295 
296     XCamReturn ret = XCAM_RETURN_NO_ERROR;
297 #if 0
298     RkAiqAlgoPreAdebayer* adebayer_pre_int        = (RkAiqAlgoPreAdebayer*)mPreInParam;
299     RkAiqAlgoPreResAdebayer* adebayer_pre_res_int = (RkAiqAlgoPreResAdebayer*)mPreOutParam;
300     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
301         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
302     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
303 
304     ret = RkAiqHandle::preProcess();
305     if (ret) {
306         RKAIQCORE_CHECK_RET(ret, "adebayer handle preProcess failed");
307     }
308 
309     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
310     ret                       = des->pre_process(mPreInParam, mPreOutParam);
311     RKAIQCORE_CHECK_RET(ret, "adebayer algo pre_process failed");
312 
313     EXIT_ANALYZER_FUNCTION();
314 #endif
315     return XCAM_RETURN_NO_ERROR;
316 }
317 
processing()318 XCamReturn RkAiqAdebayerHandleInt::processing() {
319     ENTER_ANALYZER_FUNCTION();
320 
321     XCamReturn ret = XCAM_RETURN_NO_ERROR;
322 
323     RkAiqAlgoProcAdebayer* adebayer_proc_int = (RkAiqAlgoProcAdebayer*)mProcInParam;
324     RkAiqAlgoProcResAdebayer* adebayer_proc_res_int =
325         (RkAiqAlgoProcResAdebayer*)mProcOutParam;
326     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
327         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
328     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
329 
330 #if RKAIQ_HAVE_DEBAYER_V1
331     adebayer_proc_res_int->debayerResV1.config = &shared->fullParams->mDebayerParams->data()->result;
332 #endif
333 #if RKAIQ_HAVE_DEBAYER_V2 || RKAIQ_HAVE_DEBAYER_V2_LITE
334     adebayer_proc_res_int->debayerResV2.config = &shared->fullParams->mDebayerV32Params->data()->result;
335 #endif
336 
337     ret = RkAiqHandle::processing();
338     if (ret) {
339         RKAIQCORE_CHECK_RET(ret, "adebayer handle processing failed");
340     }
341 
342     // TODO: fill procParam
343     adebayer_proc_int->hdr_mode = sharedCom->working_mode;
344 
345 #ifdef DISABLE_HANDLE_ATTRIB
346     mCfgMutex.lock();
347 #endif
348     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
349     ret                       = des->processing(mProcInParam, mProcOutParam);
350 #ifdef DISABLE_HANDLE_ATTRIB
351     mCfgMutex.unlock();
352 #endif
353     RKAIQCORE_CHECK_RET(ret, "adebayer algo processing failed");
354 
355     EXIT_ANALYZER_FUNCTION();
356     return ret;
357 }
358 
postProcess()359 XCamReturn RkAiqAdebayerHandleInt::postProcess() {
360     ENTER_ANALYZER_FUNCTION();
361 
362     XCamReturn ret = XCAM_RETURN_NO_ERROR;
363 #if 0
364     RkAiqAlgoPostAdebayer* adebayer_post_int = (RkAiqAlgoPostAdebayer*)mPostInParam;
365     RkAiqAlgoPostResAdebayer* adebayer_post_res_int =
366         (RkAiqAlgoPostResAdebayer*)mPostOutParam;
367     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
368         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
369     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
370 
371     ret = RkAiqHandle::postProcess();
372     if (ret) {
373         RKAIQCORE_CHECK_RET(ret, "adebayer handle postProcess failed");
374         return ret;
375     }
376 
377     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
378     ret                       = des->post_process(mPostInParam, mPostOutParam);
379     RKAIQCORE_CHECK_RET(ret, "adebayer algo post_process failed");
380 
381     EXIT_ANALYZER_FUNCTION();
382 #endif
383     return ret;
384 }
385 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)386 XCamReturn RkAiqAdebayerHandleInt::genIspResult(RkAiqFullParams* params,
387         RkAiqFullParams* cur_params) {
388     ENTER_ANALYZER_FUNCTION();
389     XCamReturn ret                = XCAM_RETURN_NO_ERROR;
390     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
391         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
392     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
393     RkAiqAlgoProcResAdebayer* adebayer_com = (RkAiqAlgoProcResAdebayer*)mProcOutParam;
394 
395 #if RKAIQ_HAVE_DEBAYER_V1
396     rk_aiq_isp_debayer_params_v20_t* debayer_param = params->mDebayerParams->data().ptr();
397 #endif
398 #if RKAIQ_HAVE_DEBAYER_V2 || RKAIQ_HAVE_DEBAYER_V2_LITE
399     rk_aiq_isp_debayer_params_v32_t* debayer_param = params->mDebayerV32Params->data().ptr();
400 #endif
401     if (!adebayer_com) {
402         LOGD_ANALYZER("no adebayer result");
403         return XCAM_RETURN_NO_ERROR;
404     }
405 
406     if (!this->getAlgoId()) {
407         RkAiqAlgoProcResAdebayer* adebayer_rk = (RkAiqAlgoProcResAdebayer*)adebayer_com;
408         if (sharedCom->init) {
409             debayer_param->frame_id = 0;
410         } else {
411             debayer_param->frame_id = shared->frameId;
412         }
413 
414         if (adebayer_com->res_com.cfg_update) {
415             mSyncFlag = shared->frameId;
416             debayer_param->sync_flag = mSyncFlag;
417             // copy from algo result
418             // set as the latest result
419 #if RKAIQ_HAVE_DEBAYER_V1
420             cur_params->mDebayerParams = params->mDebayerParams;
421 #endif
422 #if RKAIQ_HAVE_DEBAYER_V2 || RKAIQ_HAVE_DEBAYER_V2_LITE
423             cur_params->mDebayerV32Params = params->mDebayerV32Params;
424 #endif
425             debayer_param->is_update = true;
426             LOGD_ADEBAYER("[%d] params from algo", mSyncFlag);
427         } else if (mSyncFlag != debayer_param->sync_flag) {
428             debayer_param->sync_flag = mSyncFlag;
429             // copy from latest result
430 #if RKAIQ_HAVE_DEBAYER_V1
431             if (cur_params->mDebayerParams.ptr()) {
432                 debayer_param->result = cur_params->mDebayerParams->data()->result;
433                 debayer_param->is_update = true;
434             } else {
435                 LOGE_ADEBAYER("no latest params !");
436                 debayer_param->is_update = false;
437             }
438 #endif
439 #if RKAIQ_HAVE_DEBAYER_V2 || RKAIQ_HAVE_DEBAYER_V2_LITE
440             if (cur_params->mDebayerV32Params.ptr()) {
441                 debayer_param->result = cur_params->mDebayerV32Params->data()->result;
442                 debayer_param->is_update = true;
443             } else {
444                 LOGE_ADEBAYER("no latest params !");
445                 debayer_param->is_update = false;
446             }
447 #endif
448             LOGD_ADEBAYER("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
449         } else {
450             // do nothing, result in buf needn't update
451             debayer_param->is_update = false;
452             LOGD_ADEBAYER("[%d] params needn't update", shared->frameId);
453         }
454     }
455 
456     EXIT_ANALYZER_FUNCTION();
457 
458     return ret;
459 }
460 
461 }  // namespace RkCam
462