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 "RkAiqAcnrHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAcnrHandleInt);
23
init()24 void RkAiqAcnrHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAcnr());
29 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAcnr());
30 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAcnr());
31 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAcnr());
32 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAcnr());
33 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAcnr());
34 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAcnr());
35
36 EXIT_ANALYZER_FUNCTION();
37 }
38
updateConfig(bool needSync)39 XCamReturn RkAiqAcnrHandleInt::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_auvnr_SetAttrib(mAlgoCtx, &mCurAtt, false);
51 sendSignal();
52 }
53
54 if (updateIQpara) {
55 mCurIQPara = mNewIQPara;
56 updateIQpara = false;
57 // TODO
58 rk_aiq_uapi_auvnr_SetIQPara(mAlgoCtx, &mCurIQPara, false);
59 sendSignal();
60 }
61
62 if (updateJsonpara) {
63 mCurJsonPara = mNewJsonPara;
64 updateJsonpara = false;
65 // TODO
66 rk_aiq_uapi_auvnr_SetJsonPara(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_uvnr_attrib_v1_t * att)77 XCamReturn RkAiqAcnrHandleInt::setAttrib(rk_aiq_uvnr_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_auvnr_SetAttrib(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_uvnr_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_uvnr_attrib_v1_t * att)105 XCamReturn RkAiqAcnrHandleInt::getAttrib(rk_aiq_uvnr_attrib_v1_t* att) {
106 ENTER_ANALYZER_FUNCTION();
107
108 XCamReturn ret = XCAM_RETURN_NO_ERROR;
109
110 rk_aiq_uapi_auvnr_GetAttrib(mAlgoCtx, att);
111
112 EXIT_ANALYZER_FUNCTION();
113 return ret;
114 }
115
setIQPara(rk_aiq_uvnr_IQPara_v1_t * para)116 XCamReturn RkAiqAcnrHandleInt::setIQPara(rk_aiq_uvnr_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_auvnr_SetIQPara(mAlgoCtx, att, 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_uvnr_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_uvnr_IQPara_v1_t * para)144 XCamReturn RkAiqAcnrHandleInt::getIQPara(rk_aiq_uvnr_IQPara_v1_t* para) {
145 ENTER_ANALYZER_FUNCTION();
146
147 XCamReturn ret = XCAM_RETURN_NO_ERROR;
148
149 rk_aiq_uapi_auvnr_GetIQPara(mAlgoCtx, para);
150
151 EXIT_ANALYZER_FUNCTION();
152 return ret;
153 }
154
setJsonPara(rk_aiq_uvnr_JsonPara_v1_t * para)155 XCamReturn RkAiqAcnrHandleInt::setJsonPara(rk_aiq_uvnr_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_auvnr_SetJsonPara(mAlgoCtx, att, 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_uvnr_JsonPara_v1_t))) {
171 mNewJsonPara = *para;
172 updateJsonpara = true;
173 waitSignal();
174 }
175 #endif
176
177 mCfgMutex.unlock();
178
179 EXIT_ANALYZER_FUNCTION();
180 return ret;
181 }
182
getJsonPara(rk_aiq_uvnr_JsonPara_v1_t * para)183 XCamReturn RkAiqAcnrHandleInt::getJsonPara(rk_aiq_uvnr_JsonPara_v1_t* para) {
184 ENTER_ANALYZER_FUNCTION();
185
186 XCamReturn ret = XCAM_RETURN_NO_ERROR;
187
188 rk_aiq_uapi_auvnr_GetJsonPara(mAlgoCtx, para);
189
190 EXIT_ANALYZER_FUNCTION();
191 return ret;
192 }
193
setStrength(float fPercent)194 XCamReturn RkAiqAcnrHandleInt::setStrength(float fPercent) {
195 ENTER_ANALYZER_FUNCTION();
196
197 XCamReturn ret = XCAM_RETURN_NO_ERROR;
198
199 // rk_aiq_uapi_asharp_SetStrength(mAlgoCtx, fPercent);
200
201 EXIT_ANALYZER_FUNCTION();
202 return ret;
203 }
204
getStrength(float * pPercent)205 XCamReturn RkAiqAcnrHandleInt::getStrength(float* pPercent) {
206 ENTER_ANALYZER_FUNCTION();
207
208 XCamReturn ret = XCAM_RETURN_NO_ERROR;
209
210 // rk_aiq_uapi_asharp_GetStrength(mAlgoCtx, pPercent);
211
212 EXIT_ANALYZER_FUNCTION();
213 return ret;
214 }
215
prepare()216 XCamReturn RkAiqAcnrHandleInt::prepare() {
217 ENTER_ANALYZER_FUNCTION();
218
219 XCamReturn ret = XCAM_RETURN_NO_ERROR;
220
221 ret = RkAiqHandle::prepare();
222 RKAIQCORE_CHECK_RET(ret, "auvnr handle prepare failed");
223
224 RkAiqAlgoConfigAcnr* auvnr_config_int = (RkAiqAlgoConfigAcnr*)mConfig;
225
226 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
227 ret = des->prepare(mConfig);
228 RKAIQCORE_CHECK_RET(ret, "auvnr algo prepare failed");
229
230 EXIT_ANALYZER_FUNCTION();
231 return XCAM_RETURN_NO_ERROR;
232 }
233
preProcess()234 XCamReturn RkAiqAcnrHandleInt::preProcess() {
235 ENTER_ANALYZER_FUNCTION();
236
237 XCamReturn ret = XCAM_RETURN_NO_ERROR;
238
239 RkAiqAlgoPreAcnr* auvnr_pre_int = (RkAiqAlgoPreAcnr*)mPreInParam;
240 RkAiqAlgoPreResAcnr* auvnr_pre_res_int = (RkAiqAlgoPreResAcnr*)mPreOutParam;
241
242 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
243 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
244 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
245
246 ret = RkAiqHandle::preProcess();
247 if (ret) {
248 RKAIQCORE_CHECK_RET(ret, "auvnr handle preProcess failed");
249 }
250
251 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
252 ret = des->pre_process(mPreInParam, mPreOutParam);
253 RKAIQCORE_CHECK_RET(ret, "auvnr algo pre_process failed");
254
255 EXIT_ANALYZER_FUNCTION();
256 return XCAM_RETURN_NO_ERROR;
257 }
258
processing()259 XCamReturn RkAiqAcnrHandleInt::processing() {
260 ENTER_ANALYZER_FUNCTION();
261
262 XCamReturn ret = XCAM_RETURN_NO_ERROR;
263
264 RkAiqAlgoProcAcnr* auvnr_proc_int = (RkAiqAlgoProcAcnr*)mProcInParam;
265 RkAiqAlgoProcResAcnr* auvnr_proc_res_int = (RkAiqAlgoProcResAcnr*)mProcOutParam;
266
267 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
268 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
269 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
270
271 auvnr_proc_res_int->stAuvnrProcResult.stFix = &shared->fullParams->mUvnrParams->data()->result;
272
273 ret = RkAiqHandle::processing();
274 if (ret) {
275 RKAIQCORE_CHECK_RET(ret, "auvnr handle processing failed");
276 }
277
278 // TODO: fill procParam
279 auvnr_proc_int->iso = sharedCom->iso;
280 auvnr_proc_int->hdr_mode = sharedCom->working_mode;
281
282 #ifdef DISABLE_HANDLE_ATTRIB
283 mCfgMutex.lock();
284 #endif
285 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
286 ret = des->processing(mProcInParam, mProcOutParam);
287 #ifdef DISABLE_HANDLE_ATTRIB
288 mCfgMutex.unlock();
289 #endif
290 RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
291
292 EXIT_ANALYZER_FUNCTION();
293 return ret;
294 }
295
postProcess()296 XCamReturn RkAiqAcnrHandleInt::postProcess() {
297 ENTER_ANALYZER_FUNCTION();
298
299 XCamReturn ret = XCAM_RETURN_NO_ERROR;
300
301 RkAiqAlgoPostAcnr* auvnr_post_int = (RkAiqAlgoPostAcnr*)mPostInParam;
302 RkAiqAlgoPostResAcnr* auvnr_post_res_int = (RkAiqAlgoPostResAcnr*)mPostOutParam;
303
304 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
305 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
306 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
307
308 ret = RkAiqHandle::postProcess();
309 if (ret) {
310 RKAIQCORE_CHECK_RET(ret, "auvnr handle postProcess failed");
311 return ret;
312 }
313
314 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
315 ret = des->post_process(mPostInParam, mPostOutParam);
316 RKAIQCORE_CHECK_RET(ret, "auvnr algo post_process failed");
317
318 EXIT_ANALYZER_FUNCTION();
319 return ret;
320 }
321
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)322 XCamReturn RkAiqAcnrHandleInt::genIspResult(RkAiqFullParams* params, 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 RkAiqAlgoProcResAcnr* acnr_com = (RkAiqAlgoProcResAcnr*)mProcOutParam;
330
331 if (!acnr_com) {
332 LOGD_ANALYZER("no asharp result");
333 return XCAM_RETURN_NO_ERROR;
334 }
335
336 if (!this->getAlgoId()) {
337 RkAiqAlgoProcResAcnr* acnr_rk = (RkAiqAlgoProcResAcnr*)acnr_com;
338
339 if (params->mUvnrParams.ptr()) {
340 rk_aiq_isp_uvnr_params_v20_t* cnr_param = params->mUvnrParams->data().ptr();
341 LOGD_ANR("oyyf: %s:%d output ispp param start\n", __FUNCTION__, __LINE__);
342
343 if (sharedCom->init) {
344 cnr_param->frame_id = 0;
345 } else {
346 cnr_param->frame_id = shared->frameId;
347 }
348
349 if (acnr_rk->res_com.cfg_update) {
350 mSyncFlag = shared->frameId;
351 cnr_param->sync_flag = mSyncFlag;
352 // copy from algo result
353 // set as the latest result
354 cur_params->mUvnrParams = params->mUvnrParams;
355 cnr_param->is_update = true;
356 LOGD_ANR("[%d] params from algo", mSyncFlag);
357 } else if (mSyncFlag != cnr_param->sync_flag) {
358 cnr_param->sync_flag = mSyncFlag;
359 // copy from latest result
360 if (cur_params->mUvnrParams.ptr()) {
361 cnr_param->result = cur_params->mUvnrParams->data()->result;
362 cnr_param->is_update = true;
363 } else {
364 LOGE_ANR("no latest params !");
365 cnr_param->is_update = false;
366 }
367 LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
368 } else {
369 // do nothing, result in buf needn't update
370 cnr_param->is_update = false;
371 LOGD_ANR("[%d] params needn't update", shared->frameId);
372 }
373 }
374 LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
375 }
376
377 EXIT_ANALYZER_FUNCTION();
378
379 return ret;
380 }
381
382 } // namespace RkCam
383