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 "RkAiqAdegammaHandle.h"
17 
18 #include "RkAiqCore.h"
19 
20 namespace RkCam {
21 
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAdegammaHandleInt);
23 
init()24 void RkAiqAdegammaHandleInt::init() {
25     ENTER_ANALYZER_FUNCTION();
26 
27     RkAiqHandle::deInit();
28     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAdegamma());
29     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAdegamma());
30     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAdegamma());
31 
32     EXIT_ANALYZER_FUNCTION();
33 }
34 
updateConfig(bool needSync)35 XCamReturn RkAiqAdegammaHandleInt::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         updateAtt = false;
45         // TODO
46         rk_aiq_uapi_adegamma_SetAttrib(mAlgoCtx, mCurAtt, false);
47         waitSignal();
48     }
49 
50     if (needSync) mCfgMutex.unlock();
51 #endif
52     EXIT_ANALYZER_FUNCTION();
53     return ret;
54 }
55 
setAttrib(rk_aiq_degamma_attrib_t att)56 XCamReturn RkAiqAdegammaHandleInt::setAttrib(rk_aiq_degamma_attrib_t att) {
57     ENTER_ANALYZER_FUNCTION();
58 
59     XCamReturn ret = XCAM_RETURN_NO_ERROR;
60     mCfgMutex.lock();
61 #ifdef DISABLE_HANDLE_ATTRIB
62     ret = rk_aiq_uapi_adegamma_SetAttrib(mAlgoCtx, att, false);
63 #else
64     // TODO
65     // check if there is different between att & mCurAtt
66     // if something changed, set att to mNewAtt, and
67     // the new params will be effective later when updateConfig
68     // called by RkAiqCore
69 
70     // if something changed
71     if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_degamma_attrib_t))) {
72         mNewAtt   = att;
73         updateAtt = true;
74         sendSignal();
75     }
76 #endif
77     mCfgMutex.unlock();
78 
79     EXIT_ANALYZER_FUNCTION();
80     return ret;
81 }
82 
getAttrib(rk_aiq_degamma_attrib_t * att)83 XCamReturn RkAiqAdegammaHandleInt::getAttrib(rk_aiq_degamma_attrib_t* att) {
84     ENTER_ANALYZER_FUNCTION();
85 
86     XCamReturn ret = XCAM_RETURN_NO_ERROR;
87 
88     rk_aiq_uapi_adegamma_GetAttrib(mAlgoCtx, att);
89 
90     EXIT_ANALYZER_FUNCTION();
91     return ret;
92 }
93 
prepare()94 XCamReturn RkAiqAdegammaHandleInt::prepare() {
95     ENTER_ANALYZER_FUNCTION();
96 
97     XCamReturn ret = XCAM_RETURN_NO_ERROR;
98 
99     ret = RkAiqHandle::prepare();
100     RKAIQCORE_CHECK_RET(ret, "adegamma handle prepare failed");
101 
102     RkAiqAlgoConfigAdegamma* adegamma_config_int = (RkAiqAlgoConfigAdegamma*)mConfig;
103     RkAiqCore::RkAiqAlgosComShared_t* sharedCom  = &mAiqCore->mAlogsComSharedParams;
104 
105 #ifdef RKAIQ_ENABLE_PARSER_V1
106     adegamma_config_int->calib = sharedCom->calib;
107 #endif
108 
109     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
110     ret                       = des->prepare(mConfig);
111     RKAIQCORE_CHECK_RET(ret, "adegamma algo prepare failed");
112 
113     EXIT_ANALYZER_FUNCTION();
114     return XCAM_RETURN_NO_ERROR;
115 }
116 
preProcess()117 XCamReturn RkAiqAdegammaHandleInt::preProcess() {
118     ENTER_ANALYZER_FUNCTION();
119 
120     XCamReturn ret = XCAM_RETURN_NO_ERROR;
121 #if 0
122     RkAiqAlgoPreAdegamma* adegamma_pre_int        = (RkAiqAlgoPreAdegamma*)mPreInParam;
123     RkAiqAlgoPreResAdegamma* adegamma_pre_res_int = (RkAiqAlgoPreResAdegamma*)mPreOutParam;
124     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
125         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
126     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
127 
128     ret = RkAiqHandle::preProcess();
129     if (ret) {
130         RKAIQCORE_CHECK_RET(ret, "adegamma handle preProcess failed");
131     }
132 
133     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
134     ret                       = des->pre_process(mPreInParam, mPreOutParam);
135     RKAIQCORE_CHECK_RET(ret, "adegamma algo pre_process failed");
136 
137     EXIT_ANALYZER_FUNCTION();
138 #endif
139     return XCAM_RETURN_NO_ERROR;
140 }
141 
processing()142 XCamReturn RkAiqAdegammaHandleInt::processing() {
143     ENTER_ANALYZER_FUNCTION();
144 
145     XCamReturn ret = XCAM_RETURN_NO_ERROR;
146 
147     RkAiqAlgoProcAdegamma* adegamma_proc_int        = (RkAiqAlgoProcAdegamma*)mProcInParam;
148     RkAiqAlgoProcResAdegamma* adegamma_proc_res_int = (RkAiqAlgoProcResAdegamma*)mProcOutParam;
149     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
150         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
151     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
152 
153     adegamma_proc_res_int->adegamma_proc_res = &shared->fullParams->mAdegammaParams->data()->result;
154 
155     ret = RkAiqHandle::processing();
156     if (ret) {
157         RKAIQCORE_CHECK_RET(ret, "adegamma handle processing failed");
158     }
159 
160 #ifdef RKAIQ_ENABLE_PARSER_V1
161     adegamma_proc_int->calib = sharedCom->calib;
162 #endif
163 
164 #ifdef DISABLE_HANDLE_ATTRIB
165     mCfgMutex.lock();
166 #endif
167     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
168     ret                       = des->processing(mProcInParam, mProcOutParam);
169 #ifdef DISABLE_HANDLE_ATTRIB
170     mCfgMutex.unlock();
171 #endif
172     RKAIQCORE_CHECK_RET(ret, "adegamma algo processing failed");
173 
174     EXIT_ANALYZER_FUNCTION();
175     return ret;
176 }
177 
postProcess()178 XCamReturn RkAiqAdegammaHandleInt::postProcess() {
179     ENTER_ANALYZER_FUNCTION();
180 
181     XCamReturn ret = XCAM_RETURN_NO_ERROR;
182 #if 0
183     RkAiqAlgoPostAdegamma* adegamma_post_int        = (RkAiqAlgoPostAdegamma*)mPostInParam;
184     RkAiqAlgoPostResAdegamma* adegamma_post_res_int = (RkAiqAlgoPostResAdegamma*)mPostOutParam;
185     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
186         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
187     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
188 
189     ret = RkAiqHandle::postProcess();
190     if (ret) {
191         RKAIQCORE_CHECK_RET(ret, "adegamma handle postProcess failed");
192         return ret;
193     }
194 
195     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
196     ret                       = des->post_process(mPostInParam, mPostOutParam);
197     RKAIQCORE_CHECK_RET(ret, "agamma algo post_process failed");
198 
199     EXIT_ANALYZER_FUNCTION();
200 #endif
201     return ret;
202 }
203 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)204 XCamReturn RkAiqAdegammaHandleInt::genIspResult(RkAiqFullParams* params,
205                                                 RkAiqFullParams* cur_params) {
206     ENTER_ANALYZER_FUNCTION();
207 
208     XCamReturn ret = XCAM_RETURN_NO_ERROR;
209     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
210         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
211     RkAiqCore::RkAiqAlgosComShared_t* sharedCom     = &mAiqCore->mAlogsComSharedParams;
212     RkAiqAlgoProcResAdegamma* adegamma_com          = (RkAiqAlgoProcResAdegamma*)mProcOutParam;
213     rk_aiq_isp_adegamma_params_v20_t* degamma_param = params->mAdegammaParams->data().ptr();
214 
215     if (!adegamma_com) {
216         LOGD_ANALYZER("no adegamma result");
217         return XCAM_RETURN_NO_ERROR;
218     }
219 
220     if (!this->getAlgoId()) {
221         RkAiqAlgoProcResAdegamma* adegamma_rk = (RkAiqAlgoProcResAdegamma*)adegamma_com;
222         if (sharedCom->init) {
223             degamma_param->frame_id = 0;
224         } else {
225             degamma_param->frame_id = shared->frameId;
226         }
227 
228         if (adegamma_com->res_com.cfg_update) {
229             mSyncFlag = shared->frameId;
230             degamma_param->sync_flag = mSyncFlag;
231             // copy from algo result
232             // set as the latest result
233             cur_params->mAdegammaParams= params->mAdegammaParams;
234             degamma_param->is_update = true;
235             LOGD_ADEGAMMA("[%d] params from algo", mSyncFlag);
236         } else if (mSyncFlag != degamma_param->sync_flag) {
237             degamma_param->sync_flag = mSyncFlag;
238             // copy from latest result
239             if (cur_params->mAdegammaParams.ptr()) {
240                 degamma_param->result = cur_params->mAdegammaParams->data()->result;
241                 degamma_param->is_update = true;
242             } else {
243                 LOGE_ADEGAMMA("no latest params !");
244                 degamma_param->is_update = false;
245             }
246             LOGD_ADEGAMMA("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
247         } else {
248             // do nothing, result in buf needn't update
249             degamma_param->is_update = false;
250             LOGD_ADEGAMMA("[%d] params needn't update", shared->frameId);
251         }
252     }
253 
254     EXIT_ANALYZER_FUNCTION();
255 
256     return ret;
257 }
258 
259 }  // namespace RkCam
260