xref: /OK3568_Linux_fs/external/camera_engine_rkaiq/rkaiq/aiq_core/algo_handlers/RkAiqAmergeHandle.cpp (revision 4882a59341e53eb6f0b4789bf948001014eff981) 
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 "RkAiqAmergeHandle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAmergeHandleInt);
23 
init()24 void RkAiqAmergeHandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAmerge());
29     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAmerge());
30     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAmerge());
31 
32     EXIT_ANALYZER_FUNCTION();
33 }
updateConfig(bool needSync)34 XCamReturn RkAiqAmergeHandleInt::updateConfig(bool needSync) {
35     ENTER_ANALYZER_FUNCTION();
36 
37     XCamReturn ret = XCAM_RETURN_NO_ERROR;
38 #ifndef DISABLE_HANDLE_ATTRIB
39     if (needSync) mCfgMutex.lock();
40     // if something changed
41     if (updateAtt) {
42 #if RKAIQ_HAVE_MERGE_V10
43         mCurAttV10 = mNewAttV10;
44         rk_aiq_uapi_amerge_v10_SetAttrib(mAlgoCtx, &mCurAttV10, true);
45         updateAtt = false;
46         sendSignal(mCurAttV10.sync.sync_mode);
47 #endif
48 #if RKAIQ_HAVE_MERGE_V11
49         mCurAttV11 = mNewAttV11;
50         rk_aiq_uapi_amerge_v11_SetAttrib(mAlgoCtx, &mCurAttV11, true);
51         updateAtt = false;
52         sendSignal(mCurAttV11.sync.sync_mode);
53 #endif
54 #if RKAIQ_HAVE_MERGE_V12
55         mCurAttV12 = mNewAttV12;
56         rk_aiq_uapi_amerge_v12_SetAttrib(mAlgoCtx, &mCurAttV12, true);
57         updateAtt = false;
58         sendSignal(mCurAttV12.sync.sync_mode);
59 #endif
60     }
61     if (needSync) mCfgMutex.unlock();
62 #endif
63 
64     EXIT_ANALYZER_FUNCTION();
65     return ret;
66 }
67 
68 #if RKAIQ_HAVE_MERGE_V10
setAttribV10(const mergeAttrV10_t * att)69 XCamReturn RkAiqAmergeHandleInt::setAttribV10(const mergeAttrV10_t* att) {
70     ENTER_ANALYZER_FUNCTION();
71 
72     XCamReturn ret = XCAM_RETURN_NO_ERROR;
73     mCfgMutex.lock();
74 #ifdef DISABLE_HANDLE_ATTRIB
75     ret = rk_aiq_uapi_amerge_v10_SetAttrib(mAlgoCtx, att, false);
76 #else
77 
78     // check if there is different between att & mCurAttV10(sync)/mNewAttV10(async)
79     // if something changed, set att to mNewAttV10, and
80     // the new params will be effective later when updateConfig
81     // called by RkAiqCore
82     bool isChanged = false;
83     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
84         memcmp(&mNewAttV10, att, sizeof(mergeAttrV10_t)))
85         isChanged = true;
86     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
87              memcmp(&mCurAttV10, att, sizeof(mergeAttrV10_t)))
88         isChanged = true;
89 
90     // if something changed
91     if (isChanged) {
92         mNewAttV10 = *att;
93         updateAtt  = true;
94         waitSignal(att->sync.sync_mode);
95     }
96 #endif
97     mCfgMutex.unlock();
98 
99     EXIT_ANALYZER_FUNCTION();
100     return ret;
101 }
getAttribV10(mergeAttrV10_t * att)102 XCamReturn RkAiqAmergeHandleInt::getAttribV10(mergeAttrV10_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_amerge_v10_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_amerge_v10_GetAttrib(mAlgoCtx, att);
115         att->sync.done = true;
116         mCfgMutex.unlock();
117     } else {
118         if (updateAtt) {
119             memcpy(att, &mNewAttV10, sizeof(mergeAttrV10_t));
120             att->sync.done = false;
121         } else {
122             rk_aiq_uapi_amerge_v10_GetAttrib(mAlgoCtx, att);
123             att->sync.sync_mode = mNewAttV10.sync.sync_mode;
124             att->sync.done      = true;
125         }
126     }
127 #endif
128     EXIT_ANALYZER_FUNCTION();
129     return ret;
130 }
131 #endif
132 
133 #if RKAIQ_HAVE_MERGE_V11
setAttribV11(const mergeAttrV11_t * att)134 XCamReturn RkAiqAmergeHandleInt::setAttribV11(const mergeAttrV11_t* att) {
135     ENTER_ANALYZER_FUNCTION();
136 
137     XCamReturn ret = XCAM_RETURN_NO_ERROR;
138     mCfgMutex.lock();
139 
140 #ifdef DISABLE_HANDLE_ATTRIB
141     ret = rk_aiq_uapi_amerge_v11_SetAttrib(mAlgoCtx, att, false);
142 #else
143     // check if there is different between att & mCurAttV11(sync)/mNewAttV11(async)
144     // if something changed, set att to mNewAttV11, and
145     // the new params will be effective later when updateConfig
146     // called by RkAiqCore
147     bool isChanged = false;
148     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
149         memcmp(&mNewAttV11, att, sizeof(mergeAttrV11_t)))
150         isChanged = true;
151     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
152              memcmp(&mCurAttV11, att, sizeof(mergeAttrV11_t)))
153         isChanged = true;
154 
155     // if something changed
156     if (isChanged) {
157         mNewAttV11 = *att;
158         updateAtt  = true;
159         waitSignal(att->sync.sync_mode);
160     }
161 #endif
162     mCfgMutex.unlock();
163 
164     EXIT_ANALYZER_FUNCTION();
165     return ret;
166 }
getAttribV11(mergeAttrV11_t * att)167 XCamReturn RkAiqAmergeHandleInt::getAttribV11(mergeAttrV11_t* att) {
168     ENTER_ANALYZER_FUNCTION();
169 
170     XCamReturn ret = XCAM_RETURN_NO_ERROR;
171 
172 #ifdef DISABLE_HANDLE_ATTRIB
173     mCfgMutex.lock();
174     rk_aiq_uapi_amerge_v11_GetAttrib(mAlgoCtx, att);
175     mCfgMutex.unlock();
176 #else
177     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
178         mCfgMutex.lock();
179         rk_aiq_uapi_amerge_v11_GetAttrib(mAlgoCtx, att);
180         att->sync.done = true;
181         mCfgMutex.unlock();
182     } else {
183         if (updateAtt) {
184             memcpy(att, &mNewAttV11, sizeof(mergeAttrV11_t));
185             att->sync.done = false;
186         } else {
187             rk_aiq_uapi_amerge_v11_GetAttrib(mAlgoCtx, att);
188             att->sync.sync_mode = mNewAttV11.sync.sync_mode;
189             att->sync.done      = true;
190         }
191     }
192 #endif
193     EXIT_ANALYZER_FUNCTION();
194     return ret;
195 }
196 #endif
197 
198 #if RKAIQ_HAVE_MERGE_V12
setAttribV12(const mergeAttrV12_t * att)199 XCamReturn RkAiqAmergeHandleInt::setAttribV12(const mergeAttrV12_t* att) {
200     ENTER_ANALYZER_FUNCTION();
201 
202     XCamReturn ret = XCAM_RETURN_NO_ERROR;
203     mCfgMutex.lock();
204 
205 #ifdef DISABLE_HANDLE_ATTRIB
206     ret = rk_aiq_uapi_amerge_v12_SetAttrib(mAlgoCtx, att, false);
207 #else
208     // check if there is different between att & mCurAttV12(sync)/mNewAttV12(async)
209     // if something changed, set att to mNewAttV12, and
210     // the new params will be effective later when updateConfig
211     // called by RkAiqCore
212     bool isChanged = false;
213     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
214         memcmp(&mNewAttV12, att, sizeof(mergeAttrV12_t)))
215         isChanged = true;
216     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
217              memcmp(&mCurAttV12, att, sizeof(mergeAttrV12_t)))
218         isChanged = true;
219 
220     // if something changed
221     if (isChanged) {
222         mNewAttV12 = *att;
223         updateAtt = true;
224         waitSignal(att->sync.sync_mode);
225     }
226 #endif
227     mCfgMutex.unlock();
228 
229     EXIT_ANALYZER_FUNCTION();
230     return ret;
231 }
getAttribV12(mergeAttrV12_t * att)232 XCamReturn RkAiqAmergeHandleInt::getAttribV12(mergeAttrV12_t* att) {
233     ENTER_ANALYZER_FUNCTION();
234 
235     XCamReturn ret = XCAM_RETURN_NO_ERROR;
236 #ifdef DISABLE_HANDLE_ATTRIB
237     mCfgMutex.lock();
238     rk_aiq_uapi_amerge_v12_GetAttrib(mAlgoCtx, att);
239     mCfgMutex.unlock();
240 #else
241 
242     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
243         mCfgMutex.lock();
244         rk_aiq_uapi_amerge_v12_GetAttrib(mAlgoCtx, att);
245         att->sync.done = true;
246         mCfgMutex.unlock();
247     } else {
248         if (updateAtt) {
249             memcpy(att, &mNewAttV12, sizeof(mergeAttrV12_t));
250             att->sync.done = false;
251         } else {
252             rk_aiq_uapi_amerge_v12_GetAttrib(mAlgoCtx, att);
253             att->sync.sync_mode = mNewAttV12.sync.sync_mode;
254             att->sync.done      = true;
255         }
256     }
257 #endif
258     EXIT_ANALYZER_FUNCTION();
259     return ret;
260 }
261 #endif
262 
prepare()263 XCamReturn RkAiqAmergeHandleInt::prepare() {
264     ENTER_ANALYZER_FUNCTION();
265 
266     XCamReturn ret = XCAM_RETURN_NO_ERROR;
267 
268     ret = RkAiqHandle::prepare();
269     RKAIQCORE_CHECK_RET(ret, "amerge handle prepare failed");
270 
271     RkAiqAlgoConfigAmerge* amerge_config_int = (RkAiqAlgoConfigAmerge*)mConfig;
272     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
273 
274     amerge_config_int->rawHeight    = sharedCom->snsDes.isp_acq_height;
275     amerge_config_int->rawWidth     = sharedCom->snsDes.isp_acq_width;
276     amerge_config_int->working_mode = sharedCom->working_mode;
277 
278     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
279     ret                       = des->prepare(mConfig);
280     RKAIQCORE_CHECK_RET(ret, "amerge algo prepare failed");
281 
282     EXIT_ANALYZER_FUNCTION();
283     return XCAM_RETURN_NO_ERROR;
284 }
285 
preProcess()286 XCamReturn RkAiqAmergeHandleInt::preProcess() {
287     ENTER_ANALYZER_FUNCTION();
288 
289     XCamReturn ret = XCAM_RETURN_NO_ERROR;
290 #if 0
291     RkAiqAlgoPreAmerge* amerge_pre_int        = (RkAiqAlgoPreAmerge*)mPreInParam;
292     RkAiqAlgoPreResAmerge* amerge_pre_res_int = (RkAiqAlgoPreResAmerge*)mPreOutParam;
293     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
294         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
295     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
296 
297     ret = RkAiqHandle::preProcess();
298     if (ret) {
299         RKAIQCORE_CHECK_RET(ret, "amerge handle preProcess failed");
300     }
301 
302     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
303     ret                       = des->pre_process(mPreInParam, mPreOutParam);
304     RKAIQCORE_CHECK_RET(ret, "amerge algo pre_process failed");
305 
306     EXIT_ANALYZER_FUNCTION();
307 #endif
308     return XCAM_RETURN_NO_ERROR;
309 }
310 
processing()311 XCamReturn RkAiqAmergeHandleInt::processing() {
312     ENTER_ANALYZER_FUNCTION();
313 
314     XCamReturn ret = XCAM_RETURN_NO_ERROR;
315 
316     RkAiqAlgoProcAmerge* amerge_proc_int        = (RkAiqAlgoProcAmerge*)mProcInParam;
317     RkAiqAlgoProcResAmerge* amerge_proc_res_int = (RkAiqAlgoProcResAmerge*)mProcOutParam;
318     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
319         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
320     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
321 
322     amerge_proc_res_int->AmergeProcRes = &shared->fullParams->mMergeParams->data()->result;
323     amerge_proc_int->LongFrmMode = mAeProcRes.LongFrmMode;
324 
325     ret = RkAiqHandle::processing();
326     if (ret) {
327         RKAIQCORE_CHECK_RET(ret, "amerge handle processing failed");
328     }
329 
330 #ifdef DISABLE_HANDLE_ATTRIB
331     mCfgMutex.lock();
332 #endif
333     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
334     ret                       = des->processing(mProcInParam, mProcOutParam);
335 #ifdef DISABLE_HANDLE_ATTRIB
336     mCfgMutex.unlock();
337 #endif
338     RKAIQCORE_CHECK_RET(ret, "amerge algo processing failed");
339 
340     EXIT_ANALYZER_FUNCTION();
341     return ret;
342 }
343 
postProcess()344 XCamReturn RkAiqAmergeHandleInt::postProcess() {
345     ENTER_ANALYZER_FUNCTION();
346 
347     XCamReturn ret = XCAM_RETURN_NO_ERROR;
348 #if 0
349     RkAiqAlgoPostAmerge* amerge_post_int        = (RkAiqAlgoPostAmerge*)mPostInParam;
350     RkAiqAlgoPostResAmerge* amerge_post_res_int = (RkAiqAlgoPostResAmerge*)mPostOutParam;
351     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
352         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
353     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
354 
355     ret = RkAiqHandle::postProcess();
356     if (ret) {
357         RKAIQCORE_CHECK_RET(ret, "amerge handle postProcess failed");
358         return ret;
359     }
360 
361     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
362     ret                       = des->post_process(mPostInParam, mPostOutParam);
363     RKAIQCORE_CHECK_RET(ret, "amerge algo post_process failed");
364 
365     EXIT_ANALYZER_FUNCTION();
366 #endif
367     return ret;
368 }
369 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)370 XCamReturn RkAiqAmergeHandleInt::genIspResult(RkAiqFullParams* params,
371         RkAiqFullParams* cur_params) {
372     ENTER_ANALYZER_FUNCTION();
373 
374     XCamReturn ret = XCAM_RETURN_NO_ERROR;
375     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
376         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
377     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
378     RkAiqAlgoProcResAmerge* amerge_com          = (RkAiqAlgoProcResAmerge*)mProcOutParam;
379 
380     rk_aiq_isp_merge_params_v20_t* merge_param = params->mMergeParams->data().ptr();
381 
382     if (!amerge_com) {
383         LOGD_ANALYZER("no amerge result");
384         return XCAM_RETURN_NO_ERROR;
385     }
386 
387     if (!this->getAlgoId()) {
388         RkAiqAlgoProcResAmerge* amerge_rk = (RkAiqAlgoProcResAmerge*)amerge_com;
389 
390         if (sharedCom->init) {
391             merge_param->frame_id = 0;
392         } else {
393             merge_param->frame_id = shared->frameId;
394         }
395 
396         if (amerge_com->res_com.cfg_update) {
397             mSyncFlag = shared->frameId;
398             merge_param->sync_flag = mSyncFlag;
399             // copy from algo result
400             // set as the latest result
401             cur_params->mMergeParams = params->mMergeParams;
402             merge_param->is_update = true;
403             LOGD_AMERGE("[%d] params from algo", mSyncFlag);
404         } else if (mSyncFlag != merge_param->sync_flag) {
405             merge_param->sync_flag = mSyncFlag;
406             // copy from latest result
407             if (cur_params->mMergeParams.ptr()) {
408                 merge_param->result = cur_params->mMergeParams->data()->result;
409                 merge_param->is_update = true;
410             } else {
411                 LOGE_AMERGE("no latest params !");
412                 merge_param->is_update = false;
413             }
414             LOGD_AMERGE("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
415         } else {
416             // do nothing, result in buf needn't update
417             merge_param->is_update = false;
418             LOGD_AMERGE("[%d] params needn't update", shared->frameId);
419         }
420     }
421 
422     EXIT_ANALYZER_FUNCTION();
423 
424     return ret;
425 }
426 
427 }  // namespace RkCam
428