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 "RkAiqAcgcHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAcgcHandleInt);
23
init()24 void RkAiqAcgcHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAcgc());
29 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAcgc());
30 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAcgc());
31
32 EXIT_ANALYZER_FUNCTION();
33 }
34
prepare()35 XCamReturn RkAiqAcgcHandleInt::prepare() {
36 ENTER_ANALYZER_FUNCTION();
37
38 XCamReturn ret = XCAM_RETURN_NO_ERROR;
39
40 ret = RkAiqHandle::prepare();
41 RKAIQCORE_CHECK_RET(ret, "acgc handle prepare failed");
42
43 RkAiqAlgoConfigAcgc* acgc_config_int = (RkAiqAlgoConfigAcgc*)mConfig;
44 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
45 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
46
47 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
48 ret = des->prepare(mConfig);
49 RKAIQCORE_CHECK_RET(ret, "acgc algo prepare failed");
50
51 EXIT_ANALYZER_FUNCTION();
52 return XCAM_RETURN_NO_ERROR;
53 }
54
preProcess()55 XCamReturn RkAiqAcgcHandleInt::preProcess() {
56 ENTER_ANALYZER_FUNCTION();
57
58 XCamReturn ret = XCAM_RETURN_NO_ERROR;
59 #if 0
60 RkAiqAlgoPreAcgc* acgc_pre_int = (RkAiqAlgoPreAcgc*)mPreInParam;
61 RkAiqAlgoPreResAcgc* acgc_pre_res_int = (RkAiqAlgoPreResAcgc*)mPreOutParam;
62 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
63 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
64 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
65
66 ret = RkAiqHandle::preProcess();
67 if (ret) {
68 RKAIQCORE_CHECK_RET(ret, "acgc handle preProcess failed");
69 }
70
71 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
72 ret = des->pre_process(mPreInParam, mPreOutParam);
73 RKAIQCORE_CHECK_RET(ret, "acgc algo pre_process failed");
74
75 EXIT_ANALYZER_FUNCTION();
76 #endif
77 return XCAM_RETURN_NO_ERROR;
78 }
79
processing()80 XCamReturn RkAiqAcgcHandleInt::processing() {
81 ENTER_ANALYZER_FUNCTION();
82
83 XCamReturn ret = XCAM_RETURN_NO_ERROR;
84
85 RkAiqAlgoProcAcgc* acgc_proc_int = (RkAiqAlgoProcAcgc*)mProcInParam;
86 RkAiqAlgoProcResAcgc* acgc_proc_res_int = (RkAiqAlgoProcResAcgc*)mProcOutParam;
87 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
88 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
89 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
90
91 acgc_proc_res_int->acgc_res = &shared->fullParams->mCgcParams->data()->result;
92
93 ret = RkAiqHandle::processing();
94 if (ret) {
95 RKAIQCORE_CHECK_RET(ret, "acgc handle processing failed");
96 }
97
98 #ifdef DISABLE_HANDLE_ATTRIB
99 mCfgMutex.lock();
100 #endif
101 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
102 ret = des->processing(mProcInParam, mProcOutParam);
103 #ifdef DISABLE_HANDLE_ATTRIB
104 mCfgMutex.unlock();
105 #endif
106 RKAIQCORE_CHECK_RET(ret, "acgc algo processing failed");
107
108 EXIT_ANALYZER_FUNCTION();
109 return ret;
110 }
111
postProcess()112 XCamReturn RkAiqAcgcHandleInt::postProcess() {
113 ENTER_ANALYZER_FUNCTION();
114
115 XCamReturn ret = XCAM_RETURN_NO_ERROR;
116 #if 0
117 RkAiqAlgoPostAcgc* acgc_post_int = (RkAiqAlgoPostAcgc*)mPostInParam;
118 RkAiqAlgoPostResAcgc* acgc_post_res_int = (RkAiqAlgoPostResAcgc*)mPostOutParam;
119 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
120 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
121 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
122
123 ret = RkAiqHandle::postProcess();
124 if (ret) {
125 RKAIQCORE_CHECK_RET(ret, "acgc handle postProcess failed");
126 return ret;
127 }
128
129 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
130 ret = des->post_process(mPostInParam, mPostOutParam);
131 RKAIQCORE_CHECK_RET(ret, "acgc algo post_process failed");
132
133 EXIT_ANALYZER_FUNCTION();
134 #endif
135 return ret;
136 }
137
updateConfig(bool needSync)138 XCamReturn RkAiqAcgcHandleInt::updateConfig(bool needSync) {
139 ENTER_ANALYZER_FUNCTION();
140
141 XCamReturn ret = XCAM_RETURN_NO_ERROR;
142 #ifndef DISABLE_HANDLE_ATTRIB
143 if (needSync) mCfgMutex.lock();
144 // if something changed
145 if (updateAtt) {
146 mCurAtt = mNewAtt;
147 rk_aiq_uapi_acgc_SetAttrib(mAlgoCtx, &mCurAtt, false);
148 updateAtt = false;
149 sendSignal(mCurAtt.sync.sync_mode);
150 }
151 if (needSync) mCfgMutex.unlock();
152 #endif
153 EXIT_ANALYZER_FUNCTION();
154 return ret;
155 }
156
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)157 XCamReturn RkAiqAcgcHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
158 ENTER_ANALYZER_FUNCTION();
159
160 XCamReturn ret = XCAM_RETURN_NO_ERROR;
161 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
162 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
163 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
164 RkAiqAlgoProcResAcgc* acgc_com = (RkAiqAlgoProcResAcgc*)mProcOutParam;
165 rk_aiq_isp_cgc_params_v20_t* cgc_param = params->mCgcParams->data().ptr();
166
167 if (sharedCom->init) {
168 cgc_param->frame_id = 0;
169 } else {
170 cgc_param->frame_id = shared->frameId;
171 }
172
173 if (!acgc_com) {
174 LOGE_ACGC("no acgc result");
175 return XCAM_RETURN_NO_ERROR;
176 }
177
178 if (acgc_com->res_com.cfg_update) {
179 mSyncFlag = shared->frameId;
180 cgc_param->sync_flag = mSyncFlag;
181 // copy from algo result
182 // set as the latest result
183 cur_params->mCgcParams = params->mCgcParams;
184 cgc_param->is_update = true;
185 LOGD_ACGC("[%d] params from algo", mSyncFlag);
186 } else if (mSyncFlag != cgc_param->sync_flag) {
187 cgc_param->sync_flag = mSyncFlag;
188 // copy from latest result
189 if (cur_params->mCgcParams.ptr()) {
190 cgc_param->result = cur_params->mCgcParams->data()->result;
191 cgc_param->is_update = true;
192 } else {
193 LOGE_ACGC("no latest params !");
194 cgc_param->is_update = false;
195 }
196 LOGD_ACGC("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
197 } else {
198 // do nothing, result in buf needn't update
199 cgc_param->is_update = false;
200 LOGD_ACGC("[%d] params needn't update", shared->frameId);
201 }
202
203 EXIT_ANALYZER_FUNCTION();
204
205 return ret;
206 }
207
setAttrib(const rk_aiq_uapi_acgc_attrib_t * att)208 XCamReturn RkAiqAcgcHandleInt::setAttrib(const rk_aiq_uapi_acgc_attrib_t* att) {
209 ENTER_ANALYZER_FUNCTION();
210
211 XCAM_ASSERT(att != nullptr);
212
213 XCamReturn ret = XCAM_RETURN_NO_ERROR;
214 mCfgMutex.lock();
215
216 #ifdef DISABLE_HANDLE_ATTRIB
217 ret = rk_aiq_uapi_acgc_SetAttrib(mAlgoCtx, att, false);
218 #else
219 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
220 // if something changed, set att to mNewAtt, and
221 // the new params will be effective later when updateConfig
222 // called by RkAiqCore
223 bool isChanged = false;
224 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
225 memcmp(&mNewAtt, att, sizeof(*att)))
226 isChanged = true;
227 else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
228 memcmp(&mCurAtt, att, sizeof(*att)))
229 isChanged = true;
230
231 // if something changed
232 if (isChanged) {
233 mNewAtt = *att;
234 updateAtt = true;
235 waitSignal(att->sync.sync_mode);
236 }
237 #endif
238
239 mCfgMutex.unlock();
240
241 EXIT_ANALYZER_FUNCTION();
242 return ret;
243 }
244
getAttrib(rk_aiq_uapi_acgc_attrib_t * att)245 XCamReturn RkAiqAcgcHandleInt::getAttrib(rk_aiq_uapi_acgc_attrib_t* att) {
246 ENTER_ANALYZER_FUNCTION();
247
248 XCAM_ASSERT(att != nullptr);
249
250 XCamReturn ret = XCAM_RETURN_NO_ERROR;
251 #ifdef DISABLE_HANDLE_ATTRIB
252 mCfgMutex.lock();
253 rk_aiq_uapi_acgc_GetAttrib(mAlgoCtx, att);
254 mCfgMutex.unlock();
255 #else
256
257 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
258 mCfgMutex.lock();
259 rk_aiq_uapi_acgc_GetAttrib(mAlgoCtx, att);
260 att->sync.done = true;
261 mCfgMutex.unlock();
262 } else {
263 if (updateAtt) {
264 memcpy(att, &mNewAtt, sizeof(mNewAtt));
265 att->sync.done = false;
266 } else {
267 rk_aiq_uapi_acgc_GetAttrib(mAlgoCtx, att);
268 att->sync.sync_mode = mNewAtt.sync.sync_mode;
269 att->sync.done = true;
270 }
271 }
272 #endif
273
274 EXIT_ANALYZER_FUNCTION();
275 return ret;
276 }
277
278 }; // namespace RkCam
279