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 "RkAiqAcnrV1Handle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAcnrV1HandleInt);
23
init()24 void RkAiqAcnrV1HandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAcnrV1());
29 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAcnrV1());
30 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAcnrV1());
31 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAcnrV1());
32 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAcnrV1());
33 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAcnrV1());
34 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAcnrV1());
35
36 EXIT_ANALYZER_FUNCTION();
37 }
38
updateConfig(bool needSync)39 XCamReturn RkAiqAcnrV1HandleInt::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_acnrV1_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_acnrV1_SetChromaSFStrength(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_cnr_attrib_v1_t * att)76 XCamReturn RkAiqAcnrV1HandleInt::setAttrib(rk_aiq_cnr_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_acnrV1_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_cnr_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_cnr_attrib_v1_t * att)104 XCamReturn RkAiqAcnrV1HandleInt::getAttrib(rk_aiq_cnr_attrib_v1_t* att) {
105 ENTER_ANALYZER_FUNCTION();
106
107 XCamReturn ret = XCAM_RETURN_NO_ERROR;
108
109 rk_aiq_uapi_acnrV1_GetAttrib(mAlgoCtx, att);
110
111 EXIT_ANALYZER_FUNCTION();
112 return ret;
113 }
114
setIQPara(rk_aiq_cnr_IQPara_V1_t * para)115 XCamReturn RkAiqAcnrV1HandleInt::setIQPara(rk_aiq_cnr_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 //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_cnr_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_cnr_IQPara_V1_t * para)143 XCamReturn RkAiqAcnrV1HandleInt::getIQPara(rk_aiq_cnr_IQPara_V1_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 RkAiqAcnrV1HandleInt::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_acnrV1_SetChromaSFStrength(mAlgoCtx, fPercent);
161 #else
162 mNewStrength = fPercent;
163 updateStrength = true;
164 waitSignal();
165 #endif
166
167 mCfgMutex.unlock();
168
169 EXIT_ANALYZER_FUNCTION();
170
171 return ret;
172 }
173
getStrength(float * pPercent)174 XCamReturn RkAiqAcnrV1HandleInt::getStrength(float* pPercent) {
175 ENTER_ANALYZER_FUNCTION();
176
177 XCamReturn ret = XCAM_RETURN_NO_ERROR;
178
179 rk_aiq_uapi_acnrV1_GetChromaSFStrength(mAlgoCtx, pPercent);
180
181 EXIT_ANALYZER_FUNCTION();
182 return ret;
183 }
184
prepare()185 XCamReturn RkAiqAcnrV1HandleInt::prepare() {
186 ENTER_ANALYZER_FUNCTION();
187
188 XCamReturn ret = XCAM_RETURN_NO_ERROR;
189
190 ret = RkAiqHandle::prepare();
191 RKAIQCORE_CHECK_RET(ret, "acnr handle prepare failed");
192
193 RkAiqAlgoConfigAcnrV1* acnr_config_int = (RkAiqAlgoConfigAcnrV1*)mConfig;
194
195 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
196 ret = des->prepare(mConfig);
197 RKAIQCORE_CHECK_RET(ret, "acnr algo prepare failed");
198
199 EXIT_ANALYZER_FUNCTION();
200 return XCAM_RETURN_NO_ERROR;
201 }
202
preProcess()203 XCamReturn RkAiqAcnrV1HandleInt::preProcess() {
204 ENTER_ANALYZER_FUNCTION();
205
206 XCamReturn ret = XCAM_RETURN_NO_ERROR;
207
208 RkAiqAlgoPreAcnrV1* acnr_pre_int = (RkAiqAlgoPreAcnrV1*)mPreInParam;
209 RkAiqAlgoPreResAcnrV1* acnr_pre_res_int = (RkAiqAlgoPreResAcnrV1*)mPreOutParam;
210 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
211 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
212 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
213
214 ret = RkAiqHandle::preProcess();
215 if (ret) {
216 RKAIQCORE_CHECK_RET(ret, "acnr handle preProcess failed");
217 }
218
219 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
220 ret = des->pre_process(mPreInParam, mPreOutParam);
221 RKAIQCORE_CHECK_RET(ret, "acnr algo pre_process failed");
222
223 EXIT_ANALYZER_FUNCTION();
224 return XCAM_RETURN_NO_ERROR;
225 }
226
processing()227 XCamReturn RkAiqAcnrV1HandleInt::processing() {
228 ENTER_ANALYZER_FUNCTION();
229
230 XCamReturn ret = XCAM_RETURN_NO_ERROR;
231
232 RkAiqAlgoProcAcnrV1* acnr_proc_int = (RkAiqAlgoProcAcnrV1*)mProcInParam;
233 RkAiqAlgoProcResAcnrV1* acnr_proc_res_int = (RkAiqAlgoProcResAcnrV1*)mProcOutParam;
234 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
235 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
236 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
237
238 acnr_proc_res_int->stAcnrProcResult.stFix = &shared->fullParams->mCnrV21Params->data()->result;
239
240 ret = RkAiqHandle::processing();
241 if (ret) {
242 RKAIQCORE_CHECK_RET(ret, "acnr handle processing failed");
243 }
244
245 // TODO: fill procParam
246 acnr_proc_int->iso = sharedCom->iso;
247 acnr_proc_int->hdr_mode = sharedCom->working_mode;
248
249 #ifdef DISABLE_HANDLE_ATTRIB
250 mCfgMutex.lock();
251 #endif
252 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
253 ret = des->processing(mProcInParam, mProcOutParam);
254 #ifdef DISABLE_HANDLE_ATTRIB
255 mCfgMutex.unlock();
256 #endif
257 RKAIQCORE_CHECK_RET(ret, "aynr algo processing failed");
258
259 EXIT_ANALYZER_FUNCTION();
260 return ret;
261 }
262
postProcess()263 XCamReturn RkAiqAcnrV1HandleInt::postProcess() {
264 ENTER_ANALYZER_FUNCTION();
265
266 XCamReturn ret = XCAM_RETURN_NO_ERROR;
267
268 RkAiqAlgoPostAcnrV1* acnr_post_int = (RkAiqAlgoPostAcnrV1*)mPostInParam;
269 RkAiqAlgoPostResAcnrV1* acnr_post_res_int = (RkAiqAlgoPostResAcnrV1*)mPostOutParam;
270 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
271 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
272 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
273
274 ret = RkAiqHandle::postProcess();
275 if (ret) {
276 RKAIQCORE_CHECK_RET(ret, "acnr handle postProcess failed");
277 return ret;
278 }
279
280 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
281 ret = des->post_process(mPostInParam, mPostOutParam);
282 RKAIQCORE_CHECK_RET(ret, "acnr algo post_process failed");
283
284 EXIT_ANALYZER_FUNCTION();
285 return ret;
286 }
287
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)288 XCamReturn RkAiqAcnrV1HandleInt::genIspResult(RkAiqFullParams* params,
289 RkAiqFullParams* cur_params) {
290 ENTER_ANALYZER_FUNCTION();
291
292 XCamReturn ret = XCAM_RETURN_NO_ERROR;
293 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
294 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
295 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
296 RkAiqAlgoProcResAcnrV1* acnr_rk = (RkAiqAlgoProcResAcnrV1*)mProcOutParam;
297
298 if (!acnr_rk) {
299 LOGD_ANALYZER("no aynr result");
300 return XCAM_RETURN_NO_ERROR;
301 }
302
303 if (!this->getAlgoId()) {
304 LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
305 rk_aiq_isp_cnr_params_v21_t* cnr_param = params->mCnrV21Params->data().ptr();
306 if (sharedCom->init) {
307 cnr_param->frame_id = 0;
308 } else {
309 cnr_param->frame_id = shared->frameId;
310 }
311
312 if (acnr_rk->res_com.cfg_update) {
313 mSyncFlag = shared->frameId;
314 cnr_param->sync_flag = mSyncFlag;
315 // copy from algo result
316 // set as the latest result
317 cur_params->mCnrV21Params = params->mCnrV21Params;
318 cnr_param->is_update = true;
319 LOGD_ANR("[%d] params from algo", mSyncFlag);
320 } else if (mSyncFlag != cnr_param->sync_flag) {
321 cnr_param->sync_flag = mSyncFlag;
322 // copy from latest result
323 if (cur_params->mCnrV21Params.ptr()) {
324 cnr_param->result = cur_params->mCnrV21Params->data()->result;
325 cnr_param->is_update = true;
326 } else {
327 LOGE_ANR("no latest params !");
328 cnr_param->is_update = false;
329 }
330 LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
331 } else {
332 // do nothing, result in buf needn't update
333 cnr_param->is_update = false;
334 LOGD_ANR("[%d] params needn't update", shared->frameId);
335 }
336 LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
337 }
338
339 EXIT_ANALYZER_FUNCTION();
340
341 return ret;
342 }
343
344 } // namespace RkCam
345