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