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 "RkAiqAeisHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAeisHandleInt);
23
prepare()24 XCamReturn RkAiqAeisHandleInt::prepare() {
25 ENTER_ANALYZER_FUNCTION();
26
27 XCamReturn ret = XCAM_RETURN_NO_ERROR;
28
29 ret = RkAiqHandle::prepare();
30 RKAIQCORE_CHECK_RET(ret, "aeis handle prepare failed");
31
32 RkAiqAlgoConfigAeis* aeis_config_int = (RkAiqAlgoConfigAeis*)mConfig;
33 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
34
35 aeis_config_int->mem_ops = mAiqCore->mShareMemOps;
36
37 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
38 ret = des->prepare(mConfig);
39 RKAIQCORE_CHECK_RET(ret, "aeis algo prepare failed");
40
41 EXIT_ANALYZER_FUNCTION();
42 return XCAM_RETURN_NO_ERROR;
43 }
44
init()45 void RkAiqAeisHandleInt::init() {
46 ENTER_ANALYZER_FUNCTION();
47
48 RkAiqHandle::deInit();
49 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAeis());
50 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAeis());
51 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAeis());
52
53 EXIT_ANALYZER_FUNCTION();
54 }
55
preProcess()56 XCamReturn RkAiqAeisHandleInt::preProcess() {
57 ENTER_ANALYZER_FUNCTION();
58
59 XCamReturn ret = XCAM_RETURN_NO_ERROR;
60 #if 0
61 RkAiqAlgoPreAeis* aeis_pre_int = (RkAiqAlgoPreAeis*)mPreInParam;
62 RkAiqAlgoPreResAeis* aeis_pre_res_int = (RkAiqAlgoPreResAeis*)mPreOutParam;
63 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
64 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)getGroupShared();
65 if (!shared) return XCAM_RETURN_BYPASS;
66
67 ret = RkAiqHandle::preProcess();
68 if (ret) {
69 RKAIQCORE_CHECK_RET(ret, "aeis handle preProcess failed");
70 }
71
72 if (!shared->orbStats && !sharedCom->init) {
73 LOGE_AEIS("no orb stats, ignore!");
74 return XCAM_RETURN_BYPASS;
75 }
76
77 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
78 ret = des->pre_process(mPreInParam, mPreOutParam);
79 RKAIQCORE_CHECK_RET(ret, "aeis algo pre_process failed");
80
81 EXIT_ANALYZER_FUNCTION();
82 #endif
83 return XCAM_RETURN_NO_ERROR;
84 }
85
processing()86 XCamReturn RkAiqAeisHandleInt::processing() {
87 ENTER_ANALYZER_FUNCTION();
88
89 XCamReturn ret = XCAM_RETURN_NO_ERROR;
90
91 RkAiqAlgoProcAeis* aeis_proc_int = (RkAiqAlgoProcAeis*)mProcInParam;
92 RkAiqAlgoProcResAeis* aeis_proc_res_int = (RkAiqAlgoProcResAeis*)mProcOutParam;
93 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
94
95 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)getGroupShared();
96 if (!shared) return XCAM_RETURN_BYPASS;
97
98 aeis_proc_int->orb_stats_buf = shared->orbStats;
99 aeis_proc_int->nr_img_buf = shared->nrImg;
100 aeis_proc_int->sof = shared->sof;
101
102 // Formula:
103 // ΔTs : reset time duration per row
104 // ΔTr : readout time duration per row
105 // ΔTe : expsure time duration per row
106 // M : image sensor total row count
107 // Y : the Yth row, 1 < Y < M
108 // Ts(y) : the reset time(point) of Y row
109 // Tr(y) : the readout time(point) of Y row
110 // Ts(y) = Tr(y) - ΔTe - ΔTr - ΔTs
111 //
112 // ΔTv-blanking : Vertical Blanking Time
113 // ΔTv-blanking = Tr((N-1)last) - Tr((N)first)
114 // ΔTframe = Tr((N-1)first) - Tr((N)first)
115 //
116 // ΔTline = HTS / PCLK
117 // PPL : Pixels Per Line
118 // LPF : Lines Per Frame
119 // HTS : Horizental Total Size
120 // VTS : Vertical Total Size
121 //
122 // PCLK = VTS * HTS * FPS
123 // ΔTskew : Rolling Shutter Skew
124 // ΔTline : line readout time
125 // ΔTskew = ΔTline * height
126
127 constexpr const uint64_t nano_seconds_per_second = 1000000000ULL;
128
129 // TODO(Cody): Assume that the sensor is a seamless sensor
130 // HDR, Coded Rolling Shutter is not included in this case
131 aeis_proc_int->rolling_shutter_skew =
132 sharedCom->snsDes.line_length_pck * nano_seconds_per_second /
133 sharedCom->snsDes.vt_pix_clk_freq_hz * sharedCom->snsDes.sensor_output_height;
134
135 // TODO(Cody): The exposure time is identical to integration time
136 aeis_proc_int->integration_time =
137 shared->curExp.LinearExp.exp_real_params.integration_time;
138 aeis_proc_int->analog_gain = shared->curExp.LinearExp.exp_real_params.analog_gain;
139 aeis_proc_int->frame_width = sharedCom->snsDes.sensor_output_width;
140 aeis_proc_int->frame_height = sharedCom->snsDes.sensor_output_height;
141
142 ret = RkAiqHandle::processing();
143 if (ret) {
144 RKAIQCORE_CHECK_RET(ret, "aeis handle processing failed");
145 }
146
147 if (!shared->orbStats && !sharedCom->init) {
148 LOGE_AEIS("no orb stats, ignore!");
149 return XCAM_RETURN_BYPASS;
150 }
151
152 #ifdef DISABLE_HANDLE_ATTRIB
153 mCfgMutex.lock();
154 #endif
155 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
156 ret = des->processing(mProcInParam, mProcOutParam);
157 #ifdef DISABLE_HANDLE_ATTRIB
158 mCfgMutex.unlock();
159 #endif
160 RKAIQCORE_CHECK_RET(ret, "aeis algo processing failed");
161
162 EXIT_ANALYZER_FUNCTION();
163 return ret;
164 }
165
postProcess()166 XCamReturn RkAiqAeisHandleInt::postProcess() {
167 ENTER_ANALYZER_FUNCTION();
168
169 XCamReturn ret = XCAM_RETURN_NO_ERROR;
170 #if 0
171 RkAiqAlgoPostAeis* aeis_post_int = (RkAiqAlgoPostAeis*)mPostInParam;
172 RkAiqAlgoPostResAeis* aeis_post_res_int = (RkAiqAlgoPostResAeis*)mPostOutParam;
173 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
174 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)getGroupShared();
175 if (!shared) return XCAM_RETURN_BYPASS;
176
177 ret = RkAiqHandle::postProcess();
178 if (ret) {
179 RKAIQCORE_CHECK_RET(ret, "aeis handle postProcess failed");
180 return ret;
181 }
182
183 if (!shared->orbStats && !sharedCom->init) {
184 LOGE_AEIS("no orb stats, ignore!");
185 return XCAM_RETURN_BYPASS;
186 }
187
188 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
189 ret = des->post_process(mPostInParam, mPostOutParam);
190 RKAIQCORE_CHECK_RET(ret, "aeis algo post_process failed");
191
192 EXIT_ANALYZER_FUNCTION();
193 #endif
194 return ret;
195 }
196
updateConfig(bool needSync)197 XCamReturn RkAiqAeisHandleInt::updateConfig(bool needSync) {
198 ENTER_ANALYZER_FUNCTION();
199
200 XCamReturn ret = XCAM_RETURN_NO_ERROR;
201 #ifndef DISABLE_HANDLE_ATTRIB
202 if (needSync) mCfgMutex.lock();
203 // if something changed
204 if (updateAtt) {
205 mCurAtt = mNewAtt;
206 updateAtt = false;
207 // TODO
208 rk_aiq_uapi_aeis_SetAttrib(mAlgoCtx, mCurAtt, false);
209 sendSignal();
210 }
211
212 if (needSync) mCfgMutex.unlock();
213 #endif
214
215 EXIT_ANALYZER_FUNCTION();
216 return ret;
217 }
218
setAttrib(rk_aiq_eis_attrib_t att)219 XCamReturn RkAiqAeisHandleInt::setAttrib(rk_aiq_eis_attrib_t att) {
220 ENTER_ANALYZER_FUNCTION();
221
222 XCamReturn ret = XCAM_RETURN_NO_ERROR;
223 mCfgMutex.lock();
224 #ifdef DISABLE_HANDLE_ATTRIB
225 ret = rk_aiq_uapi_aeis_SetAttrib(mAlgoCtx, att, false);
226 #else
227 // TODO
228 // check if there is different between att & mCurAtt
229 // if something changed, set att to mNewAtt, and
230 // the new params will be efeistive later when updateConfig
231 // called by RkAiqCore
232
233 // if something changed
234 if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_eis_attrib_t))) {
235 mNewAtt = att;
236 updateAtt = true;
237 waitSignal();
238 }
239 #endif
240
241 mCfgMutex.unlock();
242
243 EXIT_ANALYZER_FUNCTION();
244 return ret;
245 }
246
getAttrib(rk_aiq_eis_attrib_t * att)247 XCamReturn RkAiqAeisHandleInt::getAttrib(rk_aiq_eis_attrib_t* att) {
248 ENTER_ANALYZER_FUNCTION();
249
250 XCamReturn ret = XCAM_RETURN_NO_ERROR;
251
252 rk_aiq_uapi_aeis_GetAttrib(mAlgoCtx, att);
253
254 EXIT_ANALYZER_FUNCTION();
255 return ret;
256 }
257
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)258 XCamReturn RkAiqAeisHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
259 ENTER_ANALYZER_FUNCTION();
260
261 XCamReturn ret = XCAM_RETURN_NO_ERROR;
262 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
263 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
264 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
265 RkAiqAlgoProcResAeis* aeis_com = (RkAiqAlgoProcResAeis*)mProcOutParam;
266
267 if (!aeis_com) {
268 LOGD_ANALYZER("no aeis result");
269 return XCAM_RETURN_NO_ERROR;
270 }
271
272 rk_aiq_isp_fec_params_v20_t* fec_params = params->mFecParams->data().ptr();
273 if (!this->getAlgoId()) {
274 RkAiqAlgoProcResAeis* aeis_rk = (RkAiqAlgoProcResAeis*)aeis_com;
275 if (sharedCom->init) {
276 fec_params->frame_id = 0;
277 } else {
278 fec_params->frame_id = shared->frameId;
279 }
280
281 if (aeis_rk->update) {
282 fec_params->update_mask |= RKAIQ_ISPP_FEC_ST_ID;
283 fec_params->result.fec_en = aeis_rk->fec_en;
284 fec_params->result.usage = RKAIQ_ISPP_FEC_ST_ID;
285 if (fec_params->result.fec_en) {
286 #if 1
287 if (1) {
288 #else
289 if (aeis_rk->fd >= 0) {
290 #endif
291 fec_params->result.config = true;
292 fec_params->result.frame_id = aeis_rk->frame_id;
293 fec_params->frame_id = aeis_rk->frame_id;
294 fec_params->result.mesh_density = aeis_rk->mesh_density;
295 fec_params->result.mesh_size = aeis_rk->mesh_size;
296 fec_params->result.mesh_buf_fd = aeis_rk->fd;
297 fec_params->result.img_buf_index = aeis_rk->img_buf_index;
298 fec_params->result.img_buf_size = aeis_rk->img_size;
299 } else {
300 fec_params->result.config = false;
301 }
302 } else {
303 fec_params->update_mask &= ~RKAIQ_ISPP_FEC_ST_ID;
304 }
305 }
306 LOGD_AEIS("eis update %d, id %d, fec: en %d, config %d, fd %d, idx %d", aeis_rk->update,
307 fec_params->result.frame_id, fec_params->result.fec_en, fec_params->result.config,
308 fec_params->result.mesh_buf_fd, fec_params->result.img_buf_index);
309 }
310
311 cur_params->mFecParams = params->mFecParams;
312
313 EXIT_ANALYZER_FUNCTION();
314
315 return ret;
316 }
317
318 } // namespace RkCam
319