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 "RkAiqAsharpV4Handle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAsharpV4HandleInt);
23 
init()24 void RkAiqAsharpV4HandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAsharpV4());
29     mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAsharpV4());
30     mPreOutParam  = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAsharpV4());
31     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAsharpV4());
32     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAsharpV4());
33     mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAsharpV4());
34     mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAsharpV4());
35 
36 
37     EXIT_ANALYZER_FUNCTION();
38 }
39 
updateConfig(bool needSync)40 XCamReturn RkAiqAsharpV4HandleInt::updateConfig(bool needSync) {
41     ENTER_ANALYZER_FUNCTION();
42 
43     XCamReturn ret = XCAM_RETURN_NO_ERROR;
44 #ifndef DISABLE_HANDLE_ATTRIB
45     if (needSync) mCfgMutex.lock();
46     // if something changed
47     if (updateAtt) {
48         mCurAtt   = mNewAtt;
49         rk_aiq_uapi_asharpV4_SetAttrib(mAlgoCtx, &mCurAtt, false);
50         sendSignal(mCurAtt.sync.sync_mode);
51         updateAtt = false;
52     }
53 
54     if (updateStrength) {
55         mCurStrength   = mNewStrength;
56         rk_aiq_uapi_asharpV4_SetStrength(mAlgoCtx, &mCurStrength);
57         sendSignal(mCurStrength.sync.sync_mode);
58         updateStrength = false;
59     }
60 
61     if (needSync) mCfgMutex.unlock();
62 #endif
63 
64     EXIT_ANALYZER_FUNCTION();
65     return ret;
66 }
67 
setAttrib(rk_aiq_sharp_attrib_v4_t * att)68 XCamReturn RkAiqAsharpV4HandleInt::setAttrib(rk_aiq_sharp_attrib_v4_t* att) {
69     ENTER_ANALYZER_FUNCTION();
70 
71     XCamReturn ret = XCAM_RETURN_NO_ERROR;
72     mCfgMutex.lock();
73 #ifdef DISABLE_HANDLE_ATTRIB
74     ret = rk_aiq_uapi_asharpV4_SetAttrib(mAlgoCtx, att, false);
75 #else
76 
77     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
78     // if something changed, set att to mNewAtt, and
79     // the new params will be effective later when updateConfig
80     // called by RkAiqCore
81     bool isChanged = false;
82     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
83             memcmp(&mNewAtt, att, sizeof(*att)))
84         isChanged = true;
85     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
86              memcmp(&mCurAtt, att, sizeof(*att)))
87         isChanged = true;
88 
89     // if something changed
90     if (isChanged) {
91         mNewAtt   = *att;
92         updateAtt = true;
93         waitSignal(att->sync.sync_mode);
94     }
95 #endif
96 
97     mCfgMutex.unlock();
98 
99     EXIT_ANALYZER_FUNCTION();
100     return ret;
101 }
102 
getAttrib(rk_aiq_sharp_attrib_v4_t * att)103 XCamReturn RkAiqAsharpV4HandleInt::getAttrib(rk_aiq_sharp_attrib_v4_t* att) {
104     ENTER_ANALYZER_FUNCTION();
105 
106     XCamReturn ret = XCAM_RETURN_NO_ERROR;
107 
108 #ifdef DISABLE_HANDLE_ATTRIB
109     mCfgMutex.lock();
110     rk_aiq_uapi_asharpV4_GetAttrib(mAlgoCtx, att);
111     mCfgMutex.unlock();
112 #else
113     if(att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
114         mCfgMutex.lock();
115         rk_aiq_uapi_asharpV4_GetAttrib(mAlgoCtx, att);
116         att->sync.done = true;
117         mCfgMutex.unlock();
118     } else {
119         if(updateAtt) {
120             memcpy(att, &mNewAtt, sizeof(mNewAtt));
121             att->sync.done = false;
122         } else {
123             rk_aiq_uapi_asharpV4_GetAttrib(mAlgoCtx, att);
124             att->sync.done = true;
125         }
126     }
127 #endif
128 
129     EXIT_ANALYZER_FUNCTION();
130     return ret;
131 }
132 
setStrength(rk_aiq_sharp_strength_v4_t * pStrength)133 XCamReturn RkAiqAsharpV4HandleInt::setStrength(rk_aiq_sharp_strength_v4_t *pStrength) {
134     ENTER_ANALYZER_FUNCTION();
135 
136     XCamReturn ret = XCAM_RETURN_NO_ERROR;
137     mCfgMutex.lock();
138 
139 #ifdef DISABLE_HANDLE_ATTRIB
140     ret = rk_aiq_uapi_asharpV4_SetStrength(mAlgoCtx, pStrength);
141 #else
142     bool isChanged = false;
143     if (pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
144             memcmp(&mNewStrength, pStrength, sizeof(*pStrength)))
145         isChanged = true;
146     else if (pStrength->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
147              memcmp(&mCurStrength, pStrength, sizeof(*pStrength)))
148         isChanged = true;
149 
150     if (isChanged) {
151         mNewStrength   = *pStrength;
152         updateStrength = true;
153         waitSignal(pStrength->sync.sync_mode);
154     }
155 #endif
156 
157     mCfgMutex.unlock();
158     EXIT_ANALYZER_FUNCTION();
159     return ret;
160 }
161 
getStrength(rk_aiq_sharp_strength_v4_t * pStrength)162 XCamReturn RkAiqAsharpV4HandleInt::getStrength(rk_aiq_sharp_strength_v4_t *pStrength) {
163     ENTER_ANALYZER_FUNCTION();
164 
165 
166     XCamReturn ret = XCAM_RETURN_NO_ERROR;
167 
168 #ifdef DISABLE_HANDLE_ATTRIB
169     mCfgMutex.lock();
170     rk_aiq_uapi_asharpV4_GetStrength(mAlgoCtx, pStrength);
171     mCfgMutex.unlock();
172 #else
173     if(pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
174         mCfgMutex.lock();
175         rk_aiq_uapi_asharpV4_GetStrength(mAlgoCtx, pStrength);
176         pStrength->sync.done = true;
177         mCfgMutex.unlock();
178     } else {
179         if(updateStrength) {
180             *pStrength = mNewStrength;
181             pStrength->sync.done = false;
182         } else {
183             rk_aiq_uapi_asharpV4_GetStrength(mAlgoCtx, pStrength);
184             pStrength->sync.done = true;
185         }
186     }
187 #endif
188 
189     EXIT_ANALYZER_FUNCTION();
190     return ret;
191 }
192 
getInfo(rk_aiq_sharp_info_v4_t * pInfo)193 XCamReturn RkAiqAsharpV4HandleInt::getInfo(rk_aiq_sharp_info_v4_t *pInfo) {
194     ENTER_ANALYZER_FUNCTION();
195 
196 
197     XCamReturn ret = XCAM_RETURN_NO_ERROR;
198 
199     if(pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
200         mCfgMutex.lock();
201         rk_aiq_uapi_asharpV4_GetInfo(mAlgoCtx, pInfo);
202         pInfo->sync.done = true;
203         mCfgMutex.unlock();
204     } else {
205         rk_aiq_uapi_asharpV4_GetInfo(mAlgoCtx, pInfo);
206         pInfo->sync.done = true;
207     }
208 
209     EXIT_ANALYZER_FUNCTION();
210     return ret;
211 }
212 
213 
prepare()214 XCamReturn RkAiqAsharpV4HandleInt::prepare() {
215     ENTER_ANALYZER_FUNCTION();
216 
217     XCamReturn ret = XCAM_RETURN_NO_ERROR;
218 
219     ret = RkAiqHandle::prepare();
220     RKAIQCORE_CHECK_RET(ret, "asharp handle prepare failed");
221 
222     RkAiqAlgoConfigAsharpV4* asharp_config_int = (RkAiqAlgoConfigAsharpV4*)mConfig;
223 
224     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
225     ret                       = des->prepare(mConfig);
226     RKAIQCORE_CHECK_RET(ret, "asharp algo prepare failed");
227 
228     EXIT_ANALYZER_FUNCTION();
229     return XCAM_RETURN_NO_ERROR;
230 }
231 
preProcess()232 XCamReturn RkAiqAsharpV4HandleInt::preProcess() {
233     ENTER_ANALYZER_FUNCTION();
234 
235     XCamReturn ret = XCAM_RETURN_NO_ERROR;
236 
237     RkAiqAlgoPreAsharpV4* asharp_pre_int        = (RkAiqAlgoPreAsharpV4*)mPreInParam;
238     RkAiqAlgoPreResAsharpV4* asharp_pre_res_int = (RkAiqAlgoPreResAsharpV4*)mPreOutParam;
239     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
240         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
241     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
242 
243     ret = RkAiqHandle::preProcess();
244     if (ret) {
245         RKAIQCORE_CHECK_RET(ret, "asharp handle preProcess failed");
246     }
247 
248     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
249     ret                       = des->pre_process(mPreInParam, mPreOutParam);
250     RKAIQCORE_CHECK_RET(ret, "asharp algo pre_process failed");
251 
252     EXIT_ANALYZER_FUNCTION();
253     return XCAM_RETURN_NO_ERROR;
254 }
255 
processing()256 XCamReturn RkAiqAsharpV4HandleInt::processing() {
257     ENTER_ANALYZER_FUNCTION();
258 
259     XCamReturn ret = XCAM_RETURN_NO_ERROR;
260 
261     RkAiqAlgoProcAsharpV4* asharp_proc_int        = (RkAiqAlgoProcAsharpV4*)mProcInParam;
262     RkAiqAlgoProcResAsharpV4* asharp_proc_res_int = (RkAiqAlgoProcResAsharpV4*)mProcOutParam;
263     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
264         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
265     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
266 
267     asharp_proc_res_int->stAsharpProcResult.stFix = &shared->fullParams->mSharpenV3xParams->data()->result;
268 
269     ret = RkAiqHandle::processing();
270     if (ret) {
271         RKAIQCORE_CHECK_RET(ret, "asharp handle processing failed");
272     }
273 
274     // TODO: fill procParam
275     asharp_proc_int->iso      = sharedCom->iso;
276     asharp_proc_int->hdr_mode = sharedCom->working_mode;
277 
278 #ifdef DISABLE_HANDLE_ATTRIB
279     mCfgMutex.lock();
280 #endif
281     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
282     ret                       = des->processing(mProcInParam, mProcOutParam);
283 #ifdef DISABLE_HANDLE_ATTRIB
284     mCfgMutex.unlock();
285 #endif
286     RKAIQCORE_CHECK_RET(ret, "asharp algo processing failed");
287 
288     EXIT_ANALYZER_FUNCTION();
289     return ret;
290 }
291 
postProcess()292 XCamReturn RkAiqAsharpV4HandleInt::postProcess() {
293     ENTER_ANALYZER_FUNCTION();
294 
295     XCamReturn ret = XCAM_RETURN_NO_ERROR;
296 
297     RkAiqAlgoPostAsharpV4* asharp_post_int        = (RkAiqAlgoPostAsharpV4*)mPostInParam;
298     RkAiqAlgoPostResAsharpV4* asharp_post_res_int = (RkAiqAlgoPostResAsharpV4*)mPostOutParam;
299     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
300         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
301     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
302 
303     ret = RkAiqHandle::postProcess();
304     if (ret) {
305         RKAIQCORE_CHECK_RET(ret, "asharp handle postProcess failed");
306         return ret;
307     }
308 
309     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
310     ret                       = des->post_process(mPostInParam, mPostOutParam);
311     RKAIQCORE_CHECK_RET(ret, "asharp algo post_process failed");
312 
313     EXIT_ANALYZER_FUNCTION();
314     return ret;
315 }
316 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)317 XCamReturn RkAiqAsharpV4HandleInt::genIspResult(RkAiqFullParams* params,
318         RkAiqFullParams* cur_params) {
319     ENTER_ANALYZER_FUNCTION();
320 
321     XCamReturn ret = XCAM_RETURN_NO_ERROR;
322     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
323         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
324     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
325     RkAiqAlgoProcResAsharpV4* asharp_rk = (RkAiqAlgoProcResAsharpV4*)mProcOutParam;
326 
327     if (!asharp_rk) {
328         LOGD_ANALYZER("no asharp result");
329         return XCAM_RETURN_NO_ERROR;
330     }
331 
332     if (!this->getAlgoId()) {
333         LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
334         rk_aiq_isp_sharpen_params_v3x_t* sharp_param = params->mSharpenV3xParams->data().ptr();
335         if (sharedCom->init) {
336             sharp_param->frame_id = 0;
337         } else {
338             sharp_param->frame_id = shared->frameId;
339         }
340 
341         if (asharp_rk->res_com.cfg_update) {
342             mSyncFlag = shared->frameId;
343             sharp_param->sync_flag = mSyncFlag;
344             // copy from algo result
345             // set as the latest result
346             cur_params->mSharpenV3xParams = params->mSharpenV3xParams;
347             sharp_param->is_update = true;
348             LOGD_ASHARP("[%d] params from algo", mSyncFlag);
349         } else if (mSyncFlag != sharp_param->sync_flag) {
350             sharp_param->sync_flag = mSyncFlag;
351             // copy from latest result
352             if (cur_params->mSharpenV3xParams.ptr()) {
353                 sharp_param->result = cur_params->mSharpenV3xParams->data()->result;
354                 sharp_param->is_update = true;
355             } else {
356                 LOGE_ASHARP("no latest params !");
357                 sharp_param->is_update = false;
358             }
359             LOGD_ASHARP("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
360         } else {
361             // do nothing, result in buf needn't update
362             sharp_param->is_update = false;
363             LOGD_ASHARP("[%d] params needn't update", shared->frameId);
364         }
365         LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
366     }
367 
368     EXIT_ANALYZER_FUNCTION();
369 
370     return ret;
371 }
372 
373 }  // namespace RkCam
374