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 "RkAiqAynrHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAynrHandleInt);
23
init()24 void RkAiqAynrHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAynr());
29 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAynr());
30 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAynr());
31 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAynr());
32 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAynr());
33 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAynr());
34 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAynr());
35
36 EXIT_ANALYZER_FUNCTION();
37 }
38
updateConfig(bool needSync)39 XCamReturn RkAiqAynrHandleInt::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_aynr_SetAttrib_v1(mAlgoCtx, &mCurAtt, false);
51 sendSignal();
52 }
53
54 if (updateIQpara) {
55 mCurIQPara = mNewIQPara;
56 updateIQpara = false;
57 // TODO
58 rk_aiq_uapi_aynr_SetIQPara_v1(mAlgoCtx, &mCurIQPara, false);
59 sendSignal();
60 }
61
62 if (updateJsonpara) {
63 mCurJsonPara = mNewJsonPara;
64 updateJsonpara = false;
65 // TODO
66 rk_aiq_uapi_aynr_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_ynr_attrib_v1_t * att)77 XCamReturn RkAiqAynrHandleInt::setAttrib(rk_aiq_ynr_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_aynr_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_ynr_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_ynr_attrib_v1_t * att)105 XCamReturn RkAiqAynrHandleInt::getAttrib(rk_aiq_ynr_attrib_v1_t* att) {
106 ENTER_ANALYZER_FUNCTION();
107
108 XCamReturn ret = XCAM_RETURN_NO_ERROR;
109
110 rk_aiq_uapi_aynr_GetAttrib_v1(mAlgoCtx, att);
111
112 EXIT_ANALYZER_FUNCTION();
113 return ret;
114 }
115
setIQPara(rk_aiq_ynr_IQPara_V1_t * para)116 XCamReturn RkAiqAynrHandleInt::setIQPara(rk_aiq_ynr_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_aynr_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_ynr_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_ynr_IQPara_V1_t * para)144 XCamReturn RkAiqAynrHandleInt::getIQPara(rk_aiq_ynr_IQPara_V1_t* para) {
145 ENTER_ANALYZER_FUNCTION();
146
147 XCamReturn ret = XCAM_RETURN_NO_ERROR;
148
149 rk_aiq_uapi_aynr_GetIQPara_v1(mAlgoCtx, para);
150
151 EXIT_ANALYZER_FUNCTION();
152 return ret;
153 }
154
setJsonPara(rk_aiq_ynr_JsonPara_V1_t * para)155 XCamReturn RkAiqAynrHandleInt::setJsonPara(rk_aiq_ynr_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_aynr_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_ynr_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_ynr_JsonPara_V1_t * para)183 XCamReturn RkAiqAynrHandleInt::getJsonPara(rk_aiq_ynr_JsonPara_V1_t* para) {
184 ENTER_ANALYZER_FUNCTION();
185
186 XCamReturn ret = XCAM_RETURN_NO_ERROR;
187
188 rk_aiq_uapi_aynr_GetJsonPara_v1(mAlgoCtx, para);
189
190 EXIT_ANALYZER_FUNCTION();
191 return ret;
192 }
193
setStrength(float fPercent)194 XCamReturn RkAiqAynrHandleInt::setStrength(float fPercent) {
195 ENTER_ANALYZER_FUNCTION();
196
197 XCamReturn ret = XCAM_RETURN_NO_ERROR;
198
199 rk_aiq_uapi_aynr_SetLumaSFStrength_v1(mAlgoCtx, fPercent);
200
201 EXIT_ANALYZER_FUNCTION();
202 return ret;
203 }
204
getStrength(float * pPercent)205 XCamReturn RkAiqAynrHandleInt::getStrength(float* pPercent) {
206 ENTER_ANALYZER_FUNCTION();
207
208 XCamReturn ret = XCAM_RETURN_NO_ERROR;
209
210 rk_aiq_uapi_aynr_GetLumaSFStrength_v1(mAlgoCtx, pPercent);
211
212 EXIT_ANALYZER_FUNCTION();
213 return ret;
214 }
215
prepare()216 XCamReturn RkAiqAynrHandleInt::prepare() {
217 ENTER_ANALYZER_FUNCTION();
218
219 XCamReturn ret = XCAM_RETURN_NO_ERROR;
220
221 ret = RkAiqHandle::prepare();
222 RKAIQCORE_CHECK_RET(ret, "aynr handle prepare failed");
223
224 RkAiqAlgoConfigAynr* aynr_config_int = (RkAiqAlgoConfigAynr*)mConfig;
225
226 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
227 ret = des->prepare(mConfig);
228 RKAIQCORE_CHECK_RET(ret, "aynr algo prepare failed");
229
230 EXIT_ANALYZER_FUNCTION();
231 return XCAM_RETURN_NO_ERROR;
232 }
233
preProcess()234 XCamReturn RkAiqAynrHandleInt::preProcess() {
235 ENTER_ANALYZER_FUNCTION();
236
237 XCamReturn ret = XCAM_RETURN_NO_ERROR;
238
239 RkAiqAlgoPreAynr* aynr_pre_int = (RkAiqAlgoPreAynr*)mPreInParam;
240 RkAiqAlgoPreResAynr* aynr_pre_res_int = (RkAiqAlgoPreResAynr*)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, "aynr handle preProcess failed");
249 }
250
251 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
252 ret = des->pre_process(mPreInParam, mPreOutParam);
253 RKAIQCORE_CHECK_RET(ret, "aynr algo pre_process failed");
254
255 EXIT_ANALYZER_FUNCTION();
256 return XCAM_RETURN_NO_ERROR;
257 }
258
processing()259 XCamReturn RkAiqAynrHandleInt::processing() {
260 ENTER_ANALYZER_FUNCTION();
261
262 XCamReturn ret = XCAM_RETURN_NO_ERROR;
263
264 RkAiqAlgoProcAynr* aynr_proc_int = (RkAiqAlgoProcAynr*)mProcInParam;
265 RkAiqAlgoProcResAynr* aynr_proc_res_int = (RkAiqAlgoProcResAynr*)mProcOutParam;
266
267 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
268 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
269 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
270
271 ret = RkAiqHandle::processing();
272 if (ret) {
273 RKAIQCORE_CHECK_RET(ret, "aynr handle processing failed");
274 }
275
276 // TODO: fill procParam
277 aynr_proc_int->iso = sharedCom->iso;
278 aynr_proc_int->hdr_mode = sharedCom->working_mode;
279
280 #ifdef DISABLE_HANDLE_ATTRIB
281 mCfgMutex.lock();
282 #endif
283 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
284 ret = des->processing(mProcInParam, mProcOutParam);
285 #ifdef DISABLE_HANDLE_ATTRIB
286 mCfgMutex.unlock();
287 #endif
288 RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
289
290 EXIT_ANALYZER_FUNCTION();
291 return ret;
292 }
293
postProcess()294 XCamReturn RkAiqAynrHandleInt::postProcess() {
295 ENTER_ANALYZER_FUNCTION();
296
297 XCamReturn ret = XCAM_RETURN_NO_ERROR;
298
299 RkAiqAlgoPostAynr* aynr_post_int = (RkAiqAlgoPostAynr*)mPostInParam;
300 RkAiqAlgoPostResAynr* aynr_post_res_int = (RkAiqAlgoPostResAynr*)mPostOutParam;
301
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 return ret;
318 }
319
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)320 XCamReturn RkAiqAynrHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
321 ENTER_ANALYZER_FUNCTION();
322
323 XCamReturn ret = XCAM_RETURN_NO_ERROR;
324 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
325 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
326 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
327 RkAiqAlgoProcResAynr* aynr_com = (RkAiqAlgoProcResAynr*)mProcOutParam;
328
329 if (!aynr_com) {
330 LOGD_ANALYZER("no asharp result");
331 return XCAM_RETURN_NO_ERROR;
332 }
333
334 if (!this->getAlgoId()) {
335 RkAiqAlgoProcResAynr* aynr_rk = (RkAiqAlgoProcResAynr*)aynr_com;
336
337 if (params->mYnrParams.ptr()) {
338 rk_aiq_isp_ynr_params_v20_t* ynr_param = params->mYnrParams->data().ptr();
339 LOGD_ANR("oyyf: %s:%d output ispp param start\n", __FUNCTION__, __LINE__);
340
341 if (sharedCom->init) {
342 ynr_param->frame_id = 0;
343 } else {
344 ynr_param->frame_id = shared->frameId;
345 }
346 memcpy(&ynr_param->result, &aynr_rk->stAynrProcResult.stFix, sizeof(RK_YNR_Fix_V1_t));
347 }
348 LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
349 }
350
351 cur_params->mYnrParams = params->mYnrParams;
352
353 EXIT_ANALYZER_FUNCTION();
354
355 return ret;
356 }
357
358 } // namespace RkCam
359