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