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