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