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 "RkAiqAsharpHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAsharpHandleInt);
23
init()24 void RkAiqAsharpHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAsharp());
29 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAsharp());
30 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAsharp());
31 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAsharp());
32 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAsharp());
33 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAsharp());
34 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAsharp());
35
36 EXIT_ANALYZER_FUNCTION();
37 }
38
updateConfig(bool needSync)39 XCamReturn RkAiqAsharpHandleInt::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_asharp_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(mAlgoCtx, &mCurIQPara, false);
59 sendSignal();
60 }
61
62 if (needSync) mCfgMutex.unlock();
63 #endif
64
65 EXIT_ANALYZER_FUNCTION();
66 return ret;
67 }
68
setAttrib(rk_aiq_sharp_attrib_t * att)69 XCamReturn RkAiqAsharpHandleInt::setAttrib(rk_aiq_sharp_attrib_t* att) {
70 ENTER_ANALYZER_FUNCTION();
71
72 XCamReturn ret = XCAM_RETURN_NO_ERROR;
73 mCfgMutex.lock();
74 #ifdef DISABLE_HANDLE_ATTRIB
75 ret = rk_aiq_uapi_asharp_SetAttrib(mAlgoCtx, att, false);
76 #else
77 // TODO
78 // check if there is different between att & mCurAtt
79 // if something changed, set att to mNewAtt, and
80 // the new params will be effective later when updateConfig
81 // called by RkAiqCore
82
83 // if something changed
84 if (0 != memcmp(&mCurAtt, att, sizeof(rk_aiq_sharp_attrib_t))) {
85 mNewAtt = *att;
86 updateAtt = true;
87 waitSignal();
88 }
89 #endif
90
91 mCfgMutex.unlock();
92
93 EXIT_ANALYZER_FUNCTION();
94 return ret;
95 }
96
getAttrib(rk_aiq_sharp_attrib_t * att)97 XCamReturn RkAiqAsharpHandleInt::getAttrib(rk_aiq_sharp_attrib_t* att) {
98 ENTER_ANALYZER_FUNCTION();
99
100 XCamReturn ret = XCAM_RETURN_NO_ERROR;
101
102 rk_aiq_uapi_asharp_GetAttrib(mAlgoCtx, att);
103
104 EXIT_ANALYZER_FUNCTION();
105 return ret;
106 }
107
setIQPara(rk_aiq_sharp_IQpara_t * para)108 XCamReturn RkAiqAsharpHandleInt::setIQPara(rk_aiq_sharp_IQpara_t* para) {
109 ENTER_ANALYZER_FUNCTION();
110
111 XCamReturn ret = XCAM_RETURN_NO_ERROR;
112 mCfgMutex.lock();
113 #ifdef DISABLE_HANDLE_ATTRIB
114 ret = rk_aiq_uapi_asharp_SetIQpara(mAlgoCtx, para, false);
115 #else
116 // TODO
117 // check if there is different between att & mCurAtt
118 // if something changed, set att to mNewAtt, and
119 // the new params will be effective later when updateConfig
120 // called by RkAiqCore
121
122 // if something changed
123 if (0 != memcmp(&mCurIQPara, para, sizeof(rk_aiq_sharp_IQpara_t))) {
124 mNewIQPara = *para;
125 updateIQpara = true;
126 waitSignal();
127 }
128 #endif
129
130 mCfgMutex.unlock();
131
132 EXIT_ANALYZER_FUNCTION();
133 return ret;
134 }
135
getIQPara(rk_aiq_sharp_IQpara_t * para)136 XCamReturn RkAiqAsharpHandleInt::getIQPara(rk_aiq_sharp_IQpara_t* para) {
137 ENTER_ANALYZER_FUNCTION();
138
139 XCamReturn ret = XCAM_RETURN_NO_ERROR;
140
141 rk_aiq_uapi_asharp_GetIQpara(mAlgoCtx, para);
142
143 EXIT_ANALYZER_FUNCTION();
144 return ret;
145 }
146
setStrength(float fPercent)147 XCamReturn RkAiqAsharpHandleInt::setStrength(float fPercent) {
148 ENTER_ANALYZER_FUNCTION();
149
150 XCamReturn ret = XCAM_RETURN_NO_ERROR;
151
152 rk_aiq_uapi_asharp_SetStrength(mAlgoCtx, fPercent);
153
154 EXIT_ANALYZER_FUNCTION();
155 return ret;
156 }
157
getStrength(float * pPercent)158 XCamReturn RkAiqAsharpHandleInt::getStrength(float* pPercent) {
159 ENTER_ANALYZER_FUNCTION();
160
161 XCamReturn ret = XCAM_RETURN_NO_ERROR;
162
163 rk_aiq_uapi_asharp_GetStrength(mAlgoCtx, pPercent);
164
165 EXIT_ANALYZER_FUNCTION();
166 return ret;
167 }
168
prepare()169 XCamReturn RkAiqAsharpHandleInt::prepare() {
170 ENTER_ANALYZER_FUNCTION();
171
172 XCamReturn ret = XCAM_RETURN_NO_ERROR;
173
174 ret = RkAiqHandle::prepare();
175 RKAIQCORE_CHECK_RET(ret, "asharp handle prepare failed");
176
177 RkAiqAlgoConfigAsharp* asharp_config_int = (RkAiqAlgoConfigAsharp*)mConfig;
178
179 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
180 ret = des->prepare(mConfig);
181 RKAIQCORE_CHECK_RET(ret, "asharp algo prepare failed");
182
183 EXIT_ANALYZER_FUNCTION();
184 return XCAM_RETURN_NO_ERROR;
185 }
186
preProcess()187 XCamReturn RkAiqAsharpHandleInt::preProcess() {
188 ENTER_ANALYZER_FUNCTION();
189
190 XCamReturn ret = XCAM_RETURN_NO_ERROR;
191
192 RkAiqAlgoPreAsharp* asharp_pre_int = (RkAiqAlgoPreAsharp*)mPreInParam;
193 RkAiqAlgoPreResAsharp* asharp_pre_res_int = (RkAiqAlgoPreResAsharp*)mPreOutParam;
194 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
195 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
196 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
197
198 ret = RkAiqHandle::preProcess();
199 if (ret) {
200 RKAIQCORE_CHECK_RET(ret, "asharp handle preProcess failed");
201 }
202
203 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
204 ret = des->pre_process(mPreInParam, mPreOutParam);
205 RKAIQCORE_CHECK_RET(ret, "asharp algo pre_process failed");
206
207 EXIT_ANALYZER_FUNCTION();
208 return XCAM_RETURN_NO_ERROR;
209 }
210
processing()211 XCamReturn RkAiqAsharpHandleInt::processing() {
212 ENTER_ANALYZER_FUNCTION();
213
214 XCamReturn ret = XCAM_RETURN_NO_ERROR;
215
216 RkAiqAlgoProcAsharp* asharp_proc_int = (RkAiqAlgoProcAsharp*)mProcInParam;
217 RkAiqAlgoProcResAsharp* asharp_proc_res_int = (RkAiqAlgoProcResAsharp*)mProcOutParam;
218 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
219 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
220 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
221 static int asharp_proc_framecnt = 0;
222 asharp_proc_framecnt++;
223
224 ret = RkAiqHandle::processing();
225 if (ret) {
226 RKAIQCORE_CHECK_RET(ret, "asharp handle processing failed");
227 }
228
229 // TODO: fill procParam
230 asharp_proc_int->iso = sharedCom->iso;
231 asharp_proc_int->hdr_mode = sharedCom->working_mode;
232
233 #ifdef DISABLE_HANDLE_ATTRIB
234 mCfgMutex.lock();
235 #endif
236 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
237 ret = des->processing(mProcInParam, mProcOutParam);
238 #ifdef DISABLE_HANDLE_ATTRIB
239 mCfgMutex.unlock();
240 #endif
241 RKAIQCORE_CHECK_RET(ret, "asharp algo processing failed");
242
243 EXIT_ANALYZER_FUNCTION();
244 return ret;
245 }
246
postProcess()247 XCamReturn RkAiqAsharpHandleInt::postProcess() {
248 ENTER_ANALYZER_FUNCTION();
249
250 XCamReturn ret = XCAM_RETURN_NO_ERROR;
251
252 RkAiqAlgoPostAsharp* asharp_post_int = (RkAiqAlgoPostAsharp*)mPostInParam;
253 RkAiqAlgoPostResAsharp* asharp_post_res_int = (RkAiqAlgoPostResAsharp*)mPostOutParam;
254 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
255 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
256 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
257
258 ret = RkAiqHandle::postProcess();
259 if (ret) {
260 RKAIQCORE_CHECK_RET(ret, "asharp handle postProcess failed");
261 return ret;
262 }
263
264 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
265 ret = des->post_process(mPostInParam, mPostOutParam);
266 RKAIQCORE_CHECK_RET(ret, "asharp algo post_process failed");
267
268 EXIT_ANALYZER_FUNCTION();
269 return ret;
270 }
271
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)272 XCamReturn RkAiqAsharpHandleInt::genIspResult(RkAiqFullParams* params,
273 RkAiqFullParams* cur_params) {
274 ENTER_ANALYZER_FUNCTION();
275
276 XCamReturn ret = XCAM_RETURN_NO_ERROR;
277 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
278 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
279 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
280 RkAiqAlgoProcResAsharp* asharp_com = (RkAiqAlgoProcResAsharp*)mProcOutParam;
281
282 if (!asharp_com) {
283 LOGD_ANALYZER("no asharp result");
284 return XCAM_RETURN_NO_ERROR;
285 }
286
287 if (!this->getAlgoId()) {
288 RkAiqAlgoProcResAsharp* asharp_rk = (RkAiqAlgoProcResAsharp*)asharp_com;
289
290 LOGD_ASHARP("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
291 rk_aiq_isp_sharpen_params_v20_t* sharpen_params = params->mSharpenParams->data().ptr();
292 sharpen_params->update_mask |= RKAIQ_ISPP_SHARP_ID;
293 memcpy(&sharpen_params->result, &asharp_rk->stAsharpProcResult.stSharpFix,
294 sizeof(rk_aiq_isp_sharpen_t));
295
296 rk_aiq_isp_edgeflt_params_v20_t* edgeflt_params = params->mEdgefltParams->data().ptr();
297 memcpy(&edgeflt_params->result, &asharp_rk->stAsharpProcResult.stEdgefltFix,
298 sizeof(rk_aiq_isp_edgeflt_t));
299
300 if (sharedCom->init) {
301 sharpen_params->frame_id = 0;
302 edgeflt_params->frame_id = 0;
303 } else {
304 sharpen_params->frame_id = shared->frameId;
305 edgeflt_params->frame_id = shared->frameId;
306 }
307 LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
308 }
309
310 cur_params->mSharpenParams = params->mSharpenParams;
311 cur_params->mEdgefltParams = params->mEdgefltParams;
312
313 EXIT_ANALYZER_FUNCTION();
314
315 return ret;
316 }
317
318 } // namespace RkCam
319