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 "RkAiqAcacV3Handle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAcacV3HandleInt);
23
prepare()24 XCamReturn RkAiqAcacV3HandleInt::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 RkAiqAcacV3HandleInt::init() {
53 ENTER_ANALYZER_FUNCTION();
54
55 RkAiqHandle::deInit();
56 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAcac());
57 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAcac());
58 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAcac());
59
60 EXIT_ANALYZER_FUNCTION();
61 }
62
preProcess()63 XCamReturn RkAiqAcacV3HandleInt::preProcess() {
64 return XCAM_RETURN_NO_ERROR;
65 }
66
processing()67 XCamReturn RkAiqAcacV3HandleInt::processing() {
68 ENTER_ANALYZER_FUNCTION();
69
70 XCamReturn ret = XCAM_RETURN_NO_ERROR;
71
72 RkAiqAlgoProcAcac* acac_proc_int = (RkAiqAlgoProcAcac*)mProcInParam;
73 RkAiqAlgoProcResAcac* acac_proc_res_int = (RkAiqAlgoProcResAcac*)mProcOutParam;
74 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
75 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)getGroupShared();
76 if (!shared) return XCAM_RETURN_BYPASS;
77
78 acac_proc_res_int->config = shared->fullParams->mCacV3xParams->data()->result.cfg;
79
80 RKAiqAecExpInfo_t* aeCurExp = &shared->curExp;
81 if (aeCurExp != NULL) {
82 if ((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
83 acac_proc_int->iso = aeCurExp->LinearExp.exp_real_params.analog_gain * 50;
84 LOGD_ACAC("%s:NORMAL:iso=%d,again=%f\n", __FUNCTION__, acac_proc_int->iso,
85 aeCurExp->LinearExp.exp_real_params.analog_gain);
86 } else if ((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_ISP_HDR2) {
87 acac_proc_int->iso = aeCurExp->HdrExp[1].exp_real_params.analog_gain * 50;
88 LOGD_ACAC("%s:HDR2:iso=%d,again=%f\n", __FUNCTION__, acac_proc_int->iso,
89 aeCurExp->HdrExp[1].exp_real_params.analog_gain);
90 } else if ((rk_aiq_working_mode_t)sharedCom->working_mode == RK_AIQ_WORKING_MODE_ISP_HDR3) {
91 acac_proc_int->iso = aeCurExp->HdrExp[2].exp_real_params.analog_gain * 50;
92 LOGD_ACAC("%s:HDR3:iso=%d,again=%f\n", __FUNCTION__, acac_proc_int->iso,
93 aeCurExp->HdrExp[2].exp_real_params.analog_gain);
94 }
95 } else {
96 acac_proc_int->iso = 50;
97 LOGE_ACAC("%s: pAEPreRes is NULL, so use default instead \n", __FUNCTION__);
98 }
99
100 ret = RkAiqHandle::processing();
101 if (ret) {
102 RKAIQCORE_CHECK_RET(ret, "acac handle processing failed");
103 }
104
105 #ifdef DISABLE_HANDLE_ATTRIB
106 mCfgMutex.lock();
107 #endif
108 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
109
110 ret = des->processing(mProcInParam, mProcOutParam);
111 #ifdef DISABLE_HANDLE_ATTRIB
112 mCfgMutex.unlock();
113 #endif
114 RKAIQCORE_CHECK_RET(ret, "acac algo processing failed");
115
116 EXIT_ANALYZER_FUNCTION();
117 return ret;
118 }
119
postProcess()120 XCamReturn RkAiqAcacV3HandleInt::postProcess() {
121 return XCAM_RETURN_NO_ERROR;
122 }
123
updateConfig(bool needSync)124 XCamReturn RkAiqAcacV3HandleInt::updateConfig(bool needSync) {
125 ENTER_ANALYZER_FUNCTION();
126
127 XCamReturn ret = XCAM_RETURN_NO_ERROR;
128 #ifndef DISABLE_HANDLE_ATTRIB
129 if (needSync) mCfgMutex.lock();
130 if (updateAtt) {
131 mCurAtt = mNewAtt;
132 updateAtt = false;
133 rk_aiq_uapi_acac_v03_SetAttrib(mAlgoCtx, &mCurAtt, false);
134 sendSignal();
135 }
136
137 if (needSync) mCfgMutex.unlock();
138 #endif
139
140 EXIT_ANALYZER_FUNCTION();
141 return ret;
142 }
143
setAttrib(const rkaiq_cac_v03_api_attr_t * att)144 XCamReturn RkAiqAcacV3HandleInt::setAttrib(const rkaiq_cac_v03_api_attr_t* att) {
145 ENTER_ANALYZER_FUNCTION();
146
147 if (att == nullptr) return XCAM_RETURN_ERROR_PARAM;
148
149 XCamReturn ret = XCAM_RETURN_NO_ERROR;
150 mCfgMutex.lock();
151
152 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
153 // if something changed, set att to mNewAtt, and
154 // the new params will be effective later when updateConfig
155 // called by RkAiqCore
156 #ifdef DISABLE_HANDLE_ATTRIB
157 ret = rk_aiq_uapi_acac_v03_SetAttrib(mAlgoCtx, att, false);
158 #else
159 bool isChanged = false;
160 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && memcmp(&mNewAtt, att, sizeof(*att)))
161 isChanged = true;
162 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && memcmp(&mCurAtt, att, sizeof(*att)))
163 isChanged = true;
164
165 // if something changed
166 if (isChanged) {
167 mNewAtt = *att;
168 updateAtt = true;
169 waitSignal(att->sync.sync_mode);
170 }
171 #endif
172
173 mCfgMutex.unlock();
174
175 EXIT_ANALYZER_FUNCTION();
176 return ret;
177 }
178
getAttrib(rkaiq_cac_v03_api_attr_t * att)179 XCamReturn RkAiqAcacV3HandleInt::getAttrib(rkaiq_cac_v03_api_attr_t* att) {
180 ENTER_ANALYZER_FUNCTION();
181
182 if (att == nullptr) return XCAM_RETURN_ERROR_PARAM;
183
184 XCamReturn ret = XCAM_RETURN_NO_ERROR;
185 #ifdef DISABLE_HANDLE_ATTRIB
186 mCfgMutex.lock();
187 ret = rk_aiq_uapi_acac_v03_GetAttrib(mAlgoCtx, att);
188 mCfgMutex.unlock();
189 #else
190 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
191 mCfgMutex.lock();
192 rk_aiq_uapi_acac_v03_GetAttrib(mAlgoCtx, att);
193 att->sync.done = true;
194 mCfgMutex.unlock();
195 } else {
196 if (updateAtt) {
197 memcpy(att, &mNewAtt, sizeof(mNewAtt));
198 att->sync.done = false;
199 } else {
200 rk_aiq_uapi_acac_v03_GetAttrib(mAlgoCtx, att);
201 att->sync.sync_mode = mNewAtt.sync.sync_mode;
202 att->sync.done = true;
203 }
204 }
205 #endif
206
207 EXIT_ANALYZER_FUNCTION();
208 return ret;
209 }
210
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)211 XCamReturn RkAiqAcacV3HandleInt::genIspResult(RkAiqFullParams* params,
212 RkAiqFullParams* cur_params) {
213 ENTER_ANALYZER_FUNCTION();
214
215 XCamReturn ret = XCAM_RETURN_NO_ERROR;
216 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
217 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
218 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
219 RkAiqAlgoProcResAcac* cac_com = (RkAiqAlgoProcResAcac*)mProcOutParam;
220
221 rk_aiq_isp_cac_params_v3x_t* cac_param = params->mCacV3xParams->data().ptr();
222
223 if (!this->getAlgoId()) {
224 RkAiqAlgoProcResAcac* cac_rk = (RkAiqAlgoProcResAcac*)cac_com;
225 if (sharedCom->init) {
226 cac_param->frame_id = 0;
227 } else {
228 cac_param->frame_id = shared->frameId;
229 }
230 cac_param->result.enable = cac_rk->enable;
231
232 if (cac_com->res_com.cfg_update) {
233 mSyncFlag = shared->frameId;
234 cac_param->sync_flag = mSyncFlag;
235 // copy from algo result
236 // set as the latest result
237 cur_params->mCacV3xParams = params->mCacV3xParams;
238 cac_param->is_update = true;
239 LOGD_ACAC("[%d] params from algo", mSyncFlag);
240 } else if (mSyncFlag != cac_param->sync_flag) {
241 cac_param->sync_flag = mSyncFlag;
242 // copy from latest result
243 if (cur_params->mCacV3xParams.ptr()) {
244 cac_param->result = cur_params->mCacV3xParams->data()->result;
245 cac_param->is_update = true;
246 } else {
247 LOGE_ACAC("no latest params !");
248 cac_param->is_update = false;
249 }
250 LOGD_ACAC("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
251 } else {
252 // do nothing, result in buf needn't update
253 cac_param->is_update = false;
254 LOGD_ACAC("[%d] params needn't update", shared->frameId);
255 }
256 }
257
258 EXIT_ANALYZER_FUNCTION();
259 return ret;
260 }
261
262 } // namespace RkCam
263