xref: /OK3568_Linux_fs/external/camera_engine_rkaiq/rkaiq/aiq_core/algo_handlers/RkAiqAynrV22Handle.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 "RkAiqAynrV22Handle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAynrV22HandleInt);
23 
init()24 void RkAiqAynrV22HandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAynrV22());
29     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAynrV22());
30     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAynrV22());
31 
32     EXIT_ANALYZER_FUNCTION();
33 }
34 
updateConfig(bool needSync)35 XCamReturn RkAiqAynrV22HandleInt::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_aynrV22_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_aynrV22_SetLumaSFStrength(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_ynr_attrib_v22_t * att)63 XCamReturn RkAiqAynrV22HandleInt::setAttrib(const rk_aiq_ynr_attrib_v22_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_aynrV22_SetAttrib(mAlgoCtx, att, false);
76 #else
77     // if something changed
78     if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_ynr_attrib_v22_t))) {
79         mNewAtt   = *att;
80         updateAtt = true;
81         waitSignal(att->sync.sync_mode);
82 
83     }
84 #endif
85 
86     mCfgMutex.unlock();
87 
88     EXIT_ANALYZER_FUNCTION();
89     return ret;
90 }
91 
getAttrib(rk_aiq_ynr_attrib_v22_t * att)92 XCamReturn RkAiqAynrV22HandleInt::getAttrib(rk_aiq_ynr_attrib_v22_t* att) {
93     ENTER_ANALYZER_FUNCTION();
94 
95     XCamReturn ret = XCAM_RETURN_NO_ERROR;
96 
97 #ifdef DISABLE_HANDLE_ATTRIB
98       mCfgMutex.lock();
99       ret = rk_aiq_uapi_aynrV22_GetAttrib(mAlgoCtx, att);
100       mCfgMutex.unlock();
101 #else
102     if(att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
103         mCfgMutex.lock();
104         rk_aiq_uapi_aynrV22_GetAttrib(mAlgoCtx, att);
105         att->sync.done = true;
106         mCfgMutex.unlock();
107     } else {
108         if(updateAtt) {
109             memcpy(att, &mNewAtt, sizeof(mNewAtt));
110             att->sync.done = false;
111         } else {
112             rk_aiq_uapi_aynrV22_GetAttrib(mAlgoCtx, att);
113             att->sync.done = true;
114         }
115     }
116 #endif
117 
118     EXIT_ANALYZER_FUNCTION();
119     return ret;
120 }
121 
122 
setStrength(const rk_aiq_ynr_strength_v22_t * pStrength)123 XCamReturn RkAiqAynrV22HandleInt::setStrength(const rk_aiq_ynr_strength_v22_t *pStrength) {
124     ENTER_ANALYZER_FUNCTION();
125 
126     XCamReturn ret = XCAM_RETURN_NO_ERROR;
127 
128     mCfgMutex.lock();
129 
130 #ifdef DISABLE_HANDLE_ATTRIB
131     ret = rk_aiq_uapi_aynrV22_SetLumaSFStrength(mAlgoCtx, pStrength);
132 #else
133     if (0 != memcmp(&mCurStrength, pStrength, sizeof(mCurStrength))) {
134         mNewStrength   = *pStrength;
135         updateStrength = true;
136         waitSignal(pStrength->sync.sync_mode);
137     }
138 #endif
139 
140     mCfgMutex.unlock();
141     EXIT_ANALYZER_FUNCTION();
142     return ret;
143 }
144 
getStrength(rk_aiq_ynr_strength_v22_t * pStrength)145 XCamReturn RkAiqAynrV22HandleInt::getStrength(rk_aiq_ynr_strength_v22_t *pStrength) {
146     ENTER_ANALYZER_FUNCTION();
147 
148     XCamReturn ret = XCAM_RETURN_NO_ERROR;
149 
150 #ifdef DISABLE_HANDLE_ATTRIB
151         mCfgMutex.lock();
152         ret = rk_aiq_uapi_aynrV22_GetLumaSFStrength(mAlgoCtx, pStrength);
153         mCfgMutex.unlock();
154 #else
155     if(pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
156         mCfgMutex.unlock();
157         rk_aiq_uapi_aynrV22_GetLumaSFStrength(mAlgoCtx, pStrength);
158         pStrength->sync.done = true;
159         mCfgMutex.unlock();
160     } else {
161         if(updateStrength) {
162             *pStrength = mNewStrength;
163             pStrength->sync.done = false;
164         } else {
165             rk_aiq_uapi_aynrV22_GetLumaSFStrength(mAlgoCtx, pStrength);
166             pStrength->sync.done = true;
167         }
168     }
169 #endif
170 
171     EXIT_ANALYZER_FUNCTION();
172     return ret;
173 }
174 
175 
getInfo(rk_aiq_ynr_info_v22_t * pInfo)176 XCamReturn RkAiqAynrV22HandleInt::getInfo(rk_aiq_ynr_info_v22_t *pInfo) {
177     ENTER_ANALYZER_FUNCTION();
178 
179     XCamReturn ret = XCAM_RETURN_NO_ERROR;
180 
181     if(pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
182         mCfgMutex.unlock();
183         rk_aiq_uapi_aynrV22_GetInfo(mAlgoCtx, pInfo);
184         pInfo->sync.done = true;
185         mCfgMutex.unlock();
186     } else {
187         rk_aiq_uapi_aynrV22_GetInfo(mAlgoCtx, pInfo);
188         pInfo->sync.done = true;
189     }
190 
191     EXIT_ANALYZER_FUNCTION();
192     return ret;
193 }
194 
prepare()195 XCamReturn RkAiqAynrV22HandleInt::prepare() {
196     ENTER_ANALYZER_FUNCTION();
197 
198     XCamReturn ret = XCAM_RETURN_NO_ERROR;
199 
200     ret = RkAiqHandle::prepare();
201     RKAIQCORE_CHECK_RET(ret, "aynr handle prepare failed");
202 
203     RkAiqAlgoConfigAynrV22* aynr_config_int   = (RkAiqAlgoConfigAynrV22*)mConfig;
204     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
205 
206     aynr_config_int->stAynrConfig.rawWidth  = sharedCom->snsDes.isp_acq_width;
207     aynr_config_int->stAynrConfig.rawHeight = sharedCom->snsDes.isp_acq_height;
208 
209     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
210     ret                       = des->prepare(mConfig);
211     RKAIQCORE_CHECK_RET(ret, "aynr algo prepare failed");
212 
213     EXIT_ANALYZER_FUNCTION();
214     return XCAM_RETURN_NO_ERROR;
215 }
216 
preProcess()217 XCamReturn RkAiqAynrV22HandleInt::preProcess() {
218     ENTER_ANALYZER_FUNCTION();
219 
220     XCamReturn ret = XCAM_RETURN_NO_ERROR;
221 #if 0
222     RkAiqAlgoPreAynrV22* aynr_pre_int        = (RkAiqAlgoPreAynrV22*)mPreInParam;
223     RkAiqAlgoPreResAynrV22* aynr_pre_res_int = (RkAiqAlgoPreResAynrV22*)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, "aynr handle preProcess failed");
231     }
232 
233     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
234     ret                       = des->pre_process(mPreInParam, mPreOutParam);
235     RKAIQCORE_CHECK_RET(ret, "aynr algo pre_process failed");
236 
237     EXIT_ANALYZER_FUNCTION();
238 #endif
239     return XCAM_RETURN_NO_ERROR;
240 }
241 
processing()242 XCamReturn RkAiqAynrV22HandleInt::processing() {
243     ENTER_ANALYZER_FUNCTION();
244 
245     XCamReturn ret = XCAM_RETURN_NO_ERROR;
246 
247     RkAiqAlgoProcAynrV22* aynr_proc_int        = (RkAiqAlgoProcAynrV22*)mProcInParam;
248     if (mDes->id == 0) {
249         mProcResShared = new RkAiqAlgoProcResAynrV22IntShared();
250         if (!mProcResShared.ptr()) {
251             LOGE("new YNR(v22) mProcResShared failed, bypass!");
252             return XCAM_RETURN_BYPASS;
253         }
254     }
255     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
256         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
257     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
258 
259     ret = RkAiqHandle::processing();
260     if (ret) {
261         RKAIQCORE_CHECK_RET(ret, "aynr handle processing failed");
262     }
263 
264     // TODO: fill procParam
265     aynr_proc_int->iso      = sharedCom->iso;
266     aynr_proc_int->hdr_mode = sharedCom->working_mode;
267     aynr_proc_int->stAblcV32_proc_res = shared->res_comb.ablcV32_proc_res;
268 
269     mProcResShared->result.stAynrProcResult.stFix = &shared->fullParams->mYnrV32Params->data()->result;
270 #ifdef DISABLE_HANDLE_ATTRIB
271     mCfgMutex.lock();
272 #endif
273     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
274     ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)(&mProcResShared->result));
275 #ifdef DISABLE_HANDLE_ATTRIB
276     mCfgMutex.unlock();
277 #endif
278     RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
279 
280     if (!mProcResShared->result.res_com.cfg_update) {
281         mProcResShared->result.stAynrProcResult = mLatestparam;
282         LOGD_ANR("[%d] copy results from latest !", shared->frameId);
283     }
284 
285     if (!mAiqCore->mAlogsComSharedParams.init && mPostShared) {
286         mProcResShared->set_sequence(shared->frameId);
287         RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_YNR_V22_PROC_RES_OK, shared->frameId, mProcResShared);
288         mAiqCore->post_message(msg);
289     }
290 
291     EXIT_ANALYZER_FUNCTION();
292     return ret;
293 }
294 
postProcess()295 XCamReturn RkAiqAynrV22HandleInt::postProcess() {
296     ENTER_ANALYZER_FUNCTION();
297 
298     XCamReturn ret = XCAM_RETURN_NO_ERROR;
299 #if 0
300     RkAiqAlgoPostAynrV22* aynr_post_int        = (RkAiqAlgoPostAynrV22*)mPostInParam;
301     RkAiqAlgoPostResAynrV22* aynr_post_res_int = (RkAiqAlgoPostResAynrV22*)mPostOutParam;
302     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
303         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
304     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
305 
306     ret = RkAiqHandle::postProcess();
307     if (ret) {
308         RKAIQCORE_CHECK_RET(ret, "aynr handle postProcess failed");
309         return ret;
310     }
311 
312     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
313     ret                       = des->post_process(mPostInParam, mPostOutParam);
314     RKAIQCORE_CHECK_RET(ret, "aynr algo post_process failed");
315 
316     EXIT_ANALYZER_FUNCTION();
317 #endif
318     return ret;
319 }
320 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)321 XCamReturn RkAiqAynrV22HandleInt::genIspResult(RkAiqFullParams* params,
322         RkAiqFullParams* cur_params) {
323     ENTER_ANALYZER_FUNCTION();
324 
325     XCamReturn ret = XCAM_RETURN_NO_ERROR;
326     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
327         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
328     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
329     if (!mProcResShared.ptr()) return XCAM_RETURN_NO_ERROR;
330     RkAiqAlgoProcResAynrV22* aynr_rk = (RkAiqAlgoProcResAynrV22*)&mProcResShared->result;
331 
332     if (!aynr_rk) {
333         LOGD_ANALYZER("no aynr 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_ynr_params_v32_t* ynr_param = params->mYnrV32Params->data().ptr();
340         if (sharedCom->init) {
341             ynr_param->frame_id = 0;
342         } else {
343             ynr_param->frame_id = shared->frameId;
344         }
345 
346         if (aynr_rk->res_com.cfg_update) {
347             mSyncFlag = shared->frameId;
348             ynr_param->sync_flag = mSyncFlag;
349             // copy from algo result
350             cur_params->mYnrV32Params = params->mYnrV32Params;
351             mLatestparam = aynr_rk->stAynrProcResult;
352             ynr_param->is_update = true;
353             LOGD_ANR("[%d] params from algo", mSyncFlag);
354         } else if (mSyncFlag != ynr_param->sync_flag) {
355             ynr_param->sync_flag = mSyncFlag;
356             // copy from latest result
357             if (cur_params->mYnrV32Params.ptr()) {
358                 ynr_param->result = cur_params->mYnrV32Params->data()->result;
359                 ynr_param->is_update = true;
360             } else {
361                 LOGE_ANR("no latest params !");
362                 ynr_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             ynr_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