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