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 "RkAiqAmfnrHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAmfnrHandleInt);
23
init()24 void RkAiqAmfnrHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAmfnr());
29 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAmfnr());
30 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAmfnr());
31 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAmfnr());
32 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAmfnr());
33 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAmfnr());
34 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAmfnr());
35
36 EXIT_ANALYZER_FUNCTION();
37 }
38
updateConfig(bool needSync)39 XCamReturn RkAiqAmfnrHandleInt::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 updateAtt = false;
49 // TODO
50 rk_aiq_uapi_amfnr_SetAttrib_v1(mAlgoCtx, &mCurAtt, false);
51 sendSignal();
52 }
53
54 if (updateIQpara) {
55 mCurIQPara = mNewIQPara;
56 updateIQpara = false;
57 // TODO
58 rk_aiq_uapi_amfnr_SetIQPara_v1(mAlgoCtx, &mCurIQPara, false);
59 sendSignal();
60 }
61
62 if (updateJsonpara) {
63 mCurJsonPara = mNewJsonPara;
64 updateJsonpara = false;
65 // TODO
66 rk_aiq_uapi_amfnr_SetJsonPara_v1(mAlgoCtx, &mCurJsonPara, false);
67 sendSignal();
68 }
69
70 if (needSync) mCfgMutex.unlock();
71 #endif
72
73 EXIT_ANALYZER_FUNCTION();
74 return ret;
75 }
76
setAttrib(rk_aiq_mfnr_attrib_v1_t * att)77 XCamReturn RkAiqAmfnrHandleInt::setAttrib(rk_aiq_mfnr_attrib_v1_t* att) {
78 ENTER_ANALYZER_FUNCTION();
79
80 XCamReturn ret = XCAM_RETURN_NO_ERROR;
81 mCfgMutex.lock();
82 #ifdef DISABLE_HANDLE_ATTRIB
83 ret = rk_aiq_uapi_amfnr_SetAttrib_v1(mAlgoCtx, att, false);
84 #else
85 // TODO
86 // check if there is different between att & mCurAtt
87 // if something changed, set att to mNewAtt, and
88 // the new params will be effective later when updateConfig
89 // called by RkAiqCore
90
91 // if something changed
92 if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_mfnr_attrib_v1_t))) {
93 mNewAtt = *att;
94 updateAtt = true;
95 waitSignal();
96 }
97 #endif
98
99 mCfgMutex.unlock();
100
101 EXIT_ANALYZER_FUNCTION();
102 return ret;
103 }
104
getAttrib(rk_aiq_mfnr_attrib_v1_t * att)105 XCamReturn RkAiqAmfnrHandleInt::getAttrib(rk_aiq_mfnr_attrib_v1_t* att) {
106 ENTER_ANALYZER_FUNCTION();
107
108 XCamReturn ret = XCAM_RETURN_NO_ERROR;
109
110 rk_aiq_uapi_amfnr_GetAttrib_v1(mAlgoCtx, att);
111
112 EXIT_ANALYZER_FUNCTION();
113 return ret;
114 }
115
setIQPara(rk_aiq_mfnr_IQPara_V1_t * para)116 XCamReturn RkAiqAmfnrHandleInt::setIQPara(rk_aiq_mfnr_IQPara_V1_t* para) {
117 ENTER_ANALYZER_FUNCTION();
118
119 XCamReturn ret = XCAM_RETURN_NO_ERROR;
120 mCfgMutex.lock();
121 #ifdef DISABLE_HANDLE_ATTRIB
122 ret = rk_aiq_uapi_amfnr_SetIQPara_v1(mAlgoCtx, para, false);
123 #else
124 // TODO
125 // check if there is different between att & mCurAtt
126 // if something changed, set att to mNewAtt, and
127 // the new params will be effective later when updateConfig
128 // called by RkAiqCore
129
130 // if something changed
131 if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_mfnr_IQPara_V1_t))) {
132 mNewIQPara = *para;
133 updateIQpara = true;
134 waitSignal();
135 }
136 #endif
137
138 mCfgMutex.unlock();
139
140 EXIT_ANALYZER_FUNCTION();
141 return ret;
142 }
143
getIQPara(rk_aiq_mfnr_IQPara_V1_t * para)144 XCamReturn RkAiqAmfnrHandleInt::getIQPara(rk_aiq_mfnr_IQPara_V1_t* para) {
145 ENTER_ANALYZER_FUNCTION();
146
147 XCamReturn ret = XCAM_RETURN_NO_ERROR;
148
149 rk_aiq_uapi_amfnr_GetIQPara_v1(mAlgoCtx, para);
150
151 EXIT_ANALYZER_FUNCTION();
152 return ret;
153 }
154
setJsonPara(rk_aiq_mfnr_JsonPara_V1_t * para)155 XCamReturn RkAiqAmfnrHandleInt::setJsonPara(rk_aiq_mfnr_JsonPara_V1_t* para) {
156 ENTER_ANALYZER_FUNCTION();
157
158 XCamReturn ret = XCAM_RETURN_NO_ERROR;
159 mCfgMutex.lock();
160 #ifdef DISABLE_HANDLE_ATTRIB
161 ret = rk_aiq_uapi_amfnr_SetJsonPara_v1(mAlgoCtx, para, false);
162 #else
163 // TODO
164 // check if there is different between att & mCurAtt
165 // if something changed, set att to mNewAtt, and
166 // the new params will be effective later when updateConfig
167 // called by RkAiqCore
168
169 // if something changed
170 if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_mfnr_JsonPara_V1_t))) {
171 mNewJsonPara = *para;
172 updateJsonpara = true;
173 waitSignal();
174 }
175 #endif
176 mCfgMutex.unlock();
177
178 EXIT_ANALYZER_FUNCTION();
179 return ret;
180 }
181
getJsonPara(rk_aiq_mfnr_JsonPara_V1_t * para)182 XCamReturn RkAiqAmfnrHandleInt::getJsonPara(rk_aiq_mfnr_JsonPara_V1_t* para) {
183 ENTER_ANALYZER_FUNCTION();
184
185 XCamReturn ret = XCAM_RETURN_NO_ERROR;
186
187 rk_aiq_uapi_amfnr_GetJsonPara_v1(mAlgoCtx, para);
188
189 EXIT_ANALYZER_FUNCTION();
190 return ret;
191 }
192
setLumaStrength(float fPercent)193 XCamReturn RkAiqAmfnrHandleInt::setLumaStrength(float fPercent) {
194 ENTER_ANALYZER_FUNCTION();
195
196 XCamReturn ret = XCAM_RETURN_NO_ERROR;
197
198 rk_aiq_uapi_amfnr_SetLumaTFStrength_v1(mAlgoCtx, fPercent);
199
200 EXIT_ANALYZER_FUNCTION();
201 return ret;
202 }
203
getLumaStrength(float * pPercent)204 XCamReturn RkAiqAmfnrHandleInt::getLumaStrength(float* pPercent) {
205 ENTER_ANALYZER_FUNCTION();
206
207 XCamReturn ret = XCAM_RETURN_NO_ERROR;
208
209 rk_aiq_uapi_amfnr_GetLumaTFStrength_v1(mAlgoCtx, pPercent);
210
211 EXIT_ANALYZER_FUNCTION();
212 return ret;
213 }
214
setChromaStrength(float fPercent)215 XCamReturn RkAiqAmfnrHandleInt::setChromaStrength(float fPercent) {
216 ENTER_ANALYZER_FUNCTION();
217
218 XCamReturn ret = XCAM_RETURN_NO_ERROR;
219
220 rk_aiq_uapi_amfnr_SetChromaTFStrength_v1(mAlgoCtx, fPercent);
221
222 EXIT_ANALYZER_FUNCTION();
223 return ret;
224 }
225
getChromaStrength(float * pPercent)226 XCamReturn RkAiqAmfnrHandleInt::getChromaStrength(float* pPercent) {
227 ENTER_ANALYZER_FUNCTION();
228
229 XCamReturn ret = XCAM_RETURN_NO_ERROR;
230
231 rk_aiq_uapi_amfnr_GetChromaTFStrength_v1(mAlgoCtx, pPercent);
232
233 EXIT_ANALYZER_FUNCTION();
234 return ret;
235 }
236
prepare()237 XCamReturn RkAiqAmfnrHandleInt::prepare() {
238 ENTER_ANALYZER_FUNCTION();
239
240 XCamReturn ret = XCAM_RETURN_NO_ERROR;
241
242 ret = RkAiqHandle::prepare();
243 RKAIQCORE_CHECK_RET(ret, "amfnr handle prepare failed");
244
245 RkAiqAlgoConfigAmfnr* amfnr_config_int = (RkAiqAlgoConfigAmfnr*)mConfig;
246
247 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
248 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
249
250 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
251 ret = des->prepare(mConfig);
252 RKAIQCORE_CHECK_RET(ret, "amfnr algo prepare failed");
253
254 EXIT_ANALYZER_FUNCTION();
255 return XCAM_RETURN_NO_ERROR;
256 }
257
preProcess()258 XCamReturn RkAiqAmfnrHandleInt::preProcess() {
259 ENTER_ANALYZER_FUNCTION();
260
261 XCamReturn ret = XCAM_RETURN_NO_ERROR;
262
263 RkAiqAlgoPreAmfnr* amfnr_pre_int = (RkAiqAlgoPreAmfnr*)mPreInParam;
264 RkAiqAlgoPreResAmfnr* amfnr_pre_res_int = (RkAiqAlgoPreResAmfnr*)mPreOutParam;
265
266 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
267 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
268 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
269
270 ret = RkAiqHandle::preProcess();
271 if (ret) {
272 RKAIQCORE_CHECK_RET(ret, "amfnr handle preProcess failed");
273 }
274
275 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
276 ret = des->pre_process(mPreInParam, mPreOutParam);
277 RKAIQCORE_CHECK_RET(ret, "amfnr algo pre_process failed");
278
279 EXIT_ANALYZER_FUNCTION();
280 return XCAM_RETURN_NO_ERROR;
281 }
282
processing()283 XCamReturn RkAiqAmfnrHandleInt::processing() {
284 ENTER_ANALYZER_FUNCTION();
285
286 XCamReturn ret = XCAM_RETURN_NO_ERROR;
287
288 RkAiqAlgoProcAmfnr* amfnr_proc_int = (RkAiqAlgoProcAmfnr*)mProcInParam;
289 RkAiqAlgoProcResAmfnr* amfnr_proc_res_int = (RkAiqAlgoProcResAmfnr*)mProcOutParam;
290
291 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
292 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
293 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
294
295 ret = RkAiqHandle::processing();
296 if (ret) {
297 RKAIQCORE_CHECK_RET(ret, "amfnr handle processing failed");
298 }
299
300 #ifdef DISABLE_HANDLE_ATTRIB
301 mCfgMutex.lock();
302 #endif
303 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
304 ret = des->processing(mProcInParam, mProcOutParam);
305 #ifdef DISABLE_HANDLE_ATTRIB
306 mCfgMutex.unlock();
307 #endif
308 RKAIQCORE_CHECK_RET(ret, "amfnr algo processing failed");
309
310 EXIT_ANALYZER_FUNCTION();
311 return ret;
312 }
313
postProcess()314 XCamReturn RkAiqAmfnrHandleInt::postProcess() {
315 ENTER_ANALYZER_FUNCTION();
316
317 XCamReturn ret = XCAM_RETURN_NO_ERROR;
318
319 RkAiqAlgoPostAmfnr* amfnr_post_int = (RkAiqAlgoPostAmfnr*)mPostInParam;
320 RkAiqAlgoPostResAmfnr* amfnr_post_res_int = (RkAiqAlgoPostResAmfnr*)mPostOutParam;
321
322 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
323 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
324 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
325
326 ret = RkAiqHandle::postProcess();
327 if (ret) {
328 RKAIQCORE_CHECK_RET(ret, "amfnr handle postProcess failed");
329 return ret;
330 }
331
332 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
333 ret = des->post_process(mPostInParam, mPostOutParam);
334 RKAIQCORE_CHECK_RET(ret, "amfnr algo post_process failed");
335
336 EXIT_ANALYZER_FUNCTION();
337 return ret;
338 }
339
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)340 XCamReturn RkAiqAmfnrHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
341 ENTER_ANALYZER_FUNCTION();
342
343 XCamReturn ret = XCAM_RETURN_NO_ERROR;
344 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
345 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
346 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
347 RkAiqAlgoProcResAmfnr* amfnr_com = (RkAiqAlgoProcResAmfnr*)mProcOutParam;
348
349 if (!amfnr_com) {
350 LOGD_ANALYZER("no asharp result");
351 return XCAM_RETURN_NO_ERROR;
352 }
353
354 if (!this->getAlgoId()) {
355 RkAiqAlgoProcResAmfnr* amfnr_rk = (RkAiqAlgoProcResAmfnr*)amfnr_com;
356 if (params->mTnrParams.ptr()) {
357 rk_aiq_isp_tnr_params_v20_t* tnr_param = params->mTnrParams->data().ptr();
358 LOGD_ANR("oyyf: %s:%d output ispp param start\n", __FUNCTION__, __LINE__);
359
360 if (sharedCom->init) {
361 tnr_param->frame_id = 0;
362 } else {
363 tnr_param->frame_id = shared->frameId;
364 }
365 tnr_param->update_mask |= RKAIQ_ISPP_TNR_ID;
366 memcpy(&tnr_param->result, &amfnr_rk->stAmfnrProcResult.stFix,
367 sizeof(RK_MFNR_Fix_V1_t));
368 }
369 LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
370 }
371
372 cur_params->mTnrParams = params->mTnrParams;
373
374 EXIT_ANALYZER_FUNCTION();
375
376 return ret;
377 }
378
379 } // namespace RkCam
380