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 "RkAiqAynrV2Handle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAynrV2HandleInt);
23
init()24 void RkAiqAynrV2HandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAynrV2());
29 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAynrV2());
30 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAynrV2());
31 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAynrV2());
32 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAynrV2());
33 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAynrV2());
34 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAynrV2());
35
36 EXIT_ANALYZER_FUNCTION();
37 }
38
updateConfig(bool needSync)39 XCamReturn RkAiqAynrV2HandleInt::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_aynrV2_SetAttrib(mAlgoCtx, &mCurAtt, false);
51 sendSignal();
52 }
53
54 if (updateIQpara) {
55 mCurIQPara = mNewIQPara;
56 updateIQpara = false;
57 // TODO
58 // rk_aiq_uapi_asharp_SetIQpara_V3(mAlgoCtx, &mCurIQPara, false);
59 sendSignal();
60 }
61
62 if (updateStrength) {
63 mCurStrength = mNewStrength;
64 updateStrength = false;
65 rk_aiq_uapi_aynrV2_SetLumaSFStrength(mAlgoCtx, mCurStrength);
66 sendSignal();
67 }
68
69 if (needSync) mCfgMutex.unlock();
70 #endif
71
72 EXIT_ANALYZER_FUNCTION();
73 return ret;
74 }
75
setAttrib(rk_aiq_ynr_attrib_v2_t * att)76 XCamReturn RkAiqAynrV2HandleInt::setAttrib(rk_aiq_ynr_attrib_v2_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_aynrV2_SetAttrib(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_ynr_attrib_v2_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_ynr_attrib_v2_t * att)104 XCamReturn RkAiqAynrV2HandleInt::getAttrib(rk_aiq_ynr_attrib_v2_t* att) {
105 ENTER_ANALYZER_FUNCTION();
106
107 XCamReturn ret = XCAM_RETURN_NO_ERROR;
108
109 rk_aiq_uapi_aynrV2_GetAttrib(mAlgoCtx, att);
110
111 EXIT_ANALYZER_FUNCTION();
112 return ret;
113 }
114
setIQPara(rk_aiq_ynr_IQPara_V2_t * para)115 XCamReturn RkAiqAynrV2HandleInt::setIQPara(rk_aiq_ynr_IQPara_V2_t* para) {
116 ENTER_ANALYZER_FUNCTION();
117
118 XCamReturn ret = XCAM_RETURN_NO_ERROR;
119 mCfgMutex.lock();
120 #ifdef DISABLE_HANDLE_ATTRIB
121 // TODO
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_ynr_IQPara_V2_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_ynr_IQPara_V2_t * para)143 XCamReturn RkAiqAynrV2HandleInt::getIQPara(rk_aiq_ynr_IQPara_V2_t* para) {
144 ENTER_ANALYZER_FUNCTION();
145
146 XCamReturn ret = XCAM_RETURN_NO_ERROR;
147
148 // rk_aiq_uapi_asharp_GetIQpara(mAlgoCtx, para);
149
150 EXIT_ANALYZER_FUNCTION();
151 return ret;
152 }
153
setStrength(float fPercent)154 XCamReturn RkAiqAynrV2HandleInt::setStrength(float fPercent) {
155 ENTER_ANALYZER_FUNCTION();
156
157 XCamReturn ret = XCAM_RETURN_NO_ERROR;
158 mCfgMutex.lock();
159 #ifdef DISABLE_HANDLE_ATTRIB
160 ret = rk_aiq_uapi_aynrV2_SetLumaSFStrength(mAlgoCtx, fPercent);
161 #else
162
163 mNewStrength = fPercent;
164 updateStrength = true;
165 waitSignal();
166 #endif
167
168 mCfgMutex.unlock();
169 EXIT_ANALYZER_FUNCTION();
170 return ret;
171 }
172
getStrength(float * pPercent)173 XCamReturn RkAiqAynrV2HandleInt::getStrength(float* pPercent) {
174 ENTER_ANALYZER_FUNCTION();
175
176 XCamReturn ret = XCAM_RETURN_NO_ERROR;
177
178 rk_aiq_uapi_aynrV2_GetLumaSFStrength(mAlgoCtx, pPercent);
179
180 EXIT_ANALYZER_FUNCTION();
181 return ret;
182 }
183
prepare()184 XCamReturn RkAiqAynrV2HandleInt::prepare() {
185 ENTER_ANALYZER_FUNCTION();
186
187 XCamReturn ret = XCAM_RETURN_NO_ERROR;
188
189 ret = RkAiqHandle::prepare();
190 RKAIQCORE_CHECK_RET(ret, "aynr handle prepare failed");
191
192 RkAiqAlgoConfigAynrV2* aynr_config_int = (RkAiqAlgoConfigAynrV2*)mConfig;
193
194 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
195
196 aynr_config_int->stAynrConfig.rawWidth = sharedCom->snsDes.isp_acq_width;
197 aynr_config_int->stAynrConfig.rawHeight = sharedCom->snsDes.isp_acq_height;
198 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
199 ret = des->prepare(mConfig);
200 RKAIQCORE_CHECK_RET(ret, "aynr algo prepare failed");
201
202 EXIT_ANALYZER_FUNCTION();
203 return XCAM_RETURN_NO_ERROR;
204 }
205
preProcess()206 XCamReturn RkAiqAynrV2HandleInt::preProcess() {
207 ENTER_ANALYZER_FUNCTION();
208
209 XCamReturn ret = XCAM_RETURN_NO_ERROR;
210
211 RkAiqAlgoPreAynrV2* aynr_pre_int = (RkAiqAlgoPreAynrV2*)mPreInParam;
212 RkAiqAlgoPreResAynrV2* aynr_pre_res_int = (RkAiqAlgoPreResAynrV2*)mPreOutParam;
213 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
214 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
215 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
216
217 ret = RkAiqHandle::preProcess();
218 if (ret) {
219 RKAIQCORE_CHECK_RET(ret, "aynr handle preProcess failed");
220 }
221
222 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
223 ret = des->pre_process(mPreInParam, mPreOutParam);
224 RKAIQCORE_CHECK_RET(ret, "aynr algo pre_process failed");
225
226 EXIT_ANALYZER_FUNCTION();
227 return XCAM_RETURN_NO_ERROR;
228 }
229
processing()230 XCamReturn RkAiqAynrV2HandleInt::processing() {
231 ENTER_ANALYZER_FUNCTION();
232
233 XCamReturn ret = XCAM_RETURN_NO_ERROR;
234
235 RkAiqAlgoProcAynrV2* aynr_proc_int = (RkAiqAlgoProcAynrV2*)mProcInParam;
236 RkAiqAlgoProcResAynrV2* aynr_proc_res_int = (RkAiqAlgoProcResAynrV2*)mProcOutParam;
237 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
238 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
239 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
240
241 aynr_proc_res_int->stAynrProcResult.stFix = &shared->fullParams->mYnrV21Params->data()->result;
242
243 ret = RkAiqHandle::processing();
244 if (ret) {
245 RKAIQCORE_CHECK_RET(ret, "aynr handle processing failed");
246 }
247
248 // TODO: fill procParam
249 aynr_proc_int->iso = sharedCom->iso;
250 aynr_proc_int->hdr_mode = sharedCom->working_mode;
251
252 #ifdef DISABLE_HANDLE_ATTRIB
253 mCfgMutex.lock();
254 #endif
255 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
256 ret = des->processing(mProcInParam, mProcOutParam);
257 #ifdef DISABLE_HANDLE_ATTRIB
258 mCfgMutex.unlock();
259 #endif
260 RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
261
262 EXIT_ANALYZER_FUNCTION();
263 return ret;
264 }
265
postProcess()266 XCamReturn RkAiqAynrV2HandleInt::postProcess() {
267 ENTER_ANALYZER_FUNCTION();
268
269 XCamReturn ret = XCAM_RETURN_NO_ERROR;
270
271 RkAiqAlgoPostAynrV2* aynr_post_int = (RkAiqAlgoPostAynrV2*)mPostInParam;
272 RkAiqAlgoPostResAynrV2* aynr_post_res_int = (RkAiqAlgoPostResAynrV2*)mPostOutParam;
273 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
274 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
275 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
276
277 ret = RkAiqHandle::postProcess();
278 if (ret) {
279 RKAIQCORE_CHECK_RET(ret, "aynr handle postProcess failed");
280 return ret;
281 }
282
283 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
284 ret = des->post_process(mPostInParam, mPostOutParam);
285 RKAIQCORE_CHECK_RET(ret, "aynr algo post_process failed");
286
287 EXIT_ANALYZER_FUNCTION();
288 return ret;
289 }
290
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)291 XCamReturn RkAiqAynrV2HandleInt::genIspResult(RkAiqFullParams* params,
292 RkAiqFullParams* cur_params) {
293 ENTER_ANALYZER_FUNCTION();
294
295 XCamReturn ret = XCAM_RETURN_NO_ERROR;
296 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
297 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
298 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
299 RkAiqAlgoProcResAynrV2* aynr_rk = (RkAiqAlgoProcResAynrV2*)mProcOutParam;
300
301 if (!aynr_rk) {
302 LOGD_ANALYZER("no aynr result");
303 return XCAM_RETURN_NO_ERROR;
304 }
305
306 if (!this->getAlgoId()) {
307 LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
308
309 rk_aiq_isp_ynr_params_v21_t* ynr_param = params->mYnrV21Params->data().ptr();
310 if (sharedCom->init) {
311 ynr_param->frame_id = 0;
312 } else {
313 ynr_param->frame_id = shared->frameId;
314 }
315
316 if (aynr_rk->res_com.cfg_update) {
317 mSyncFlag = shared->frameId;
318 ynr_param->sync_flag = mSyncFlag;
319 // copy from algo result
320 cur_params->mYnrV21Params = params->mYnrV21Params;
321 ynr_param->is_update = true;
322 LOGD_ANR("[%d] params from algo", mSyncFlag);
323 } else if (mSyncFlag != ynr_param->sync_flag) {
324 ynr_param->sync_flag = mSyncFlag;
325 // copy from latest result
326 if (cur_params->mYnrV21Params.ptr()) {
327 ynr_param->result = cur_params->mYnrV21Params->data()->result;
328 ynr_param->is_update = true;
329 } else {
330 LOGE_ANR("no latest params !");
331 ynr_param->is_update = false;
332 }
333 LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
334 } else {
335 // do nothing, result in buf needn't update
336 ynr_param->is_update = false;
337 LOGD_ANR("[%d] params needn't update", shared->frameId);
338 }
339 LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
340 }
341
342 EXIT_ANALYZER_FUNCTION();
343
344 return ret;
345 }
346
347 } // namespace RkCam
348