xref: /OK3568_Linux_fs/external/camera_engine_rkaiq/rkaiq/aiq_core/algo_handlers/RkAiqAynrV3Handle.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 "RkAiqAynrV3Handle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAynrV3HandleInt);
23 
init()24 void RkAiqAynrV3HandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAynrV3());
29     mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAynrV3());
30     mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAynrV3());
31     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAynrV3());
32     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAynrV3());
33     mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAynrV3());
34     mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAynrV3());
35 
36     EXIT_ANALYZER_FUNCTION();
37 }
38 
updateConfig(bool needSync)39 XCamReturn RkAiqAynrV3HandleInt::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_aynrV3_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_aynrV3_SetLumaSFStrength(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_ynr_attrib_v3_t * att)67 XCamReturn RkAiqAynrV3HandleInt::setAttrib(rk_aiq_ynr_attrib_v3_t* att) {
68     ENTER_ANALYZER_FUNCTION();
69 
70     XCamReturn ret = XCAM_RETURN_NO_ERROR;
71     mCfgMutex.lock();
72 #ifdef DISABLE_HANDLE_ATTRIB
73     ret = rk_aiq_uapi_aynrV3_SetAttrib(mAlgoCtx, att, false);
74 #else
75 
76     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
77     // if something changed, set att to mNewAtt, and
78     // the new params will be effective later when updateConfig
79     // called by RkAiqCore
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_ynr_attrib_v3_t * att)102 XCamReturn RkAiqAynrV3HandleInt::getAttrib(rk_aiq_ynr_attrib_v3_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_aynrV3_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_aynrV3_GetAttrib(mAlgoCtx, att);
115         att->sync.done = true;
116         mCfgMutex.unlock();
117     } else {
118         if(updateAtt) {
119             memcpy(att, &mNewAtt, sizeof(mNewAtt));
120             att->sync.done = false;
121         } else {
122             rk_aiq_uapi_aynrV3_GetAttrib(mAlgoCtx, att);
123             att->sync.done = true;
124         }
125     }
126 #endif
127 
128     EXIT_ANALYZER_FUNCTION();
129     return ret;
130 }
131 
132 
setStrength(rk_aiq_ynr_strength_v3_t * pStrength)133 XCamReturn RkAiqAynrV3HandleInt::setStrength(rk_aiq_ynr_strength_v3_t *pStrength) {
134     ENTER_ANALYZER_FUNCTION();
135 
136     XCamReturn ret = XCAM_RETURN_NO_ERROR;
137 
138     mCfgMutex.lock();
139 #ifdef DISABLE_HANDLE_ATTRIB
140     ret = rk_aiq_uapi_aynrV3_SetLumaSFStrength(mAlgoCtx, pStrength);
141 #else
142 
143     bool isChanged = false;
144     if (pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
145         memcmp(&mNewStrength, pStrength, sizeof(*pStrength)))
146         isChanged = true;
147     else if (pStrength->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
148              memcmp(&mCurStrength, pStrength, sizeof(*pStrength)))
149         isChanged = true;
150 
151     if (isChanged) {
152         mNewStrength   = *pStrength;
153         updateStrength = true;
154         waitSignal(pStrength->sync.sync_mode);
155     }
156 #endif
157 
158     mCfgMutex.unlock();
159     EXIT_ANALYZER_FUNCTION();
160     return ret;
161 }
162 
getStrength(rk_aiq_ynr_strength_v3_t * pStrength)163 XCamReturn RkAiqAynrV3HandleInt::getStrength(rk_aiq_ynr_strength_v3_t *pStrength) {
164     ENTER_ANALYZER_FUNCTION();
165 
166     XCamReturn ret = XCAM_RETURN_NO_ERROR;
167 
168 #ifdef DISABLE_HANDLE_ATTRIB
169     mCfgMutex.unlock();
170     rk_aiq_uapi_aynrV3_GetLumaSFStrength(mAlgoCtx, pStrength);
171     mCfgMutex.unlock();
172 #else
173     if(pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
174         mCfgMutex.unlock();
175         rk_aiq_uapi_aynrV3_GetLumaSFStrength(mAlgoCtx, pStrength);
176         pStrength->sync.done = true;
177         mCfgMutex.unlock();
178     } else {
179         if(updateStrength) {
180             *pStrength = mNewStrength;
181             pStrength->sync.done = false;
182         } else {
183             rk_aiq_uapi_aynrV3_GetLumaSFStrength(mAlgoCtx, pStrength);
184             pStrength->sync.done = true;
185         }
186     }
187 #endif
188 
189     EXIT_ANALYZER_FUNCTION();
190     return ret;
191 }
192 
getInfo(rk_aiq_ynr_info_v3_t * pInfo)193 XCamReturn RkAiqAynrV3HandleInt::getInfo(rk_aiq_ynr_info_v3_t *pInfo) {
194     ENTER_ANALYZER_FUNCTION();
195 
196     XCamReturn ret = XCAM_RETURN_NO_ERROR;
197 
198     if(pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
199         mCfgMutex.unlock();
200         rk_aiq_uapi_aynrV3_GetInfo(mAlgoCtx, pInfo);
201         pInfo->sync.done = true;
202         mCfgMutex.unlock();
203     } else {
204         rk_aiq_uapi_aynrV3_GetInfo(mAlgoCtx, pInfo);
205         pInfo->sync.done = true;
206     }
207 
208     EXIT_ANALYZER_FUNCTION();
209     return ret;
210 }
211 
prepare()212 XCamReturn RkAiqAynrV3HandleInt::prepare() {
213     ENTER_ANALYZER_FUNCTION();
214 
215     XCamReturn ret = XCAM_RETURN_NO_ERROR;
216 
217     ret = RkAiqHandle::prepare();
218     RKAIQCORE_CHECK_RET(ret, "aynr handle prepare failed");
219 
220     RkAiqAlgoConfigAynrV3* aynr_config_int   = (RkAiqAlgoConfigAynrV3*)mConfig;
221     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
222 
223     aynr_config_int->stAynrConfig.rawWidth  = sharedCom->snsDes.isp_acq_width;
224     aynr_config_int->stAynrConfig.rawHeight = sharedCom->snsDes.isp_acq_height;
225 
226     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
227     ret                       = des->prepare(mConfig);
228     RKAIQCORE_CHECK_RET(ret, "aynr algo prepare failed");
229 
230     EXIT_ANALYZER_FUNCTION();
231     return XCAM_RETURN_NO_ERROR;
232 }
233 
preProcess()234 XCamReturn RkAiqAynrV3HandleInt::preProcess() {
235     ENTER_ANALYZER_FUNCTION();
236 
237     XCamReturn ret = XCAM_RETURN_NO_ERROR;
238 
239     RkAiqAlgoPreAynrV3* aynr_pre_int        = (RkAiqAlgoPreAynrV3*)mPreInParam;
240     RkAiqAlgoPreResAynrV3* aynr_pre_res_int = (RkAiqAlgoPreResAynrV3*)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, "aynr handle preProcess failed");
248     }
249 
250     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
251     ret                       = des->pre_process(mPreInParam, mPreOutParam);
252     RKAIQCORE_CHECK_RET(ret, "aynr algo pre_process failed");
253 
254     EXIT_ANALYZER_FUNCTION();
255     return XCAM_RETURN_NO_ERROR;
256 }
257 
processing()258 XCamReturn RkAiqAynrV3HandleInt::processing() {
259     ENTER_ANALYZER_FUNCTION();
260 
261     XCamReturn ret = XCAM_RETURN_NO_ERROR;
262 
263     RkAiqAlgoProcAynrV3* aynr_proc_int        = (RkAiqAlgoProcAynrV3*)mProcInParam;
264     if (mDes->id == 0) {
265         mProcResShared = new RkAiqAlgoProcResAynrV3IntShared();
266         if (!mProcResShared.ptr()) {
267             LOGE("new YNR(v3) mProcResShared failed, bypass!");
268             return XCAM_RETURN_BYPASS;
269         }
270     }
271     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
272         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
273     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
274 
275     ret = RkAiqHandle::processing();
276     if (ret) {
277         mProcResShared = NULL;
278         RKAIQCORE_CHECK_RET(ret, "aynr handle processing failed");
279     }
280 
281     // TODO: fill procParam
282     aynr_proc_int->iso      = sharedCom->iso;
283     aynr_proc_int->hdr_mode = sharedCom->working_mode;
284 
285     mProcResShared->result.stAynrProcResult.stFix = &shared->fullParams->mYnrV3xParams->data()->result;
286 #ifdef DISABLE_HANDLE_ATTRIB
287     mCfgMutex.lock();
288 #endif
289     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
290     ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)(&mProcResShared->result));
291 #ifdef DISABLE_HANDLE_ATTRIB
292     mCfgMutex.unlock();
293 #endif
294     RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
295 
296     if (!mProcResShared->result.res_com.cfg_update) {
297         mProcResShared->result.stAynrProcResult = mLatestparam;
298         LOGD_ANR("[%d] copy results from latest !", shared->frameId);
299     }
300 
301     if (!mAiqCore->mAlogsComSharedParams.init && mPostShared) {
302         mProcResShared->set_sequence(shared->frameId);
303         RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_YNR_V3_PROC_RES_OK, shared->frameId, mProcResShared);
304         mAiqCore->post_message(msg);
305     }
306 
307     EXIT_ANALYZER_FUNCTION();
308     return ret;
309 }
310 
postProcess()311 XCamReturn RkAiqAynrV3HandleInt::postProcess() {
312     ENTER_ANALYZER_FUNCTION();
313 
314     XCamReturn ret = XCAM_RETURN_NO_ERROR;
315 
316     RkAiqAlgoPostAynrV3* aynr_post_int        = (RkAiqAlgoPostAynrV3*)mPostInParam;
317     RkAiqAlgoPostResAynrV3* aynr_post_res_int = (RkAiqAlgoPostResAynrV3*)mPostOutParam;
318     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
319         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
320     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
321 
322     ret = RkAiqHandle::postProcess();
323     if (ret) {
324         RKAIQCORE_CHECK_RET(ret, "aynr handle postProcess failed");
325         return ret;
326     }
327 
328     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
329     ret                       = des->post_process(mPostInParam, mPostOutParam);
330     RKAIQCORE_CHECK_RET(ret, "aynr algo post_process failed");
331 
332     EXIT_ANALYZER_FUNCTION();
333     return ret;
334 }
335 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)336 XCamReturn RkAiqAynrV3HandleInt::genIspResult(RkAiqFullParams* params,
337         RkAiqFullParams* cur_params) {
338     ENTER_ANALYZER_FUNCTION();
339 
340     XCamReturn ret = XCAM_RETURN_NO_ERROR;
341     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
342         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
343     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
344     if (!mProcResShared.ptr()) {
345         params->mYnrV3xParams = cur_params->mYnrV3xParams;
346         return ret;
347     }
348     RkAiqAlgoProcResAynrV3* aynr_rk = (RkAiqAlgoProcResAynrV3*)&mProcResShared->result;
349 
350     if (!aynr_rk) {
351         LOGD_ANALYZER("no aynr result");
352         return XCAM_RETURN_NO_ERROR;
353     }
354 
355     if (!this->getAlgoId()) {
356         LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
357         rk_aiq_isp_ynr_params_v3x_t* ynr_param = params->mYnrV3xParams->data().ptr();
358         if (sharedCom->init) {
359             ynr_param->frame_id = 0;
360         } else {
361             ynr_param->frame_id = shared->frameId;
362         }
363 
364         if (aynr_rk->res_com.cfg_update) {
365             mSyncFlag = shared->frameId;
366             ynr_param->sync_flag = mSyncFlag;
367             // copy from algo result
368             cur_params->mYnrV3xParams = params->mYnrV3xParams;
369             mLatestparam = aynr_rk->stAynrProcResult;
370             ynr_param->is_update = true;
371             LOGD_ANR("[%d] params from algo", mSyncFlag);
372         } else if (mSyncFlag != ynr_param->sync_flag) {
373             ynr_param->sync_flag = mSyncFlag;
374             // copy from latest result
375             if (cur_params->mYnrV3xParams.ptr()) {
376                 ynr_param->result = cur_params->mYnrV3xParams->data()->result;
377                 ynr_param->is_update = true;
378             } else {
379                 LOGE_ANR("no latest params !");
380                 ynr_param->is_update = false;
381             }
382             LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
383         } else {
384             // do nothing, result in buf needn't update
385             ynr_param->is_update = false;
386             LOGD_ANR("[%d] params needn't update", shared->frameId);
387         }
388         LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
389     }
390 
391     EXIT_ANALYZER_FUNCTION();
392 
393     return ret;
394 }
395 
396 }  // namespace RkCam
397