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