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 "RkAiqAsharpV33Handle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAsharpV33HandleInt);
23 
init()24 void RkAiqAsharpV33HandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAsharpV33());
29     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAsharpV33());
30     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAsharpV33());
31 
32     EXIT_ANALYZER_FUNCTION();
33 }
34 
updateConfig(bool needsync)35 XCamReturn RkAiqAsharpV33HandleInt::updateConfig(bool needsync) {
36     XCamReturn ret = XCAM_RETURN_NO_ERROR;
37 
38 #ifndef DISABLE_HANDLE_ATTRIB
39     if (needsync) mCfgMutex.lock();
40     // if something changed
41     if (updateAtt) {
42         mCurAtt = mNewAtt;
43         rk_aiq_uapi_asharpV33_SetAttrib(mAlgoCtx, &mCurAtt, false);
44         sendSignal(mCurAtt.sync.sync_mode);
45         updateAtt = false;
46     }
47 
48     if (updateAttLite) {
49         mCurAttLite = mNewAttLite;
50         rk_aiq_uapi_asharpV33Lite_SetAttrib(mAlgoCtx, &mCurAttLite, false);
51         sendSignal(mCurAttLite.sync.sync_mode);
52         updateAttLite = false;
53     }
54 
55     if (updateStrength) {
56         mCurStrength = mNewStrength;
57         rk_aiq_uapi_asharpV33_SetStrength(mAlgoCtx, &mCurStrength);
58         sendSignal(mCurStrength.sync.sync_mode);
59         updateStrength = false;
60     }
61 
62     if (needsync) mCfgMutex.unlock();
63 #endif
64 
65     EXIT_ANALYZER_FUNCTION();
66     return ret;
67 }
68 
setAttrib(const rk_aiq_sharp_attrib_v33_t * att)69 XCamReturn RkAiqAsharpV33HandleInt::setAttrib(const rk_aiq_sharp_attrib_v33_t* att) {
70     ENTER_ANALYZER_FUNCTION();
71 
72     XCAM_ASSERT(att != nullptr);
73 
74     XCamReturn ret = XCAM_RETURN_NO_ERROR;
75     mCfgMutex.lock();
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 
82 #ifdef DISABLE_HANDLE_ATTRIB
83     ret = rk_aiq_uapi_asharpV33_SetAttrib(mAlgoCtx, att, false);
84 #else
85     // if something changed
86     bool isChanged = false;
87     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
88             memcmp(&mNewAtt, att, sizeof(*att)))
89         isChanged = true;
90     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
91              memcmp(&mCurAtt, att, sizeof(*att)))
92         isChanged = true;
93 
94     // if something changed
95     if (isChanged) {
96         mNewAtt   = *att;
97         updateAtt = true;
98         waitSignal(att->sync.sync_mode);
99     }
100 #endif
101 
102     mCfgMutex.unlock();
103 
104     EXIT_ANALYZER_FUNCTION();
105     return ret;
106 }
107 
getAttrib(rk_aiq_sharp_attrib_v33_t * att)108 XCamReturn RkAiqAsharpV33HandleInt::getAttrib(rk_aiq_sharp_attrib_v33_t* att) {
109     ENTER_ANALYZER_FUNCTION();
110 
111     XCamReturn ret = XCAM_RETURN_NO_ERROR;
112 
113 #ifdef DISABLE_HANDLE_ATTRIB
114       mCfgMutex.lock();
115       ret = rk_aiq_uapi_asharpV33_GetAttrib(mAlgoCtx, att);
116       mCfgMutex.unlock();
117 #else
118     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
119         mCfgMutex.lock();
120         rk_aiq_uapi_asharpV33_GetAttrib(mAlgoCtx, att);
121         att->sync.done = true;
122         mCfgMutex.unlock();
123     } else {
124         if (updateAtt) {
125             memcpy(att, &mNewAtt, sizeof(mNewAtt));
126             att->sync.done = false;
127         } else {
128             rk_aiq_uapi_asharpV33_GetAttrib(mAlgoCtx, att);
129             att->sync.done = true;
130         }
131     }
132 #endif
133 
134     EXIT_ANALYZER_FUNCTION();
135     return ret;
136 }
137 
setAttribLite(const rk_aiq_sharp_attrib_v33LT_t * att)138 XCamReturn RkAiqAsharpV33HandleInt::setAttribLite(const rk_aiq_sharp_attrib_v33LT_t* att) {
139     ENTER_ANALYZER_FUNCTION();
140 
141     XCAM_ASSERT(att != nullptr);
142 
143     XCamReturn ret = XCAM_RETURN_NO_ERROR;
144     mCfgMutex.lock();
145 
146     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
147     // if something changed, set att to mNewAtt, and
148     // the new params will be effective later when updateConfig
149     // called by RkAiqCore
150 
151 #ifdef DISABLE_HANDLE_ATTRIB
152     ret = rk_aiq_uapi_asharpV33Lite_SetAttrib(mAlgoCtx, att, false);
153 #else
154     // if something changed
155     bool isChanged = false;
156 
157     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && memcmp(&mCurAttLite, att, sizeof(*att)))
158         isChanged = true;
159     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
160              memcmp(&mCurAttLite, att, sizeof(*att)))
161         isChanged = true;
162 
163     // if something changed
164     if (isChanged) {
165         mNewAttLite   = *att;
166         updateAttLite = true;
167         waitSignal(att->sync.sync_mode);
168     }
169 #endif
170 
171     mCfgMutex.unlock();
172 
173     EXIT_ANALYZER_FUNCTION();
174     return ret;
175 }
176 
getAttribLite(rk_aiq_sharp_attrib_v33LT_t * att)177 XCamReturn RkAiqAsharpV33HandleInt::getAttribLite(rk_aiq_sharp_attrib_v33LT_t* att) {
178     ENTER_ANALYZER_FUNCTION();
179 
180     XCamReturn ret = XCAM_RETURN_NO_ERROR;
181 
182 #ifdef DISABLE_HANDLE_ATTRIB
183       mCfgMutex.lock();
184       ret = rk_aiq_uapi_asharpV33Lite_GetAttrib(mAlgoCtx, att);
185       mCfgMutex.unlock();
186 #else
187     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
188         mCfgMutex.lock();
189         rk_aiq_uapi_asharpV33Lite_GetAttrib(mAlgoCtx, att);
190         att->sync.done = true;
191         mCfgMutex.unlock();
192     } else {
193         if (updateAttLite) {
194             memcpy(att, &mNewAttLite, sizeof(mNewAttLite));
195             att->sync.done = false;
196         } else {
197             rk_aiq_uapi_asharpV33Lite_GetAttrib(mAlgoCtx, att);
198             att->sync.done = true;
199         }
200     }
201 #endif
202 
203     EXIT_ANALYZER_FUNCTION();
204     return ret;
205 }
206 
setStrength(const rk_aiq_sharp_strength_v33_t * pStrength)207 XCamReturn RkAiqAsharpV33HandleInt::setStrength(const rk_aiq_sharp_strength_v33_t* pStrength) {
208     ENTER_ANALYZER_FUNCTION();
209 
210     XCamReturn ret = XCAM_RETURN_NO_ERROR;
211     mCfgMutex.lock();
212 
213 #ifdef DISABLE_HANDLE_ATTRIB
214     ret = rk_aiq_uapi_asharpV33_SetStrength(mAlgoCtx, pStrength);
215 #else
216     bool isChanged = false;
217     if (pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && memcmp(&mNewStrength, pStrength, sizeof(*pStrength)))
218         isChanged = true;
219     else if (pStrength->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && memcmp(&mCurStrength, pStrength, sizeof(*pStrength)))
220         isChanged = true;
221 
222     if (isChanged) {
223         mNewStrength   = *pStrength;
224         updateStrength = true;
225         waitSignal(pStrength->sync.sync_mode);
226     }
227 #endif
228 
229     mCfgMutex.unlock();
230     EXIT_ANALYZER_FUNCTION();
231     return ret;
232 }
233 
getStrength(rk_aiq_sharp_strength_v33_t * pStrength)234 XCamReturn RkAiqAsharpV33HandleInt::getStrength(rk_aiq_sharp_strength_v33_t* pStrength) {
235     ENTER_ANALYZER_FUNCTION();
236 
237     XCamReturn ret = XCAM_RETURN_NO_ERROR;
238 
239 #ifdef DISABLE_HANDLE_ATTRIB
240         mCfgMutex.lock();
241         ret = rk_aiq_uapi_asharpV33_GetStrength(mAlgoCtx, pStrength);
242         mCfgMutex.unlock();
243 #else
244     if (pStrength->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
245         mCfgMutex.lock();
246         rk_aiq_uapi_asharpV33_GetStrength(mAlgoCtx, pStrength);
247         pStrength->sync.done = true;
248         mCfgMutex.unlock();
249     } else {
250         if (updateStrength) {
251             *pStrength   = mNewStrength;
252             pStrength->sync.done = false;
253         } else {
254             rk_aiq_uapi_asharpV33_GetStrength(mAlgoCtx, pStrength);
255             pStrength->sync.done = true;
256         }
257     }
258 #endif
259 
260     EXIT_ANALYZER_FUNCTION();
261     return ret;
262 }
263 
264 
getInfo(rk_aiq_sharp_info_v33_t * pInfo)265 XCamReturn RkAiqAsharpV33HandleInt::getInfo(rk_aiq_sharp_info_v33_t* pInfo) {
266     ENTER_ANALYZER_FUNCTION();
267 
268     XCamReturn ret = XCAM_RETURN_NO_ERROR;
269 
270     if (pInfo->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
271         mCfgMutex.lock();
272         rk_aiq_uapi_asharpV33_GetInfo(mAlgoCtx, pInfo);
273         pInfo->sync.done = true;
274         mCfgMutex.unlock();
275     } else {
276         rk_aiq_uapi_asharpV33_GetInfo(mAlgoCtx, pInfo);
277         pInfo->sync.done = true;
278     }
279 
280     EXIT_ANALYZER_FUNCTION();
281     return ret;
282 }
283 
284 
prepare()285 XCamReturn RkAiqAsharpV33HandleInt::prepare() {
286     ENTER_ANALYZER_FUNCTION();
287 
288     XCamReturn ret = XCAM_RETURN_NO_ERROR;
289     ret            = RkAiqHandle::prepare();
290     RKAIQCORE_CHECK_RET(ret, "asharp handle prepare failed");
291 
292     RkAiqAlgoConfigAsharpV33* asharp_config_int = (RkAiqAlgoConfigAsharpV33*)mConfig;
293     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
294 
295     asharp_config_int->stAsharpConfig.rawWidth = sharedCom->snsDes.isp_acq_width;
296     asharp_config_int->stAsharpConfig.rawHeight = sharedCom->snsDes.isp_acq_height;
297 
298     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
299     ret                       = des->prepare(mConfig);
300     RKAIQCORE_CHECK_RET(ret, "asharp algo prepare failed");
301     EXIT_ANALYZER_FUNCTION();
302     return ret;
303 }
304 
preProcess()305 XCamReturn RkAiqAsharpV33HandleInt::preProcess() {
306     ENTER_ANALYZER_FUNCTION();
307 
308     XCamReturn ret                               = XCAM_RETURN_NO_ERROR;
309 #if 0
310     RkAiqAlgoPreAsharpV33* asharp_pre_int        = (RkAiqAlgoPreAsharpV33*)mPreInParam;
311     RkAiqAlgoPreResAsharpV33* asharp_pre_res_int = (RkAiqAlgoPreResAsharpV33*)mPreOutParam;
312     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
313         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
314     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
315 
316     ret = RkAiqHandle::preProcess();
317     if (ret) {
318         RKAIQCORE_CHECK_RET(ret, "asharp handle preProcess failed");
319     }
320 
321     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
322     ret                       = des->pre_process(mPreInParam, mPreOutParam);
323     RKAIQCORE_CHECK_RET(ret, "asharp algo pre_process failed");
324 
325     EXIT_ANALYZER_FUNCTION();
326 #endif
327     return ret;
328 }
329 
processing()330 XCamReturn RkAiqAsharpV33HandleInt::processing() {
331     ENTER_ANALYZER_FUNCTION();
332 
333     XCamReturn ret                                 = XCAM_RETURN_NO_ERROR;
334     RkAiqAlgoProcAsharpV33* asharp_proc_int        = (RkAiqAlgoProcAsharpV33*)mProcInParam;
335     RkAiqAlgoProcResAsharpV33* asharp_proc_res_int = (RkAiqAlgoProcResAsharpV33*)mProcOutParam;
336     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
337         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
338     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
339 
340     asharp_proc_res_int->stAsharpProcResult.stFix = &shared->fullParams->mSharpV32Params->data()->result;
341 
342     ret = RkAiqHandle::processing();
343     if (ret) {
344         RKAIQCORE_CHECK_RET(ret, "asharp handle processing failed");
345     }
346 
347     // TODO: fill procParam
348     asharp_proc_int->iso      = sharedCom->iso;
349     asharp_proc_int->hdr_mode = sharedCom->working_mode;
350     asharp_proc_int->stAblcV32_proc_res = shared->res_comb.ablcV32_proc_res;
351 
352 #ifdef DISABLE_HANDLE_ATTRIB
353     mCfgMutex.lock();
354 #endif
355     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
356     ret                       = des->processing(mProcInParam, mProcOutParam);
357 #ifdef DISABLE_HANDLE_ATTRIB
358     mCfgMutex.unlock();
359 #endif
360     RKAIQCORE_CHECK_RET(ret, "asharp algo processing failed");
361 
362     EXIT_ANALYZER_FUNCTION();
363 
364     return ret;
365 }
366 
postProcess()367 XCamReturn RkAiqAsharpV33HandleInt::postProcess() {
368     ENTER_ANALYZER_FUNCTION();
369 
370     XCamReturn ret                                 = XCAM_RETURN_NO_ERROR;
371 #if 0
372     RkAiqAlgoPostAsharpV33* asharp_post_int        = (RkAiqAlgoPostAsharpV33*)mPostInParam;
373     RkAiqAlgoPostResAsharpV33* asharp_post_res_int = (RkAiqAlgoPostResAsharpV33*)mPostOutParam;
374     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
375         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
376     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
377 
378     ret = RkAiqHandle::postProcess();
379     if (ret) {
380         RKAIQCORE_CHECK_RET(ret, "asharp handle postProcess failed");
381         return ret;
382     }
383 
384     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
385     ret                       = des->post_process(mPostInParam, mPostOutParam);
386     RKAIQCORE_CHECK_RET(ret, "asharp algo post_process failed");
387 
388     EXIT_ANALYZER_FUNCTION();
389 #endif
390     return ret;
391 }
392 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)393 XCamReturn RkAiqAsharpV33HandleInt::genIspResult(RkAiqFullParams* params,
394         RkAiqFullParams* cur_params) {
395     ENTER_ANALYZER_FUNCTION();
396     XCamReturn ret = XCAM_RETURN_NO_ERROR;
397     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
398         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
399     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
400     RkAiqAlgoProcResAsharpV33* asharp_rk        = (RkAiqAlgoProcResAsharpV33*)mProcOutParam;
401 
402     if (!asharp_rk) {
403         LOGD_ANALYZER("no asharp result");
404         return XCAM_RETURN_NO_ERROR;
405     }
406 
407     if (!this->getAlgoId()) {
408         LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
409         rk_aiq_isp_sharp_params_v32_t* sharp_param = params->mSharpV32Params->data().ptr();
410         if (sharedCom->init) {
411             sharp_param->frame_id = 0;
412         } else {
413             sharp_param->frame_id = shared->frameId;
414         }
415 
416         if (asharp_rk->res_com.cfg_update) {
417             mSyncFlag = shared->frameId;
418             sharp_param->sync_flag = mSyncFlag;
419             // copy from algo result
420             // set as the latest result
421             cur_params->mSharpV32Params = params->mSharpV32Params;
422             sharp_param->is_update = true;
423             LOGD_ASHARP("[%d] params from algo", mSyncFlag);
424         } else if (mSyncFlag != sharp_param->sync_flag) {
425             sharp_param->sync_flag = mSyncFlag;
426             // copy from latest result
427             if (cur_params->mSharpV32Params.ptr()) {
428                 sharp_param->result = cur_params->mSharpV32Params->data()->result;
429                 sharp_param->is_update = true;
430             } else {
431                 LOGE_ASHARP("no latest params !");
432                 sharp_param->is_update = false;
433             }
434             LOGD_ASHARP("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
435         } else {
436             // do nothing, result in buf needn't update
437             sharp_param->is_update = false;
438             LOGD_ASHARP("[%d] params needn't update", shared->frameId);
439         }
440         LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
441     }
442 
443     EXIT_ANALYZER_FUNCTION();
444 
445     return ret;
446 }
447 
448 }  // namespace RkCam
449