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 "RkAiqAcacHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAcacHandleInt);
23
prepare()24 XCamReturn RkAiqAcacHandleInt::prepare() {
25 ENTER_ANALYZER_FUNCTION();
26
27 XCamReturn ret = XCAM_RETURN_NO_ERROR;
28
29 ret = RkAiqHandle::prepare();
30 RKAIQCORE_CHECK_RET(ret, "acac handle prepare failed");
31
32 RkAiqAlgoConfigAcac* acac_config_int = (RkAiqAlgoConfigAcac*)mConfig;
33 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
34 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
35 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)getGroupShared();
36 if (!shared) return XCAM_RETURN_BYPASS;
37
38 acac_config_int->mem_ops = mAiqCore->mShareMemOps;
39 acac_config_int->width = sharedCom->snsDes.isp_acq_width;
40 acac_config_int->height = sharedCom->snsDes.isp_acq_height;
41 acac_config_int->is_multi_sensor = sharedCom->is_multi_sensor;
42 acac_config_int->is_multi_isp = sharedCom->is_multi_isp_mode;
43 acac_config_int->multi_isp_extended_pixel = sharedCom->multi_isp_extended_pixels;
44
45 ret = des->prepare(mConfig);
46 RKAIQCORE_CHECK_RET(ret, "acac algo prepare failed");
47
48 EXIT_ANALYZER_FUNCTION();
49 return XCAM_RETURN_NO_ERROR;
50 }
51
init()52 void RkAiqAcacHandleInt::init() {
53 ENTER_ANALYZER_FUNCTION();
54
55 RkAiqHandle::deInit();
56 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAcac());
57 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAcac());
58 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAcac());
59 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAcac());
60 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAcac());
61 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAcac());
62 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAcac());
63
64 EXIT_ANALYZER_FUNCTION();
65 }
66
preProcess()67 XCamReturn RkAiqAcacHandleInt::preProcess() {
68 ENTER_ANALYZER_FUNCTION();
69
70 XCamReturn ret = XCAM_RETURN_NO_ERROR;
71
72 RkAiqAlgoPreAcac* acac_pre_int = (RkAiqAlgoPreAcac*)mPreInParam;
73 RkAiqAlgoPreResAcac* acac_pre_res_int = (RkAiqAlgoPreResAcac*)mPreOutParam;
74 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)getGroupShared();
75 if (!shared) return XCAM_RETURN_BYPASS;
76
77 ret = RkAiqHandle::preProcess();
78 if (ret) {
79 RKAIQCORE_CHECK_RET(ret, "acac handle preProcess failed");
80 }
81
82 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
83
84 ret = des->pre_process(mPreInParam, mPreOutParam);
85 RKAIQCORE_CHECK_RET(ret, "acac algo pre_process failed");
86
87 EXIT_ANALYZER_FUNCTION();
88 return XCAM_RETURN_NO_ERROR;
89 }
90
processing()91 XCamReturn RkAiqAcacHandleInt::processing() {
92 ENTER_ANALYZER_FUNCTION();
93
94 XCamReturn ret = XCAM_RETURN_NO_ERROR;
95
96 RkAiqAlgoProcAcac* acac_proc_int = (RkAiqAlgoProcAcac*)mProcInParam;
97 RkAiqAlgoProcResAcac* acac_proc_res_int = (RkAiqAlgoProcResAcac*)mProcOutParam;
98 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
99 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)getGroupShared();
100 if (!shared) return XCAM_RETURN_BYPASS;
101
102 acac_proc_res_int->config = shared->fullParams->mCacV3xParams->data()->result.cfg;
103
104 RKAiqAecExpInfo_t* aeCurExp = &shared->curExp;
105 if (aeCurExp != NULL) {
106 if((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
107 acac_proc_int->hdr_ratio = 1;
108 acac_proc_int->iso = aeCurExp->LinearExp.exp_real_params.analog_gain * 50;
109 LOGD_ACAC("%s:NORMAL:iso=%d,again=%f\n", __FUNCTION__, acac_proc_int->iso,
110 aeCurExp->LinearExp.exp_real_params.analog_gain);
111 } else if ((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_ISP_HDR2) {
112 acac_proc_int->hdr_ratio = (aeCurExp->HdrExp[1].exp_real_params.analog_gain *
113 aeCurExp->HdrExp[1].exp_real_params.integration_time) /
114 (aeCurExp->HdrExp[0].exp_real_params.analog_gain *
115 aeCurExp->HdrExp[0].exp_real_params.integration_time);
116 acac_proc_int->iso = aeCurExp->HdrExp[1].exp_real_params.analog_gain * 50;
117 LOGD_ACAC("%s:HDR2:iso=%d,again=%f\n", __FUNCTION__, acac_proc_int->iso,
118 aeCurExp->HdrExp[1].exp_real_params.analog_gain);
119 } else if ((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_ISP_HDR3) {
120 acac_proc_int->hdr_ratio = (aeCurExp->HdrExp[2].exp_real_params.analog_gain *
121 aeCurExp->HdrExp[2].exp_real_params.integration_time) /
122 (aeCurExp->HdrExp[0].exp_real_params.analog_gain *
123 aeCurExp->HdrExp[0].exp_real_params.integration_time);
124 acac_proc_int->iso = aeCurExp->HdrExp[2].exp_real_params.analog_gain * 50;
125 LOGD_ACAC("%s:HDR3:iso=%d,again=%f\n", __FUNCTION__, acac_proc_int->iso,
126 aeCurExp->HdrExp[2].exp_real_params.analog_gain);
127 }
128 } else {
129 acac_proc_int->iso = 50;
130 LOGE_ACAC("%s: pAEPreRes is NULL, so use default instead \n", __FUNCTION__);
131 }
132
133 acac_proc_int->hdr_mode = sharedCom->working_mode;
134 switch (sharedCom->snsDes.sensor_pixelformat) {
135 case V4L2_PIX_FMT_SBGGR14:
136 case V4L2_PIX_FMT_SGBRG14:
137 case V4L2_PIX_FMT_SGRBG14:
138 case V4L2_PIX_FMT_SRGGB14:
139 acac_proc_int->raw_bits = 14;
140 break;
141 case V4L2_PIX_FMT_SBGGR12:
142 case V4L2_PIX_FMT_SGBRG12:
143 case V4L2_PIX_FMT_SGRBG12:
144 case V4L2_PIX_FMT_SRGGB12:
145 acac_proc_int->raw_bits = 12;
146 break;
147 case V4L2_PIX_FMT_SBGGR10:
148 case V4L2_PIX_FMT_SGBRG10:
149 case V4L2_PIX_FMT_SGRBG10:
150 case V4L2_PIX_FMT_SRGGB10:
151 acac_proc_int->raw_bits = 10;
152 break;
153 default:
154 acac_proc_int->raw_bits = 8;
155 }
156
157 ret = RkAiqHandle::processing();
158 if (ret) {
159 RKAIQCORE_CHECK_RET(ret, "acac handle processing failed");
160 }
161
162 #ifdef DISABLE_HANDLE_ATTRIB
163 mCfgMutex.lock();
164 #endif
165 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
166 ret = des->processing(mProcInParam, mProcOutParam);
167 #ifdef DISABLE_HANDLE_ATTRIB
168 mCfgMutex.unlock();
169 #endif
170 RKAIQCORE_CHECK_RET(ret, "acac algo processing failed");
171
172 EXIT_ANALYZER_FUNCTION();
173 return ret;
174 }
175
postProcess()176 XCamReturn RkAiqAcacHandleInt::postProcess() {
177 ENTER_ANALYZER_FUNCTION();
178
179 XCamReturn ret = XCAM_RETURN_NO_ERROR;
180
181 RkAiqAlgoPostAcac* acac_post_int = (RkAiqAlgoPostAcac*)mPostInParam;
182 RkAiqAlgoPostResAcac* acac_post_res_int = (RkAiqAlgoPostResAcac*)mPostOutParam;
183 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)getGroupShared();
184 if (!shared) return XCAM_RETURN_BYPASS;
185
186 ret = RkAiqHandle::postProcess();
187 if (ret) {
188 RKAIQCORE_CHECK_RET(ret, "acac handle postProcess failed");
189 return ret;
190 }
191
192 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
193
194 ret = des->post_process(mPostInParam, mPostOutParam);
195 RKAIQCORE_CHECK_RET(ret, "acac algo post_process failed");
196
197 EXIT_ANALYZER_FUNCTION();
198 return ret;
199 }
200
updateConfig(bool needSync)201 XCamReturn RkAiqAcacHandleInt::updateConfig(bool needSync) {
202 ENTER_ANALYZER_FUNCTION();
203
204 XCamReturn ret = XCAM_RETURN_NO_ERROR;
205 #ifndef DISABLE_HANDLE_ATTRIB
206 if (needSync) mCfgMutex.lock();
207 if (updateAtt) {
208 mCurAtt = mNewAtt;
209 updateAtt = false;
210 rk_aiq_uapi_acac_v10_SetAttrib(mAlgoCtx, &mCurAtt, false);
211 sendSignal();
212 }
213
214 if (needSync) mCfgMutex.unlock();
215 #endif
216
217 EXIT_ANALYZER_FUNCTION();
218 return ret;
219 }
220
setAttrib(const rkaiq_cac_v10_api_attr_t * att)221 XCamReturn RkAiqAcacHandleInt::setAttrib(const rkaiq_cac_v10_api_attr_t* att) {
222 ENTER_ANALYZER_FUNCTION();
223
224 if (att == nullptr) return XCAM_RETURN_ERROR_PARAM;
225
226 XCamReturn ret = XCAM_RETURN_NO_ERROR;
227 mCfgMutex.lock();
228
229 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
230 // if something changed, set att to mNewAtt, and
231 // the new params will be effective later when updateConfig
232 // called by RkAiqCore
233 #ifdef DISABLE_HANDLE_ATTRIB
234 ret = rk_aiq_uapi_acac_v10_SetAttrib(mAlgoCtx, att, false);
235 #else
236 bool isChanged = false;
237 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
238 memcmp(&mNewAtt, att, sizeof(*att)))
239 isChanged = true;
240 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
241 memcmp(&mCurAtt, att, sizeof(*att)))
242 isChanged = true;
243
244 // if something changed
245 if (isChanged) {
246 mNewAtt = *att;
247 updateAtt = true;
248 waitSignal(att->sync.sync_mode);
249 }
250 #endif
251
252 mCfgMutex.unlock();
253
254 EXIT_ANALYZER_FUNCTION();
255 return ret;
256 }
257
getAttrib(rkaiq_cac_v10_api_attr_t * att)258 XCamReturn RkAiqAcacHandleInt::getAttrib(rkaiq_cac_v10_api_attr_t* att) {
259 ENTER_ANALYZER_FUNCTION();
260
261 if (att == nullptr) return XCAM_RETURN_ERROR_PARAM;
262
263 XCamReturn ret = XCAM_RETURN_NO_ERROR;
264 #ifdef DISABLE_HANDLE_ATTRIB
265 mCfgMutex.lock();
266 rk_aiq_uapi_acac_v10_GetAttrib(mAlgoCtx, att);
267 mCfgMutex.unlock();
268 #else
269
270 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
271 mCfgMutex.lock();
272 rk_aiq_uapi_acac_v10_GetAttrib(mAlgoCtx, att);
273 att->sync.done = true;
274 mCfgMutex.unlock();
275 } else {
276 if (updateAtt) {
277 memcpy(att, &mNewAtt, sizeof(mNewAtt));
278 att->sync.done = false;
279 } else {
280 rk_aiq_uapi_acac_v10_GetAttrib(mAlgoCtx, att);
281 att->sync.sync_mode = mNewAtt.sync.sync_mode;
282 att->sync.done = true;
283 }
284 }
285 #endif
286
287 EXIT_ANALYZER_FUNCTION();
288 return ret;
289 }
290
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)291 XCamReturn RkAiqAcacHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
292 ENTER_ANALYZER_FUNCTION();
293
294 XCamReturn ret = XCAM_RETURN_NO_ERROR;
295 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
296 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
297 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
298 RkAiqAlgoProcResAcac* cac_com = (RkAiqAlgoProcResAcac*)mProcOutParam;
299
300 rk_aiq_isp_cac_params_v3x_t* cac_param = params->mCacV3xParams->data().ptr();
301
302 if (!this->getAlgoId()) {
303 RkAiqAlgoProcResAcac* cac_rk = (RkAiqAlgoProcResAcac*)cac_com;
304 if (sharedCom->init) {
305 cac_param->frame_id = 0;
306 } else {
307 cac_param->frame_id = shared->frameId;
308 }
309 cac_param->result.enable = cac_rk->enable;
310
311 if (cac_com->res_com.cfg_update) {
312 mSyncFlag = shared->frameId;
313 cac_param->sync_flag = mSyncFlag;
314 // copy from algo result
315 // set as the latest result
316 cur_params->mCacV3xParams = params->mCacV3xParams;
317 cac_param->is_update = true;
318 LOGD_ACAC("[%d] params from algo", mSyncFlag);
319 } else if (mSyncFlag != cac_param->sync_flag) {
320 cac_param->sync_flag = mSyncFlag;
321 // copy from latest result
322 if (cur_params->mCacV3xParams.ptr()) {
323 cac_param->result = cur_params->mCacV3xParams->data()->result;
324 cac_param->is_update = true;
325 } else {
326 LOGE_ACAC("no latest params !");
327 cac_param->is_update = false;
328 }
329 LOGD_ACAC("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
330 } else {
331 // do nothing, result in buf needn't update
332 cac_param->is_update = false;
333 LOGD_ACAC("[%d] params needn't update", shared->frameId);
334 }
335 }
336
337 EXIT_ANALYZER_FUNCTION();
338 return ret;
339 }
340
341 } // namespace RkCam
342