xref: /OK3568_Linux_fs/external/camera_engine_rkaiq/rkaiq/aiq_core/algo_handlers/RkAiqAblcHandle.cpp (revision 4882a59341e53eb6f0b4789bf948001014eff981) 
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 "RkAiqAblcHandle.h"
17 
18 #include "RkAiqCore.h"
19 
20 extern XCamReturn
21 rk_aiq_uapi_ablc_GetProc(const RkAiqAlgoContext *ctx,
22                          AblcProc_t *ProcRes);
23 
24 namespace RkCam {
25 
26 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAblcHandleInt);
27 
init()28 void RkAiqAblcHandleInt::init() {
29     ENTER_ANALYZER_FUNCTION();
30 
31     RkAiqHandle::deInit();
32     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAblc());
33     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAblc());
34     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAblc());
35 
36     EXIT_ANALYZER_FUNCTION();
37 }
38 
updateConfig(bool needSync)39 XCamReturn RkAiqAblcHandleInt::updateConfig(bool needSync) {
40     ENTER_ANALYZER_FUNCTION();
41 
42     XCamReturn ret = XCAM_RETURN_NO_ERROR;
43 #ifndef DISABLE_HANDLE_ATTRIB
44     if (needSync) mCfgMutex.lock();
45     // if something changed
46     if (updateAtt) {
47         mCurAtt   = mNewAtt;
48         rk_aiq_uapi_ablc_SetAttrib(mAlgoCtx, &mCurAtt, false);
49         sendSignal(mCurAtt.sync.sync_mode);
50         updateAtt = false;
51     }
52 
53     if (needSync) mCfgMutex.unlock();
54 #endif
55 
56     EXIT_ANALYZER_FUNCTION();
57     return ret;
58 }
59 
setAttrib(const rk_aiq_blc_attrib_t * att)60 XCamReturn RkAiqAblcHandleInt::setAttrib(const rk_aiq_blc_attrib_t* att) {
61     ENTER_ANALYZER_FUNCTION();
62     XCamReturn ret = XCAM_RETURN_NO_ERROR;
63     mCfgMutex.lock();
64 
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 #ifdef DISABLE_HANDLE_ATTRIB
70     ret = rk_aiq_uapi_ablc_SetAttrib(mAlgoCtx, const_cast<rk_aiq_blc_attrib_t*>(att), false);
71 #else
72     bool isChanged = false;
73     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
74             memcmp(&mNewAtt, att, sizeof(*att)))
75         isChanged = true;
76     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
77              memcmp(&mCurAtt, att, sizeof(*att)))
78         isChanged = true;
79 
80     // if something changed
81     if (isChanged) {
82         mNewAtt   = *att;
83         updateAtt = true;
84         waitSignal(att->sync.sync_mode);
85     }
86 #endif
87 
88     mCfgMutex.unlock();
89 
90     EXIT_ANALYZER_FUNCTION();
91     return ret;
92 }
93 
getAttrib(rk_aiq_blc_attrib_t * att)94 XCamReturn RkAiqAblcHandleInt::getAttrib(rk_aiq_blc_attrib_t* att) {
95     ENTER_ANALYZER_FUNCTION();
96 
97     XCamReturn ret = XCAM_RETURN_NO_ERROR;
98 
99 #ifdef DISABLE_HANDLE_ATTRIB
100     mCfgMutex.lock();
101     rk_aiq_uapi_ablc_GetAttrib(mAlgoCtx, att);
102     mCfgMutex.unlock();
103 #else
104     if(att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
105         mCfgMutex.lock();
106         rk_aiq_uapi_ablc_GetAttrib(mAlgoCtx, att);
107         att->sync.done = true;
108         mCfgMutex.unlock();
109     } else {
110         if(updateAtt) {
111             memcpy(att, &mNewAtt, sizeof(mNewAtt));
112             att->sync.done = false;
113         } else {
114             rk_aiq_uapi_ablc_GetAttrib(mAlgoCtx, att);
115             att->sync.done = true;
116         }
117     }
118 #endif
119 
120     EXIT_ANALYZER_FUNCTION();
121     return ret;
122 }
getProcRes(AblcProc_t * ProcRes)123 XCamReturn RkAiqAblcHandleInt::getProcRes(AblcProc_t *ProcRes) {
124     ENTER_ANALYZER_FUNCTION();
125 
126     XCamReturn ret = XCAM_RETURN_NO_ERROR;
127 
128     rk_aiq_uapi_ablc_GetProc(mAlgoCtx, ProcRes);
129 
130     EXIT_ANALYZER_FUNCTION();
131     return ret;
132 }
133 
getInfo(rk_aiq_ablc_info_t * pInfo)134 XCamReturn RkAiqAblcHandleInt::getInfo(rk_aiq_ablc_info_t *pInfo) {
135     ENTER_ANALYZER_FUNCTION();
136 
137     XCamReturn ret = XCAM_RETURN_NO_ERROR;
138 
139     if(pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
140         mCfgMutex.lock();
141         rk_aiq_uapi_ablc_GetInfo(mAlgoCtx, pInfo);
142         pInfo->sync.done = true;
143         mCfgMutex.unlock();
144     } else {
145         rk_aiq_uapi_ablc_GetInfo(mAlgoCtx, pInfo);
146         pInfo->sync.done = true;
147 
148     }
149 
150     EXIT_ANALYZER_FUNCTION();
151     return ret;
152 }
153 
prepare()154 XCamReturn RkAiqAblcHandleInt::prepare() {
155     ENTER_ANALYZER_FUNCTION();
156 
157     XCamReturn ret = XCAM_RETURN_NO_ERROR;
158 
159     ret = RkAiqHandle::prepare();
160     RKAIQCORE_CHECK_RET(ret, "ablc handle prepare failed");
161 
162     RkAiqAlgoConfigAblc* ablc_config_int = (RkAiqAlgoConfigAblc*)mConfig;
163     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
164         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
165 
166     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
167     ret                       = des->prepare(mConfig);
168     RKAIQCORE_CHECK_RET(ret, "ablc algo prepare failed");
169 
170     EXIT_ANALYZER_FUNCTION();
171     return XCAM_RETURN_NO_ERROR;
172 }
173 
preProcess()174 XCamReturn RkAiqAblcHandleInt::preProcess() {
175     ENTER_ANALYZER_FUNCTION();
176 
177     XCamReturn ret = XCAM_RETURN_NO_ERROR;
178 #if 0
179     RkAiqAlgoPreAblc* ablc_pre_int        = (RkAiqAlgoPreAblc*)mPreInParam;
180     RkAiqAlgoPreResAblc* ablc_pre_res_int = (RkAiqAlgoPreResAblc*)mPreOutParam;
181     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
182         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
183     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
184 
185     ret = RkAiqHandle::preProcess();
186     if (ret) {
187         RKAIQCORE_CHECK_RET(ret, "ablc handle preProcess failed");
188     }
189 
190     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
191     ret                       = des->pre_process(mPreInParam, mPreOutParam);
192     RKAIQCORE_CHECK_RET(ret, "ablc algo pre_process failed");
193 
194     EXIT_ANALYZER_FUNCTION();
195 #endif
196     return XCAM_RETURN_NO_ERROR;
197 }
198 
processing()199 XCamReturn RkAiqAblcHandleInt::processing() {
200     ENTER_ANALYZER_FUNCTION();
201 
202     XCamReturn ret = XCAM_RETURN_NO_ERROR;
203 
204     RkAiqAlgoProcAblc* ablc_proc_int        = (RkAiqAlgoProcAblc*)mProcInParam;
205 
206     if (mDes->id == 0) {
207         mProcResShared = new RkAiqAlgoProcResAblcIntShared();
208         if (!mProcResShared.ptr()) {
209             LOGE("new BLC mProcResShared failed, bypass!");
210             return XCAM_RETURN_BYPASS;
211         }
212     }
213 
214     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
215         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
216     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
217 
218     mProcResShared->result.ablc_proc_res = &shared->fullParams->mBlcV21Params->data()->result.v0;
219 
220     ret = RkAiqHandle::processing();
221     if (ret < 0) {
222         LOGE_ANALYZER("ablc handle processing failed ret %d", ret);
223         mProcResShared = NULL;
224         return ret;
225     } else if (ret == XCAM_RETURN_BYPASS) {
226         LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
227         mProcResShared = NULL;
228         return ret;
229     }
230 
231     ablc_proc_int->iso      = sharedCom->iso;
232     ablc_proc_int->hdr_mode = sharedCom->working_mode;
233 
234 #ifdef DISABLE_HANDLE_ATTRIB
235     mCfgMutex.lock();
236 #endif
237     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
238     ret                       = des->processing(mProcInParam, (RkAiqAlgoResCom*)(&mProcResShared->result));
239 #ifdef DISABLE_HANDLE_ATTRIB
240     mCfgMutex.unlock();
241 #endif
242     if (ret < 0) {
243         LOGE_ANALYZER("ablc algo processing failed ret %d", ret);
244         mProcResShared = NULL;
245         return ret;
246     } else if (ret == XCAM_RETURN_BYPASS) {
247         LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
248         mProcResShared = NULL;
249         return ret;
250     }
251 
252     if (!mProcResShared->result.res_com.cfg_update) {
253         mProcResShared->result.ablc_proc_res = mLatestparam;
254         LOGD_ABLC("[%d] copy results from latest !", shared->frameId);
255     }
256 
257     if (mAiqCore->mAlogsComSharedParams.init) {
258         RkAiqCore::RkAiqAlgosGroupShared_t* grpShared = nullptr;
259         uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_AWB);
260         if (!mAiqCore->getGroupSharedParams(grpMask, grpShared)) {
261             if (grpShared)
262                 grpShared->res_comb.ablc_proc_res = mProcResShared->result.ablc_proc_res;
263         }
264         grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_GRP0);
265         if (!mAiqCore->getGroupSharedParams(grpMask, grpShared)) {
266             if (grpShared)
267                 grpShared->res_comb.ablc_proc_res = mProcResShared->result.ablc_proc_res;
268         }
269         grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_GRP1);
270         if (!mAiqCore->getGroupSharedParams(grpMask, grpShared)) {
271             if (grpShared)
272                 grpShared->res_comb.ablc_proc_res = mProcResShared->result.ablc_proc_res;
273         }
274         grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_DHAZ);
275         if (!mAiqCore->getGroupSharedParams(grpMask, grpShared)) {
276             if (grpShared)
277                 grpShared->res_comb.ablc_proc_res = mProcResShared->result.ablc_proc_res;
278         }
279     } else if (mPostShared) {
280         mProcResShared->set_sequence(shared->frameId);
281         RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_BLC_PROC_RES_OK, shared->frameId, mProcResShared);
282         mAiqCore->post_message(msg);
283     }
284 
285     EXIT_ANALYZER_FUNCTION();
286     return ret;
287 }
288 
postProcess()289 XCamReturn RkAiqAblcHandleInt::postProcess() {
290     ENTER_ANALYZER_FUNCTION();
291 
292     XCamReturn ret = XCAM_RETURN_NO_ERROR;
293 #if 0
294     RkAiqAlgoPostAblc* ablc_post_int        = (RkAiqAlgoPostAblc*)mPostInParam;
295     RkAiqAlgoPostResAblc* ablc_post_res_int = (RkAiqAlgoPostResAblc*)mPostOutParam;
296     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
297         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
298     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
299 
300     ret = RkAiqHandle::postProcess();
301     if (ret) {
302         RKAIQCORE_CHECK_RET(ret, "ablc handle postProcess failed");
303         return ret;
304     }
305 
306     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
307     ret                       = des->post_process(mPostInParam, mPostOutParam);
308     RKAIQCORE_CHECK_RET(ret, "ablc algo post_process failed");
309 
310     EXIT_ANALYZER_FUNCTION();
311 #endif
312     return ret;
313 }
314 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)315 XCamReturn RkAiqAblcHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
316     ENTER_ANALYZER_FUNCTION();
317 
318     XCamReturn ret = XCAM_RETURN_NO_ERROR;
319     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
320         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
321     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
322     if (!mProcResShared.ptr())
323         return XCAM_RETURN_NO_ERROR;
324     RkAiqAlgoProcResAblc* ablc_com             = (RkAiqAlgoProcResAblc*)&mProcResShared->result;
325 
326     rk_aiq_isp_blc_params_v21_t* blc_param = params->mBlcV21Params->data().ptr();
327 
328     if (!ablc_com) {
329         LOGD_ANALYZER("no ablc result");
330         mProcResShared = NULL;
331         return XCAM_RETURN_NO_ERROR;
332     }
333 
334     if (!this->getAlgoId()) {
335         RkAiqAlgoProcResAblc* ablc_rk = (RkAiqAlgoProcResAblc*)ablc_com;
336 
337         if (sharedCom->init) {
338             blc_param->frame_id = 0;
339         } else {
340             blc_param->frame_id = shared->frameId;
341         }
342 
343         if (ablc_com->res_com.cfg_update) {
344             mSyncFlag = shared->frameId;
345             blc_param->sync_flag = mSyncFlag;
346             // copy from algo result
347             cur_params->mBlcV21Params = params->mBlcV21Params;
348             mLatestparam = &cur_params->mBlcV21Params->data()->result.v0;
349             blc_param->is_update = true;
350             LOGD_ABLC("[%d] params from algo", mSyncFlag);
351         } else if (mSyncFlag != blc_param->sync_flag) {
352             blc_param->sync_flag = mSyncFlag;
353             // copy from latest result
354             if (cur_params->mBlcV21Params.ptr()) {
355                 blc_param->result = cur_params->mBlcV21Params->data()->result;
356                 blc_param->is_update = true;
357             } else {
358                 LOGD_ABLC("no latest params !");
359                 blc_param->is_update = false;
360             }
361             LOGD_ABLC("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
362         } else {
363             // do nothing, result in buf needn't update
364             blc_param->is_update = false;
365             LOGD_ABLC("[%d] params needn't update", shared->frameId);
366         }
367     }
368 
369     mProcResShared = NULL;
370 
371     EXIT_ANALYZER_FUNCTION();
372 
373     return ret;
374 }
375 
376 }  // namespace RkCam
377