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 "RkAiqAgainV2Handle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAgainV2HandleInt);
23
init()24 void RkAiqAgainV2HandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAgainV2());
29 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAgainV2());
30 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAgainV2());
31
32 EXIT_ANALYZER_FUNCTION();
33 }
34
updateConfig(bool needSync)35 XCamReturn RkAiqAgainV2HandleInt::updateConfig(bool needSync) {
36 ENTER_ANALYZER_FUNCTION();
37
38 XCamReturn ret = XCAM_RETURN_NO_ERROR;
39 #ifndef DISABLE_HANDLE_ATTRIB
40 if (needSync) mCfgMutex.lock();
41 // if something changed
42 if (updateAtt) {
43 LOGD_ANR("%s:%d\n", __FUNCTION__, __LINE__);
44 mCurAtt = mNewAtt;
45 rk_aiq_uapi_againV2_SetAttrib(mAlgoCtx, &mCurAtt, false);
46 sendSignal(mCurAtt.sync.sync_mode);
47 updateAtt = false;
48 }
49
50 if (needSync) mCfgMutex.unlock();
51 #endif
52
53 EXIT_ANALYZER_FUNCTION();
54 return ret;
55 }
56
setAttrib(const rk_aiq_gain_attrib_v2_t * att)57 XCamReturn RkAiqAgainV2HandleInt::setAttrib(const rk_aiq_gain_attrib_v2_t* att) {
58 ENTER_ANALYZER_FUNCTION();
59
60 XCamReturn ret = XCAM_RETURN_NO_ERROR;
61 mCfgMutex.lock();
62
63 #ifdef DISABLE_HANDLE_ATTRIB
64 ret = rk_aiq_uapi_againV2_SetAttrib(mAlgoCtx, att, false);
65 #else
66 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
67 // if something changed, set att to mNewAtt, and
68 // the new params will be effective later when updateConfig
69 // called by RkAiqCore
70 bool isChanged = false;
71 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
72 memcmp(&mNewAtt, att, sizeof(*att)))
73 isChanged = true;
74 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
75 memcmp(&mCurAtt, att, sizeof(*att)))
76 isChanged = true;
77
78 // if something changed
79 if (isChanged) {
80 mNewAtt = *att;
81 updateAtt = true;
82 waitSignal(att->sync.sync_mode);
83 }
84 #endif
85
86 mCfgMutex.unlock();
87
88 EXIT_ANALYZER_FUNCTION();
89 return ret;
90 }
91
getAttrib(rk_aiq_gain_attrib_v2_t * att)92 XCamReturn RkAiqAgainV2HandleInt::getAttrib(rk_aiq_gain_attrib_v2_t* att) {
93 ENTER_ANALYZER_FUNCTION();
94
95 XCamReturn ret = XCAM_RETURN_NO_ERROR;
96
97 #ifdef DISABLE_HANDLE_ATTRIB
98 mCfgMutex.lock();
99 rk_aiq_uapi_againV2_GetAttrib(mAlgoCtx, att);
100 mCfgMutex.unlock();
101 #else
102 if(att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
103 mCfgMutex.lock();
104 rk_aiq_uapi_againV2_GetAttrib(mAlgoCtx, att);
105 att->sync.done = true;
106 mCfgMutex.unlock();
107 } else {
108 if(updateAtt) {
109 memcpy(att, &mNewAtt, sizeof(mNewAtt));
110 att->sync.done = false;
111 } else {
112 rk_aiq_uapi_againV2_GetAttrib(mAlgoCtx, att);
113 att->sync.done = true;
114 }
115 }
116 #endif
117
118 EXIT_ANALYZER_FUNCTION();
119 return ret;
120 }
121
getInfo(rk_aiq_gain_info_v2_t * pInfo)122 XCamReturn RkAiqAgainV2HandleInt::getInfo(rk_aiq_gain_info_v2_t* pInfo) {
123 ENTER_ANALYZER_FUNCTION();
124
125 XCamReturn ret = XCAM_RETURN_NO_ERROR;
126
127 if(pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
128 mCfgMutex.lock();
129 rk_aiq_uapi_againV2_GetInfo(mAlgoCtx, pInfo);
130 pInfo->sync.done = true;
131 mCfgMutex.unlock();
132 } else {
133 rk_aiq_uapi_againV2_GetInfo(mAlgoCtx, pInfo);
134 pInfo->sync.done = true;
135 }
136
137 EXIT_ANALYZER_FUNCTION();
138 return ret;
139 }
140
141
142
143
prepare()144 XCamReturn RkAiqAgainV2HandleInt::prepare() {
145 ENTER_ANALYZER_FUNCTION();
146
147 XCamReturn ret = XCAM_RETURN_NO_ERROR;
148
149 ret = RkAiqHandle::prepare();
150 RKAIQCORE_CHECK_RET(ret, "again handle prepare failed");
151
152 RkAiqAlgoConfigAgainV2* again_config_int = (RkAiqAlgoConfigAgainV2*)mConfig;
153 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
154 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
155 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
156
157 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
158 ret = des->prepare(mConfig);
159 RKAIQCORE_CHECK_RET(ret, "again algo prepare failed");
160
161 EXIT_ANALYZER_FUNCTION();
162 return XCAM_RETURN_NO_ERROR;
163 }
164
preProcess()165 XCamReturn RkAiqAgainV2HandleInt::preProcess() {
166 ENTER_ANALYZER_FUNCTION();
167
168 XCamReturn ret = XCAM_RETURN_NO_ERROR;
169 #if 0
170 RkAiqAlgoPreAgainV2* again_pre_int = (RkAiqAlgoPreAgainV2*)mPreInParam;
171 RkAiqAlgoPreResAgainV2* again_pre_res_int = (RkAiqAlgoPreResAgainV2*)mPreOutParam;
172
173 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
174 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
175 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
176
177 ret = RkAiqHandle::preProcess();
178 if (ret) {
179 RKAIQCORE_CHECK_RET(ret, "again handle preProcess failed");
180 }
181
182 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
183 ret = des->pre_process(mPreInParam, mPreOutParam);
184 RKAIQCORE_CHECK_RET(ret, "again algo pre_process failed");
185
186 EXIT_ANALYZER_FUNCTION();
187 #endif
188 return XCAM_RETURN_NO_ERROR;
189 }
190
processing()191 XCamReturn RkAiqAgainV2HandleInt::processing() {
192 ENTER_ANALYZER_FUNCTION();
193
194 XCamReturn ret = XCAM_RETURN_NO_ERROR;
195
196 RkAiqAlgoProcAgainV2* again_proc_int = (RkAiqAlgoProcAgainV2*)mProcInParam;
197 RkAiqAlgoProcResAgainV2* again_proc_res_int = (RkAiqAlgoProcResAgainV2*)mProcOutParam;
198
199 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
200 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
201 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
202
203 again_proc_res_int->stAgainProcResult.stFix = &shared->fullParams->mGainV3xParams->data()->result;
204
205 ret = RkAiqHandle::processing();
206 if (ret) {
207 RKAIQCORE_CHECK_RET(ret, "again handle processing failed");
208 }
209
210 // TODO: fill procParam
211 again_proc_int->iso = sharedCom->iso;
212 again_proc_int->hdr_mode = sharedCom->working_mode;
213
214 #ifdef DISABLE_HANDLE_ATTRIB
215 mCfgMutex.lock();
216 #endif
217 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
218 ret = des->processing(mProcInParam, mProcOutParam);
219 #ifdef DISABLE_HANDLE_ATTRIB
220 mCfgMutex.unlock();
221 #endif
222 RKAIQCORE_CHECK_RET(ret, "again algo processing failed");
223
224 EXIT_ANALYZER_FUNCTION();
225 return ret;
226 }
227
postProcess()228 XCamReturn RkAiqAgainV2HandleInt::postProcess() {
229 ENTER_ANALYZER_FUNCTION();
230
231 XCamReturn ret = XCAM_RETURN_NO_ERROR;
232 #if 0
233 RkAiqAlgoPostAgainV2* again_post_int = (RkAiqAlgoPostAgainV2*)mPostInParam;
234 RkAiqAlgoPostResAgainV2* again_post_res_int = (RkAiqAlgoPostResAgainV2*)mPostOutParam;
235
236 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
237 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
238 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
239
240 ret = RkAiqHandle::postProcess();
241 if (ret) {
242 RKAIQCORE_CHECK_RET(ret, "auvnr handle postProcess failed");
243 return ret;
244 }
245
246 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
247 ret = des->post_process(mPostInParam, mPostOutParam);
248 RKAIQCORE_CHECK_RET(ret, "auvnr algo post_process failed");
249
250 EXIT_ANALYZER_FUNCTION();
251 #endif
252 return ret;
253 }
254
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)255 XCamReturn RkAiqAgainV2HandleInt::genIspResult(RkAiqFullParams* params,
256 RkAiqFullParams* cur_params) {
257 ENTER_ANALYZER_FUNCTION();
258
259 XCamReturn ret = XCAM_RETURN_NO_ERROR;
260 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
261 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
262 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
263 RkAiqAlgoProcResAgainV2* again_rk = (RkAiqAlgoProcResAgainV2*)mProcOutParam;
264
265 if (!again_rk) {
266 LOGD_ANALYZER("no asharp result");
267 return XCAM_RETURN_NO_ERROR;
268 }
269
270 if (!this->getAlgoId()) {
271 if (params->mGainV3xParams.ptr()) {
272 rk_aiq_isp_gain_params_v3x_t* gain_param = params->mGainV3xParams->data().ptr();
273 if (sharedCom->init) {
274 gain_param->frame_id = 0;
275 } else {
276 gain_param->frame_id = shared->frameId;
277 }
278 LOGD_ANR("oyyf: %s:%d output gain param start\n", __FUNCTION__, __LINE__);
279
280 if (again_rk->res_com.cfg_update) {
281 mSyncFlag = shared->frameId;
282 gain_param->sync_flag = mSyncFlag;
283 // copy from algo result
284 // set as the latest result
285 cur_params->mGainV3xParams = params->mGainV3xParams;
286 gain_param->is_update = true;
287 LOGD_ANR("[%d] params from algo", mSyncFlag);
288 } else if (mSyncFlag != gain_param->sync_flag) {
289 gain_param->sync_flag = mSyncFlag;
290 // copy from latest result
291 if (cur_params->mGainV3xParams.ptr()) {
292 gain_param->result = cur_params->mGainV3xParams->data()->result;
293 gain_param->is_update = true;
294 } else {
295 LOGE_ANR("no latest params !");
296 gain_param->is_update = false;
297 }
298 LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
299 } else {
300 // do nothing, result in buf needn't update
301 gain_param->is_update = false;
302 LOGD_ANR("[%d] params needn't update", shared->frameId);
303 }
304
305 LOGD_ANR("oyyf: %s:%d output gain param end \n", __FUNCTION__, __LINE__);
306 }
307 }
308
309 EXIT_ANALYZER_FUNCTION();
310
311 return ret;
312 }
313
314 } // namespace RkCam
315