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 "RkAiqAgammaHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAgammaHandleInt);
23
init()24 void RkAiqAgammaHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAgamma());
29 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAgamma());
30 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAgamma());
31
32 EXIT_ANALYZER_FUNCTION();
33 }
34
updateConfig(bool needSync)35 XCamReturn RkAiqAgammaHandleInt::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 #if RKAIQ_HAVE_GAMMA_V10
44 mCurAttV10 = mNewAttV10;
45 rk_aiq_uapi_agamma_v10_SetAttrib(mAlgoCtx, &mCurAttV10, false);
46 updateAtt = false;
47 sendSignal(mCurAttV10.sync.sync_mode);
48 #endif
49 #if RKAIQ_HAVE_GAMMA_V11
50 mCurAttV11 = mNewAttV11;
51 rk_aiq_uapi_agamma_v11_SetAttrib(mAlgoCtx, &mCurAttV11, false);
52 updateAtt = false;
53 sendSignal(mCurAttV11.sync.sync_mode);
54 #endif
55 }
56
57 if (needSync) mCfgMutex.unlock();
58 #endif
59 EXIT_ANALYZER_FUNCTION();
60 return ret;
61 }
62
63 #if RKAIQ_HAVE_GAMMA_V10
setAttribV10(const rk_aiq_gamma_v10_attr_t * att)64 XCamReturn RkAiqAgammaHandleInt::setAttribV10(const rk_aiq_gamma_v10_attr_t* att) {
65 ENTER_ANALYZER_FUNCTION();
66
67 XCamReturn ret = XCAM_RETURN_NO_ERROR;
68 mCfgMutex.lock();
69
70 #ifdef DISABLE_HANDLE_ATTRIB
71 ret = rk_aiq_uapi_agamma_v10_SetAttrib(mAlgoCtx, att, false);
72 #else
73 // check if there is different between att & mCurAttV10(sync)/mNewAttV10(async)
74 // if something changed, set att to mNewAttV10, and
75 // the new params will be effective later when updateConfig
76 // called by RkAiqCore
77 bool isChanged = false;
78 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
79 memcmp(&mNewAttV10, att, sizeof(rk_aiq_gamma_v10_attr_t)))
80 isChanged = true;
81 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
82 memcmp(&mCurAttV10, att, sizeof(rk_aiq_gamma_v10_attr_t)))
83 isChanged = true;
84
85 // if something changed
86 if (isChanged) {
87 mNewAttV10 = *att;
88 updateAtt = true;
89 waitSignal(att->sync.sync_mode);
90 }
91 #endif
92 mCfgMutex.unlock();
93
94 EXIT_ANALYZER_FUNCTION();
95 return ret;
96 }
97
getAttribV10(rk_aiq_gamma_v10_attr_t * att)98 XCamReturn RkAiqAgammaHandleInt::getAttribV10(rk_aiq_gamma_v10_attr_t* att) {
99 ENTER_ANALYZER_FUNCTION();
100
101 XCamReturn ret = XCAM_RETURN_NO_ERROR;
102
103 #ifdef DISABLE_HANDLE_ATTRIB
104 mCfgMutex.lock();
105 rk_aiq_uapi_agamma_v10_GetAttrib(mAlgoCtx, att);
106 att->sync.done = true;
107 mCfgMutex.unlock();
108 #else
109 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
110 mCfgMutex.lock();
111 rk_aiq_uapi_agamma_v10_GetAttrib(mAlgoCtx, att);
112 att->sync.done = true;
113 mCfgMutex.unlock();
114 } else {
115 if (updateAtt) {
116 memcpy(att, &mNewAttV10, sizeof(rk_aiq_gamma_v10_attr_t));
117 att->sync.done = false;
118 } else {
119 rk_aiq_uapi_agamma_v10_GetAttrib(mAlgoCtx, att);
120 att->sync.sync_mode = mNewAttV10.sync.sync_mode;
121 att->sync.done = true;
122 }
123 }
124 #endif
125 EXIT_ANALYZER_FUNCTION();
126 return ret;
127 }
128 #endif
129 #if RKAIQ_HAVE_GAMMA_V11
setAttribV11(const rk_aiq_gamma_v11_attr_t * att)130 XCamReturn RkAiqAgammaHandleInt::setAttribV11(const rk_aiq_gamma_v11_attr_t* att) {
131 ENTER_ANALYZER_FUNCTION();
132
133 XCamReturn ret = XCAM_RETURN_NO_ERROR;
134 mCfgMutex.lock();
135
136 #ifdef DISABLE_HANDLE_ATTRIB
137 ret = rk_aiq_uapi_agamma_v11_SetAttrib(mAlgoCtx, att, false);
138 #else
139 // check if there is different between att & mCurAttV11(sync)/mNewAttV11(async)
140 // if something changed, set att to mNewAttV11, and
141 // the new params will be effective later when updateConfig
142 // called by RkAiqCore
143 bool isChanged = false;
144 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC &&
145 memcmp(&mNewAttV11, att, sizeof(rk_aiq_gamma_v11_attr_t)))
146 isChanged = true;
147 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
148 memcmp(&mCurAttV11, att, sizeof(rk_aiq_gamma_v11_attr_t)))
149 isChanged = true;
150
151 // if something changed
152 if (isChanged) {
153 mNewAttV11 = *att;
154 updateAtt = true;
155 waitSignal(att->sync.sync_mode);
156 }
157 #endif
158
159 mCfgMutex.unlock();
160
161 EXIT_ANALYZER_FUNCTION();
162 return ret;
163 }
164
getAttribV11(rk_aiq_gamma_v11_attr_t * att)165 XCamReturn RkAiqAgammaHandleInt::getAttribV11(rk_aiq_gamma_v11_attr_t* att) {
166 ENTER_ANALYZER_FUNCTION();
167
168 XCamReturn ret = XCAM_RETURN_NO_ERROR;
169
170 #ifdef DISABLE_HANDLE_ATTRIB
171 mCfgMutex.lock();
172 rk_aiq_uapi_agamma_v11_GetAttrib(mAlgoCtx, att);
173 att->sync.done = true;
174 mCfgMutex.unlock();
175 #else
176 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
177 mCfgMutex.lock();
178 rk_aiq_uapi_agamma_v11_GetAttrib(mAlgoCtx, att);
179 att->sync.done = true;
180 mCfgMutex.unlock();
181 } else {
182 if (updateAtt) {
183 memcpy(att, &mNewAttV11, sizeof(rk_aiq_gamma_v11_attr_t));
184 att->sync.done = false;
185 } else {
186 rk_aiq_uapi_agamma_v11_GetAttrib(mAlgoCtx, att);
187 att->sync.sync_mode = mNewAttV11.sync.sync_mode;
188 att->sync.done = true;
189 }
190 }
191 #endif
192
193 EXIT_ANALYZER_FUNCTION();
194 return ret;
195 }
196 #endif
197
prepare()198 XCamReturn RkAiqAgammaHandleInt::prepare() {
199 ENTER_ANALYZER_FUNCTION();
200
201 XCamReturn ret = XCAM_RETURN_NO_ERROR;
202
203 ret = RkAiqHandle::prepare();
204 RKAIQCORE_CHECK_RET(ret, "agamma handle prepare failed");
205
206 RkAiqAlgoConfigAgamma* agamma_config_int = (RkAiqAlgoConfigAgamma*)mConfig;
207 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
208 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
209 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
210
211 #ifdef RKAIQ_ENABLE_PARSER_V1
212 agamma_config_int->calib = sharedCom->calib;
213 #endif
214
215 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
216 ret = des->prepare(mConfig);
217 RKAIQCORE_CHECK_RET(ret, "agamma algo prepare failed");
218
219 EXIT_ANALYZER_FUNCTION();
220 return XCAM_RETURN_NO_ERROR;
221 }
222
preProcess()223 XCamReturn RkAiqAgammaHandleInt::preProcess() {
224 ENTER_ANALYZER_FUNCTION();
225
226 XCamReturn ret = XCAM_RETURN_NO_ERROR;
227 #if 0
228 RkAiqAlgoPreAgamma* agamma_pre_int = (RkAiqAlgoPreAgamma*)mPreInParam;
229 RkAiqAlgoPreResAgamma* agamma_pre_res_int = (RkAiqAlgoPreResAgamma*)mPreOutParam;
230 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
231 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
232 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
233
234 ret = RkAiqHandle::preProcess();
235 if (ret) {
236 RKAIQCORE_CHECK_RET(ret, "agamma handle preProcess failed");
237 }
238
239 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
240 ret = des->pre_process(mPreInParam, mPreOutParam);
241 RKAIQCORE_CHECK_RET(ret, "agamma algo pre_process failed");
242
243 EXIT_ANALYZER_FUNCTION();
244 #endif
245 return XCAM_RETURN_NO_ERROR;
246 }
247
processing()248 XCamReturn RkAiqAgammaHandleInt::processing() {
249 ENTER_ANALYZER_FUNCTION();
250
251 XCamReturn ret = XCAM_RETURN_NO_ERROR;
252
253 RkAiqAlgoProcAgamma* agamma_proc_int = (RkAiqAlgoProcAgamma*)mProcInParam;
254 RkAiqAlgoProcResAgamma* agamma_proc_res_int = (RkAiqAlgoProcResAgamma*)mProcOutParam;
255 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
256 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
257 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
258
259 agamma_proc_res_int->GammaProcRes = &shared->fullParams->mAgammaParams->data()->result;
260
261 ret = RkAiqHandle::processing();
262 if (ret) {
263 RKAIQCORE_CHECK_RET(ret, "agamma handle processing failed");
264 }
265
266 #ifdef RKAIQ_ENABLE_PARSER_V1
267 agamma_proc_int->calib = sharedCom->calib;
268 #endif
269
270 #ifdef DISABLE_HANDLE_ATTRIB
271 mCfgMutex.lock();
272 #endif
273 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
274 ret = des->processing(mProcInParam, mProcOutParam);
275 #ifdef DISABLE_HANDLE_ATTRIB
276 mCfgMutex.unlock();
277 #endif
278 RKAIQCORE_CHECK_RET(ret, "agamma algo processing failed");
279
280 EXIT_ANALYZER_FUNCTION();
281 return ret;
282 }
283
postProcess()284 XCamReturn RkAiqAgammaHandleInt::postProcess() {
285 ENTER_ANALYZER_FUNCTION();
286
287 XCamReturn ret = XCAM_RETURN_NO_ERROR;
288 #if 0
289 RkAiqAlgoPostAgamma* agamma_post_int = (RkAiqAlgoPostAgamma*)mPostInParam;
290 RkAiqAlgoPostResAgamma* agamma_post_res_int = (RkAiqAlgoPostResAgamma*)mPostOutParam;
291 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
292 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
293 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
294
295 ret = RkAiqHandle::postProcess();
296 if (ret) {
297 RKAIQCORE_CHECK_RET(ret, "agamma handle postProcess failed");
298 return ret;
299 }
300
301 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
302 ret = des->post_process(mPostInParam, mPostOutParam);
303 RKAIQCORE_CHECK_RET(ret, "agamma algo post_process failed");
304
305 EXIT_ANALYZER_FUNCTION();
306 #endif
307 return ret;
308 }
309
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)310 XCamReturn RkAiqAgammaHandleInt::genIspResult(RkAiqFullParams* params,
311 RkAiqFullParams* cur_params) {
312 ENTER_ANALYZER_FUNCTION();
313
314 XCamReturn ret = XCAM_RETURN_NO_ERROR;
315 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
316 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
317 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
318 RkAiqAlgoProcResAgamma* agamma_com = (RkAiqAlgoProcResAgamma*)mProcOutParam;
319 rk_aiq_isp_agamma_params_v20_t* agamma_param = params->mAgammaParams->data().ptr();
320
321 if (!agamma_com) {
322 LOGD_ANALYZER("no agamma result");
323 return XCAM_RETURN_NO_ERROR;
324 }
325
326 if (!this->getAlgoId()) {
327 RkAiqAlgoProcResAgamma* agamma_int = (RkAiqAlgoProcResAgamma*)agamma_com;
328 if (sharedCom->init) {
329 agamma_param->frame_id = 0;
330 } else {
331 agamma_param->frame_id = shared->frameId;
332 }
333
334 if (agamma_com->res_com.cfg_update) {
335 mSyncFlag = shared->frameId;
336 agamma_param->sync_flag = mSyncFlag;
337 // copy from algo result
338 // set as the latest result
339 cur_params->mAgammaParams = params->mAgammaParams;
340 agamma_param->is_update = true;
341 LOGD_AGAMMA("[%d] params from algo", mSyncFlag);
342 } else if (mSyncFlag != agamma_param->sync_flag) {
343 agamma_param->sync_flag = mSyncFlag;
344 // copy from latest result
345 if (cur_params->mAgammaParams.ptr()) {
346 agamma_param->result = cur_params->mAgammaParams->data()->result;
347 agamma_param->is_update = true;
348 } else {
349 LOGE_AGAMMA("no latest params !");
350 agamma_param->is_update = false;
351 }
352 LOGD_AGAMMA("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
353 } else {
354 // do nothing, result in buf needn't update
355 agamma_param->is_update = false;
356 LOGD_AGAMMA("[%d] params needn't update", shared->frameId);
357 }
358
359 }
360
361 EXIT_ANALYZER_FUNCTION();
362
363 return ret;
364 }
365
366 } // namespace RkCam
367