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