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