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 "RkAiqAnrHandle.h"
18
19 #include "RkAiqCore.h"
20
21 namespace RkCam {
22
23 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAnrHandleInt);
24
init()25 void RkAiqAnrHandleInt::init() {
26 ENTER_ANALYZER_FUNCTION();
27
28 RkAiqHandle::deInit();
29 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAnr());
30 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAnr());
31 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAnr());
32 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAnr());
33 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAnr());
34 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAnr());
35 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAnr());
36
37 EXIT_ANALYZER_FUNCTION();
38 }
39
updateConfig(bool needSync)40 XCamReturn RkAiqAnrHandleInt::updateConfig(bool needSync) {
41 ENTER_ANALYZER_FUNCTION();
42
43 XCamReturn ret = XCAM_RETURN_NO_ERROR;
44 #ifndef DISABLE_HANDLE_ATTRIB
45 if (needSync) mCfgMutex.lock();
46 // if something changed
47 if (updateAtt) {
48 mCurAtt = mNewAtt;
49 updateAtt = false;
50 // TODO
51 rk_aiq_uapi_anr_SetAttrib(mAlgoCtx, &mCurAtt, false);
52 sendSignal();
53 }
54
55 if (UpdateIQpara) {
56 mCurIQpara = mNewIQpara;
57 UpdateIQpara = false;
58 rk_aiq_uapi_anr_SetIQPara(mAlgoCtx, &mCurIQpara, false);
59 sendSignal();
60 }
61
62 if (needSync) mCfgMutex.unlock();
63 #endif
64
65 EXIT_ANALYZER_FUNCTION();
66 return ret;
67 }
68
setAttrib(rk_aiq_nr_attrib_t * att)69 XCamReturn RkAiqAnrHandleInt::setAttrib(rk_aiq_nr_attrib_t* att) {
70 ENTER_ANALYZER_FUNCTION();
71
72 XCamReturn ret = XCAM_RETURN_NO_ERROR;
73 mCfgMutex.lock();
74 // TODO
75 // check if there is different between att & mCurAtt
76 // if something changed, set att to mNewAtt, and
77 // the new params will be effective later when updateConfig
78 // called by RkAiqCore
79
80 // if something changed
81 #ifdef DISABLE_HANDLE_ATTRIB
82 ret = rk_aiq_uapi_anr_SetAttrib(mAlgoCtx, att, false);
83 #else
84 if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_nr_attrib_t))) {
85 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
86 CalibDbV2_MFNR_t* mfnr =
87 (CalibDbV2_MFNR_t*)CALIBDBV2_GET_MODULE_PTR((void*)(sharedCom->calibv2), mfnr_v1);
88 if (mfnr && mfnr->TuningPara.enable && mfnr->TuningPara.motion_detect_en) {
89 if ((att->eMode == ANR_OP_MODE_AUTO) && (!att->stAuto.mfnrEn)) {
90 att->stAuto.mfnrEn = !att->stAuto.mfnrEn;
91 LOGE("motion detect is running, operate not permit!");
92 goto EXIT;
93 } else if ((att->eMode == ANR_OP_MODE_MANUAL) && (!att->stManual.mfnrEn)) {
94 att->stManual.mfnrEn = !att->stManual.mfnrEn;
95 LOGE("motion detect is running, operate not permit!");
96 goto EXIT;
97 }
98 }
99 mNewAtt = *att;
100 updateAtt = true;
101 waitSignal();
102 }
103 EXIT:
104 #endif
105 mCfgMutex.unlock();
106
107 EXIT_ANALYZER_FUNCTION();
108 return ret;
109 }
110
getAttrib(rk_aiq_nr_attrib_t * att)111 XCamReturn RkAiqAnrHandleInt::getAttrib(rk_aiq_nr_attrib_t* att) {
112 ENTER_ANALYZER_FUNCTION();
113
114 XCamReturn ret = XCAM_RETURN_NO_ERROR;
115
116 ret = rk_aiq_uapi_anr_GetAttrib(mAlgoCtx, att);
117
118 EXIT_ANALYZER_FUNCTION();
119 return ret;
120 }
121
setIQPara(rk_aiq_nr_IQPara_t * para)122 XCamReturn RkAiqAnrHandleInt::setIQPara(rk_aiq_nr_IQPara_t* para) {
123 ENTER_ANALYZER_FUNCTION();
124
125 XCamReturn ret = XCAM_RETURN_NO_ERROR;
126 mCfgMutex.lock();
127 #ifdef DISABLE_HANDLE_ATTRIB
128 ret = rk_aiq_uapi_anr_SetIQPara(mAlgoCtx, para, false);
129 #else
130 // TODO
131 // check if there is different between att & mCurAtt
132 // if something changed, set att to mNewAtt, and
133 // the new params will be effective later when updateConfig
134 // called by RkAiqCore
135
136 // if something changed
137 if (0 != memcmp(&mCurIQpara, para, sizeof(rk_aiq_nr_IQPara_t))) {
138 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
139 CalibDbV2_MFNR_t* mfnr =
140 (CalibDbV2_MFNR_t*)CALIBDBV2_GET_MODULE_PTR((void*)(sharedCom->calibv2), mfnr_v1);
141 if (mfnr && mfnr->TuningPara.enable && mfnr->TuningPara.motion_detect_en) {
142 if ((para->module_bits & (1 << ANR_MODULE_MFNR)) && !para->stMfnrPara.enable) {
143 para->stMfnrPara.enable = !para->stMfnrPara.enable;
144 LOGE("motion detect is running, disable mfnr is not permit!");
145 }
146 }
147 mNewIQpara = *para;
148 UpdateIQpara = true;
149 waitSignal();
150 }
151 EXIT:
152 #endif
153 mCfgMutex.unlock();
154
155 EXIT_ANALYZER_FUNCTION();
156 return ret;
157 }
158
getIQPara(rk_aiq_nr_IQPara_t * para)159 XCamReturn RkAiqAnrHandleInt::getIQPara(rk_aiq_nr_IQPara_t* para) {
160 ENTER_ANALYZER_FUNCTION();
161
162 XCamReturn ret = XCAM_RETURN_NO_ERROR;
163
164 ret = rk_aiq_uapi_anr_GetIQPara(mAlgoCtx, para);
165
166 EXIT_ANALYZER_FUNCTION();
167 return ret;
168 }
169
setLumaSFStrength(float fPercent)170 XCamReturn RkAiqAnrHandleInt::setLumaSFStrength(float fPercent) {
171 ENTER_ANALYZER_FUNCTION();
172 XCamReturn ret = XCAM_RETURN_NO_ERROR;
173 ret = rk_aiq_uapi_anr_SetLumaSFStrength(mAlgoCtx, fPercent);
174 EXIT_ANALYZER_FUNCTION();
175 return ret;
176 }
177
setLumaTFStrength(float fPercent)178 XCamReturn RkAiqAnrHandleInt::setLumaTFStrength(float fPercent) {
179 ENTER_ANALYZER_FUNCTION();
180 XCamReturn ret = XCAM_RETURN_NO_ERROR;
181 ret = rk_aiq_uapi_anr_SetLumaTFStrength(mAlgoCtx, fPercent);
182 EXIT_ANALYZER_FUNCTION();
183 return ret;
184 }
185
getLumaSFStrength(float * pPercent)186 XCamReturn RkAiqAnrHandleInt::getLumaSFStrength(float* pPercent) {
187 ENTER_ANALYZER_FUNCTION();
188 XCamReturn ret = XCAM_RETURN_NO_ERROR;
189 ret = rk_aiq_uapi_anr_GetLumaSFStrength(mAlgoCtx, pPercent);
190 EXIT_ANALYZER_FUNCTION();
191 return ret;
192 }
193
getLumaTFStrength(float * pPercent)194 XCamReturn RkAiqAnrHandleInt::getLumaTFStrength(float* pPercent) {
195 ENTER_ANALYZER_FUNCTION();
196 XCamReturn ret = XCAM_RETURN_NO_ERROR;
197 ret = rk_aiq_uapi_anr_GetLumaTFStrength(mAlgoCtx, pPercent);
198 EXIT_ANALYZER_FUNCTION();
199 return ret;
200 }
201
setChromaSFStrength(float fPercent)202 XCamReturn RkAiqAnrHandleInt::setChromaSFStrength(float fPercent) {
203 ENTER_ANALYZER_FUNCTION();
204 XCamReturn ret = XCAM_RETURN_NO_ERROR;
205 ret = rk_aiq_uapi_anr_SetChromaSFStrength(mAlgoCtx, fPercent);
206 EXIT_ANALYZER_FUNCTION();
207 return ret;
208 }
209
setChromaTFStrength(float fPercent)210 XCamReturn RkAiqAnrHandleInt::setChromaTFStrength(float fPercent) {
211 ENTER_ANALYZER_FUNCTION();
212 XCamReturn ret = XCAM_RETURN_NO_ERROR;
213 ret = rk_aiq_uapi_anr_SetChromaTFStrength(mAlgoCtx, fPercent);
214 EXIT_ANALYZER_FUNCTION();
215 return ret;
216 }
217
getChromaSFStrength(float * pPercent)218 XCamReturn RkAiqAnrHandleInt::getChromaSFStrength(float* pPercent) {
219 ENTER_ANALYZER_FUNCTION();
220 XCamReturn ret = XCAM_RETURN_NO_ERROR;
221 ret = rk_aiq_uapi_anr_GetChromaSFStrength(mAlgoCtx, pPercent);
222 EXIT_ANALYZER_FUNCTION();
223 return ret;
224 }
225
getChromaTFStrength(float * pPercent)226 XCamReturn RkAiqAnrHandleInt::getChromaTFStrength(float* pPercent) {
227 ENTER_ANALYZER_FUNCTION();
228 XCamReturn ret = XCAM_RETURN_NO_ERROR;
229 ret = rk_aiq_uapi_anr_GetChromaTFStrength(mAlgoCtx, pPercent);
230 EXIT_ANALYZER_FUNCTION();
231 return ret;
232 }
233
setRawnrSFStrength(float fPercent)234 XCamReturn RkAiqAnrHandleInt::setRawnrSFStrength(float fPercent) {
235 ENTER_ANALYZER_FUNCTION();
236 XCamReturn ret = XCAM_RETURN_NO_ERROR;
237 ret = rk_aiq_uapi_anr_SetRawnrSFStrength(mAlgoCtx, fPercent);
238 EXIT_ANALYZER_FUNCTION();
239 return ret;
240 }
241
getRawnrSFStrength(float * pPercent)242 XCamReturn RkAiqAnrHandleInt::getRawnrSFStrength(float* pPercent) {
243 ENTER_ANALYZER_FUNCTION();
244 XCamReturn ret = XCAM_RETURN_NO_ERROR;
245 ret = rk_aiq_uapi_anr_GetRawnrSFStrength(mAlgoCtx, pPercent);
246 EXIT_ANALYZER_FUNCTION();
247 return ret;
248 }
249
prepare()250 XCamReturn RkAiqAnrHandleInt::prepare() {
251 ENTER_ANALYZER_FUNCTION();
252
253 XCamReturn ret = XCAM_RETURN_NO_ERROR;
254
255 ret = RkAiqHandle::prepare();
256 RKAIQCORE_CHECK_RET(ret, "anr handle prepare failed");
257
258 RkAiqAlgoConfigAnr* anr_config_int = (RkAiqAlgoConfigAnr*)mConfig;
259
260 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
261 ret = des->prepare(mConfig);
262 RKAIQCORE_CHECK_RET(ret, "anr algo prepare failed");
263
264 EXIT_ANALYZER_FUNCTION();
265 return XCAM_RETURN_NO_ERROR;
266 }
267
preProcess()268 XCamReturn RkAiqAnrHandleInt::preProcess() {
269 ENTER_ANALYZER_FUNCTION();
270
271 XCamReturn ret = XCAM_RETURN_NO_ERROR;
272
273 RkAiqAlgoPreAnr* anr_pre_int = (RkAiqAlgoPreAnr*)mPreInParam;
274 RkAiqAlgoPreResAnr* anr_pre_res_int = (RkAiqAlgoPreResAnr*)mPreOutParam;
275 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
276 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
277 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
278
279 ret = RkAiqHandle::preProcess();
280 if (ret) {
281 RKAIQCORE_CHECK_RET(ret, "anr handle preProcess failed");
282 }
283
284 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
285 ret = des->pre_process(mPreInParam, mPreOutParam);
286 RKAIQCORE_CHECK_RET(ret, "anr algo pre_process failed");
287
288
289 EXIT_ANALYZER_FUNCTION();
290 return XCAM_RETURN_NO_ERROR;
291 }
292
processing()293 XCamReturn RkAiqAnrHandleInt::processing() {
294 ENTER_ANALYZER_FUNCTION();
295
296 XCamReturn ret = XCAM_RETURN_NO_ERROR;
297
298 RkAiqAlgoProcAnr* anr_proc_int = (RkAiqAlgoProcAnr*)mProcInParam;
299 RkAiqAlgoProcResAnr* anr_proc_res_int = (RkAiqAlgoProcResAnr*)mProcOutParam;
300 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
301 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
302 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
303 static int anr_proc_framecnt = 0;
304 anr_proc_framecnt++;
305
306 ret = RkAiqHandle::processing();
307 if (ret) {
308 RKAIQCORE_CHECK_RET(ret, "anr handle processing failed");
309 }
310
311 // TODO: fill procParam
312 anr_proc_int->iso = sharedCom->iso;
313
314 anr_proc_int->hdr_mode = sharedCom->working_mode;
315
316 LOGD("%s:%d anr hdr_mode:%d \n", __FUNCTION__, __LINE__, anr_proc_int->hdr_mode);
317
318 #ifdef DISABLE_HANDLE_ATTRIB
319 mCfgMutex.lock();
320 #endif
321 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
322 ret = des->processing(mProcInParam, mProcOutParam);
323 #ifdef DISABLE_HANDLE_ATTRIB
324 mCfgMutex.unlock();
325 #endif
326 RKAIQCORE_CHECK_RET(ret, "anr algo processing failed");
327
328 EXIT_ANALYZER_FUNCTION();
329 return ret;
330 }
331
postProcess()332 XCamReturn RkAiqAnrHandleInt::postProcess() {
333 ENTER_ANALYZER_FUNCTION();
334
335 XCamReturn ret = XCAM_RETURN_NO_ERROR;
336
337 RkAiqAlgoPostAnr* anr_post_int = (RkAiqAlgoPostAnr*)mPostInParam;
338 RkAiqAlgoPostResAnr* anr_post_res_int = (RkAiqAlgoPostResAnr*)mPostOutParam;
339 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
340 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
341 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
342
343 ret = RkAiqHandle::postProcess();
344 if (ret) {
345 RKAIQCORE_CHECK_RET(ret, "anr handle postProcess failed");
346 return ret;
347 }
348
349 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
350 ret = des->post_process(mPostInParam, mPostOutParam);
351 RKAIQCORE_CHECK_RET(ret, "anr algo post_process failed");
352
353 EXIT_ANALYZER_FUNCTION();
354 return ret;
355 }
356
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)357 XCamReturn RkAiqAnrHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
358 ENTER_ANALYZER_FUNCTION();
359
360 XCamReturn ret = XCAM_RETURN_NO_ERROR;
361 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
362 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
363 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
364 RkAiqAlgoProcResAnr* anr_com = (RkAiqAlgoProcResAnr*)mProcOutParam;
365
366 if (!anr_com /*|| !params->mIsppOtherParams.ptr()*/) {
367 LOGD_ANALYZER("no anr result");
368 return XCAM_RETURN_NO_ERROR;
369 }
370
371 if (!this->getAlgoId()) {
372 RkAiqAlgoProcResAnr* anr_rk = (RkAiqAlgoProcResAnr*)anr_com;
373 LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
374
375 rk_aiq_isp_rawnr_params_v20_t* rawnr_params = params->mRawnrParams->data().ptr();
376 rawnr_params->update_mask |= RKAIQ_ISPP_NR_ID;
377 memcpy(&rawnr_params->result, &anr_rk->stAnrProcResult.stBayernrFix,
378 sizeof(rk_aiq_isp_rawnr_t));
379
380 rk_aiq_isp_gain_params_v20_t* gain_params = params->mGainParams->data().ptr();
381 memcpy(&gain_params->result, &anr_rk->stAnrProcResult.stGainFix, sizeof(rk_aiq_isp_gain_t));
382
383 rk_aiq_isp_motion_params_v20_t* motion_params = params->mMotionParams->data().ptr();
384 memcpy(&motion_params->result, &anr_rk->stAnrProcResult.stMotion,
385 sizeof(anr_rk->stAnrProcResult.stMotion));
386
387 LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
388
389 LOGD_ANR("oyyf: %s:%d output ispp param start\n", __FUNCTION__, __LINE__);
390
391 rk_aiq_isp_ynr_params_v20_t* ynr_params = params->mYnrParams->data().ptr();
392 memcpy(&ynr_params->result, &anr_rk->stAnrProcResult.stYnrFix, sizeof(RKAnr_Ynr_Fix_t));
393
394 rk_aiq_isp_uvnr_params_v20_t* uvnr_params = params->mUvnrParams->data().ptr();
395 uvnr_params->update_mask |= RKAIQ_ISPP_NR_ID;
396 memcpy(&uvnr_params->result, &anr_rk->stAnrProcResult.stUvnrFix, sizeof(RKAnr_Uvnr_Fix_t));
397
398 rk_aiq_isp_tnr_params_v20_t* tnr_params = params->mTnrParams->data().ptr();
399 memcpy(&tnr_params->result, &anr_rk->stAnrProcResult.stMfnrFix, sizeof(RKAnr_Mfnr_Fix_t));
400 LOGD_ANR("oyyf: %s:%d output ispp param end \n", __FUNCTION__, __LINE__);
401
402 if (sharedCom->init) {
403 rawnr_params->frame_id = 0;
404 gain_params->frame_id = 0;
405 motion_params->frame_id = 0;
406 ynr_params->frame_id = 0;
407 uvnr_params->frame_id = 0;
408 tnr_params->frame_id = 0;
409 } else {
410 rawnr_params->frame_id = shared->frameId;
411 gain_params->frame_id = shared->frameId;
412 motion_params->frame_id = shared->frameId;
413 ynr_params->frame_id = shared->frameId;
414 uvnr_params->frame_id = shared->frameId;
415 tnr_params->frame_id = shared->frameId;
416 }
417 }
418
419 cur_params->mRawnrParams = params->mRawnrParams;
420 cur_params->mUvnrParams = params->mUvnrParams;
421 cur_params->mYnrParams = params->mYnrParams;
422 cur_params->mTnrParams = params->mTnrParams;
423 cur_params->mYnrParams = params->mYnrParams;
424 cur_params->mGainParams = params->mGainParams;
425 cur_params->mMotionParams = params->mMotionParams;
426
427 EXIT_ANALYZER_FUNCTION();
428
429 return ret;
430 }
431
432 } // namespace RkCam
433