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 "RkAiqAldchHandle.h"
17
18 #include "RkAiqCore.h"
19 #if (RKAIQ_HAVE_LDCH_V21)
20 #include "aldch/rk_aiq_types_aldch_algo_prvt.h"
21 #endif
22
23 namespace RkCam {
24
25 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAldchHandleInt);
26
init()27 void RkAiqAldchHandleInt::init() {
28 ENTER_ANALYZER_FUNCTION();
29
30 RkAiqHandle::deInit();
31 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAldch());
32 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAldch());
33 #if (RKAIQ_HAVE_LDCH_V21)
34 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAldchV21());
35 #else
36 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAldch());
37 #endif
38
39 EXIT_ANALYZER_FUNCTION();
40 }
41
prepare()42 XCamReturn RkAiqAldchHandleInt::prepare() {
43 ENTER_ANALYZER_FUNCTION();
44
45 XCamReturn ret = XCAM_RETURN_NO_ERROR;
46
47 ret = RkAiqHandle::prepare();
48 RKAIQCORE_CHECK_RET(ret, "aldch handle prepare failed");
49
50 RkAiqAlgoConfigAldch* aldch_config_int = (RkAiqAlgoConfigAldch*)mConfig;
51 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
52
53 // memcpy(&aldch_config_int->aldch_calib_cfg, &shared->calib->aldch, sizeof(CalibDb_LDCH_t));
54 aldch_config_int->resource_path = sharedCom->resourcePath;
55 aldch_config_int->mem_ops_ptr = mAiqCore->mShareMemOps;
56 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
57 ret = des->prepare(mConfig);
58 RKAIQCORE_CHECK_RET(ret, "aldch algo prepare failed");
59
60 EXIT_ANALYZER_FUNCTION();
61 return XCAM_RETURN_NO_ERROR;
62 }
63
preProcess()64 XCamReturn RkAiqAldchHandleInt::preProcess() {
65 ENTER_ANALYZER_FUNCTION();
66
67 XCamReturn ret = XCAM_RETURN_NO_ERROR;
68 #if 0
69 RkAiqAlgoPreAldch* aldch_pre_int = (RkAiqAlgoPreAldch*)mPreInParam;
70 RkAiqAlgoPreResAldch* aldch_pre_res_int = (RkAiqAlgoPreResAldch*)mPreOutParam;
71 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
72 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
73 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
74
75 ret = RkAiqHandle::preProcess();
76 if (ret) {
77 RKAIQCORE_CHECK_RET(ret, "aldch handle preProcess failed");
78 }
79
80 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
81 ret = des->pre_process(mPreInParam, mPreOutParam);
82 RKAIQCORE_CHECK_RET(ret, "aldch algo pre_process failed");
83
84 EXIT_ANALYZER_FUNCTION();
85 #endif
86 return XCAM_RETURN_NO_ERROR;
87 }
88
processing()89 XCamReturn RkAiqAldchHandleInt::processing() {
90 ENTER_ANALYZER_FUNCTION();
91
92 XCamReturn ret = XCAM_RETURN_NO_ERROR;
93
94 RkAiqAlgoProcAldch* aldch_proc_int = (RkAiqAlgoProcAldch*)mProcInParam;
95 #if (RKAIQ_HAVE_LDCH_V21)
96 RkAiqAlgoProcResAldchV21* aldch_proc_res_int = (RkAiqAlgoProcResAldchV21*)mProcOutParam;
97 #else
98 RkAiqAlgoProcResAldch* aldch_proc_res_int = (RkAiqAlgoProcResAldch*)mProcOutParam;
99 #endif
100 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
101 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
102 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
103
104 #if (RKAIQ_HAVE_LDCH_V21)
105 aldch_proc_res_int->ldch_result = &shared->fullParams->mLdchV32Params->data()->result;
106 #else
107 aldch_proc_res_int->ldch_result = &shared->fullParams->mLdchParams->data()->result;
108 #endif
109
110 ret = RkAiqHandle::processing();
111 if (ret) {
112 RKAIQCORE_CHECK_RET(ret, "aldch handle processing failed");
113 }
114
115 #ifdef DISABLE_HANDLE_ATTRIB
116 mCfgMutex.lock();
117 #endif
118 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
119 ret = des->processing(mProcInParam, mProcOutParam);
120 #ifdef DISABLE_HANDLE_ATTRIB
121 mCfgMutex.unlock();
122 #endif
123 RKAIQCORE_CHECK_RET(ret, "aldch algo processing failed");
124
125 EXIT_ANALYZER_FUNCTION();
126 return ret;
127 }
128
postProcess()129 XCamReturn RkAiqAldchHandleInt::postProcess() {
130 ENTER_ANALYZER_FUNCTION();
131
132 XCamReturn ret = XCAM_RETURN_NO_ERROR;
133 #if 0
134 RkAiqAlgoPostAldch* aldch_post_int = (RkAiqAlgoPostAldch*)mPostInParam;
135 RkAiqAlgoPostResAldch* aldch_post_res_int = (RkAiqAlgoPostResAldch*)mPostOutParam;
136 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
137 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
138 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
139
140 ret = RkAiqHandle::postProcess();
141 if (ret) {
142 RKAIQCORE_CHECK_RET(ret, "aldch handle postProcess failed");
143 return ret;
144 }
145
146 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
147 ret = des->post_process(mPostInParam, mPostOutParam);
148 RKAIQCORE_CHECK_RET(ret, "aldch algo post_process failed");
149
150 EXIT_ANALYZER_FUNCTION();
151 #endif
152 return ret;
153 }
154
updateConfig(bool needSync)155 XCamReturn RkAiqAldchHandleInt::updateConfig(bool needSync) {
156 ENTER_ANALYZER_FUNCTION();
157
158 XCamReturn ret = XCAM_RETURN_NO_ERROR;
159 #ifndef DISABLE_HANDLE_ATTRIB
160 if (needSync) mCfgMutex.lock();
161 // if something changed
162 if (updateAtt) {
163 mCurAtt = mNewAtt;
164 #if (RKAIQ_HAVE_LDCH_V21)
165 rk_aiq_uapi_aldch_v21_SetAttrib(mAlgoCtx, mCurAtt, false);
166 mCurAtt.lut.update_flag = false;
167 #else
168 rk_aiq_uapi_aldch_SetAttrib(mAlgoCtx, mCurAtt, false);
169 #endif
170 updateAtt = false;
171 sendSignal(mCurAtt.sync.sync_mode);
172 }
173
174 if (needSync) mCfgMutex.unlock();
175 #endif
176
177 EXIT_ANALYZER_FUNCTION();
178 return ret;
179 }
180
181 #if (RKAIQ_HAVE_LDCH_V21)
setAttrib(const rk_aiq_ldch_v21_attrib_t * att)182 XCamReturn RkAiqAldchHandleInt::setAttrib(const rk_aiq_ldch_v21_attrib_t* att) {
183 ENTER_ANALYZER_FUNCTION();
184
185 XCamReturn ret = XCAM_RETURN_NO_ERROR;
186 mCfgMutex.lock();
187
188 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
189 // if something changed, set att to mNewAtt, and
190 // the new params will be effective later when updateConfig
191 // called by RkAiqCore
192 #ifdef DISABLE_HANDLE_ATTRIB
193 ret = rk_aiq_uapi_aldch_v21_SetAttrib(mAlgoCtx, *att, false);
194 #else
195 bool isChanged = false;
196 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
197 memcmp(&mNewAtt, att, sizeof(*att)))
198 isChanged = true;
199 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
200 memcmp(&mCurAtt, att, sizeof(*att)))
201 isChanged = true;
202
203 // if something changed
204 if (isChanged) {
205 mNewAtt = *att;
206 ret = copyLutFromExtBuffer(att);
207 updateAtt = true;
208 waitSignal(att->sync.sync_mode);
209 }
210 #endif
211
212 mCfgMutex.unlock();
213
214 EXIT_ANALYZER_FUNCTION();
215 return ret;
216 }
217
getAttrib(rk_aiq_ldch_v21_attrib_t * att)218 XCamReturn RkAiqAldchHandleInt::getAttrib(rk_aiq_ldch_v21_attrib_t* att) {
219 ENTER_ANALYZER_FUNCTION();
220 XCamReturn ret = XCAM_RETURN_NO_ERROR;
221 #ifdef DISABLE_HANDLE_ATTRIB
222 mCfgMutex.lock();
223 rk_aiq_uapi_aldch_v21_GetAttrib(mAlgoCtx, att);
224 mCfgMutex.unlock();
225 #else
226
227 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
228 mCfgMutex.lock();
229 rk_aiq_uapi_aldch_v21_GetAttrib(mAlgoCtx, att);
230 att->sync.done = true;
231 mCfgMutex.unlock();
232 } else {
233 if (updateAtt) {
234 memcpy(att, &mNewAtt, sizeof(mNewAtt));
235 att->sync.done = false;
236 } else {
237 rk_aiq_uapi_aldch_v21_GetAttrib(mAlgoCtx, att);
238 att->sync.sync_mode = mNewAtt.sync.sync_mode;
239 att->sync.done = true;
240 }
241 }
242 #endif
243
244 EXIT_ANALYZER_FUNCTION();
245 return ret;
246 }
247
copyLutFromExtBuffer(const rk_aiq_ldch_v21_attrib_t * att)248 XCamReturn RkAiqAldchHandleInt::copyLutFromExtBuffer(const rk_aiq_ldch_v21_attrib_t* att) {
249 XCamReturn ret = XCAM_RETURN_NO_ERROR;
250
251 if (!mAlgoCtx->hLDCH) {
252 LOGE_ALDCH("Ldch contex is NULL!");
253 return XCAM_RETURN_ERROR_FAILED;
254 }
255
256 if (att->update_lut_mode == RK_AIQ_LDCH_UPDATE_LUT_FROM_EXTERNAL_BUFFER && \
257 att->lut.update_flag) {
258 LDCHHandle_t ldchCtx = (LDCHHandle_t)mAlgoCtx->hLDCH;
259 if (!ldchCtx->_lutCache.ptr()) {
260 ldchCtx->_lutCache = new LutCache(att->lut.u.buffer.size);
261 } else if (att->lut.u.buffer.size != ldchCtx->_lutCache->GetSize()) {
262 ldchCtx->_lutCache.release();
263 ldchCtx->_lutCache = new LutCache(att->lut.u.buffer.size);
264 }
265
266 if (ldchCtx->_lutCache.ptr()) {
267 if (ldchCtx->_lutCache->GetBuffer()) {
268 memcpy(ldchCtx->_lutCache->GetBuffer(), att->lut.u.buffer.addr, att->lut.u.buffer.size);
269 }
270 } else {
271 LOGE_ALDCH("Failed to malloc ldch cache!");
272 return XCAM_RETURN_ERROR_MEM;
273 }
274 }
275
276 return ret;
277 }
278
279 #else
setAttrib(const rk_aiq_ldch_attrib_t * att)280 XCamReturn RkAiqAldchHandleInt::setAttrib(const rk_aiq_ldch_attrib_t* att) {
281 ENTER_ANALYZER_FUNCTION();
282
283 XCamReturn ret = XCAM_RETURN_NO_ERROR;
284 mCfgMutex.lock();
285
286 #ifdef DISABLE_HANDLE_ATTRIB
287 ret = rk_aiq_uapi_aldch_SetAttrib(mAlgoCtx, *att, false);
288 #else
289 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
290 // if something changed, set att to mNewAtt, and
291 // the new params will be effective later when updateConfig
292 // called by RkAiqCore
293 bool isChanged = false;
294 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
295 memcmp(&mNewAtt, att, sizeof(*att)))
296 isChanged = true;
297 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
298 memcmp(&mCurAtt, att, sizeof(*att)))
299 isChanged = true;
300
301 // if something changed
302 if (isChanged) {
303 mNewAtt = *att;
304 updateAtt = true;
305 waitSignal(att->sync.sync_mode);
306 }
307 #endif
308 mCfgMutex.unlock();
309
310 EXIT_ANALYZER_FUNCTION();
311 return ret;
312 }
313
getAttrib(rk_aiq_ldch_attrib_t * att)314 XCamReturn RkAiqAldchHandleInt::getAttrib(rk_aiq_ldch_attrib_t* att) {
315 ENTER_ANALYZER_FUNCTION();
316 XCamReturn ret = XCAM_RETURN_NO_ERROR;
317
318 #ifdef DISABLE_HANDLE_ATTRIB
319 mCfgMutex.lock();
320 rk_aiq_uapi_aldch_GetAttrib(mAlgoCtx, att);
321 mCfgMutex.unlock();
322 #else
323 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
324 mCfgMutex.lock();
325 rk_aiq_uapi_aldch_GetAttrib(mAlgoCtx, att);
326 att->sync.done = true;
327 mCfgMutex.unlock();
328 } else {
329 if (updateAtt) {
330 memcpy(att, &mNewAtt, sizeof(mNewAtt));
331 att->sync.done = false;
332 } else {
333 rk_aiq_uapi_aldch_GetAttrib(mAlgoCtx, att);
334 att->sync.sync_mode = mNewAtt.sync.sync_mode;
335 att->sync.done = true;
336 }
337 }
338 #endif
339
340 EXIT_ANALYZER_FUNCTION();
341 return ret;
342 }
343 #endif
344
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)345 XCamReturn RkAiqAldchHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
346 ENTER_ANALYZER_FUNCTION();
347
348 XCamReturn ret = XCAM_RETURN_NO_ERROR;
349 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
350 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
351 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
352 #if (RKAIQ_HAVE_LDCH_V21)
353 RkAiqAlgoProcResAldchV21* aldch_com = (RkAiqAlgoProcResAldchV21*)mProcOutParam;
354 rk_aiq_isp_ldch_params_v32_t* ldch_param = params->mLdchV32Params->data().ptr();
355 #else
356 RkAiqAlgoProcResAldch* aldch_com = (RkAiqAlgoProcResAldch*)mProcOutParam;
357 rk_aiq_isp_ldch_params_v20_t* ldch_param = params->mLdchParams->data().ptr();
358 #endif
359
360 if (!aldch_com) {
361 LOGD_ANALYZER("no aldch result");
362 return XCAM_RETURN_NO_ERROR;
363 }
364
365 if (sharedCom->init) {
366 ldch_param->frame_id = 0;
367 } else {
368 ldch_param->frame_id = shared->frameId;
369 }
370
371 if (aldch_com->res_com.cfg_update) {
372 mSyncFlag = shared->frameId;
373 ldch_param->sync_flag = mSyncFlag;
374 // copy from algo result
375 // set as the latest result
376 #if (RKAIQ_HAVE_LDCH_V21)
377 cur_params->mLdchV32Params = params->mLdchV32Params;
378 #else
379 cur_params->mLdchParams = params->mLdchParams;
380 #endif
381 ldch_param->is_update = true;
382 LOGD_ALDCH("[%d] params from algo", mSyncFlag);
383 } else if (mSyncFlag != ldch_param->sync_flag) {
384 ldch_param->sync_flag = mSyncFlag;
385 // copy from latest result
386 #if (RKAIQ_HAVE_LDCH_V21)
387 if (cur_params->mLdchV32Params.ptr()) {
388 ldch_param->is_update = true;
389 ldch_param->result = cur_params->mLdchV32Params->data()->result;
390 } else {
391 LOGE_ALDCH("no latest params !");
392 ldch_param->is_update = false;
393 }
394 #else
395 if (cur_params->mLdchParams.ptr()) {
396 ldch_param->is_update = true;
397 ldch_param->result = cur_params->mLdchParams->data()->result;
398 } else {
399 LOGE_ALDCH("no latest params !");
400 ldch_param->is_update = false;
401 }
402 #endif
403 LOGD_ALDCH("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
404 } else {
405 // do nothing, result in buf needn't update
406 ldch_param->is_update = false;
407 LOGD_ALDCH("[%d] params needn't update", shared->frameId);
408 }
409
410 EXIT_ANALYZER_FUNCTION();
411
412 return ret;
413 }
414
415 } // namespace RkCam
416