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