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 "RkAiqAsdHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAsdHandleInt);
23
init()24 void RkAiqAsdHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAsd());
29 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAsd());
30 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAsd());
31 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAsd());
32 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAsd());
33
34 EXIT_ANALYZER_FUNCTION();
35 }
36
updateConfig(bool needSync)37 XCamReturn RkAiqAsdHandleInt::updateConfig(bool needSync) {
38 ENTER_ANALYZER_FUNCTION();
39
40 XCamReturn ret = XCAM_RETURN_NO_ERROR;
41
42 #ifndef DISABLE_HANDLE_ATTRIB
43 if (needSync) mCfgMutex.lock();
44 // if something changed
45 if (updateAtt) {
46 mCurAtt = mNewAtt;
47 updateAtt = false;
48 rk_aiq_uapi_asd_SetAttrib(mAlgoCtx, mCurAtt, false);
49 sendSignal();
50 }
51
52 if (needSync) mCfgMutex.unlock();
53 #endif
54
55 EXIT_ANALYZER_FUNCTION();
56 return ret;
57 }
58
setAttrib(asd_attrib_t att)59 XCamReturn RkAiqAsdHandleInt::setAttrib(asd_attrib_t att) {
60 ENTER_ANALYZER_FUNCTION();
61
62 XCamReturn ret = XCAM_RETURN_NO_ERROR;
63 mCfgMutex.lock();
64 #ifdef DISABLE_HANDLE_ATTRIB
65 ret = rk_aiq_uapi_asd_SetAttrib(mAlgoCtx, att, false);
66 #else
67 // TODO
68 // check if there is different between att & mCurAtt
69 // if something changed, set att to mNewAtt, and
70 // the new params will be effective later when updateConfig
71 // called by RkAiqCore
72
73 // if something changed
74 if (0 != memcmp(&mCurAtt, &att, sizeof(asd_attrib_t))) {
75 mNewAtt = att;
76 updateAtt = true;
77 waitSignal();
78 }
79 #endif
80
81 mCfgMutex.unlock();
82
83 EXIT_ANALYZER_FUNCTION();
84 return ret;
85 }
86
getAttrib(asd_attrib_t * att)87 XCamReturn RkAiqAsdHandleInt::getAttrib(asd_attrib_t* att) {
88 ENTER_ANALYZER_FUNCTION();
89
90 XCamReturn ret = XCAM_RETURN_NO_ERROR;
91
92 rk_aiq_uapi_asd_GetAttrib(mAlgoCtx, att);
93
94 EXIT_ANALYZER_FUNCTION();
95 return ret;
96 }
97
prepare()98 XCamReturn RkAiqAsdHandleInt::prepare() {
99 ENTER_ANALYZER_FUNCTION();
100
101 XCamReturn ret = XCAM_RETURN_NO_ERROR;
102
103 ret = RkAiqHandle::prepare();
104 RKAIQCORE_CHECK_RET(ret, "asd handle prepare failed");
105
106 RkAiqAlgoConfigAsd* asd_config_int = (RkAiqAlgoConfigAsd*)mConfig;
107 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
108 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
109
110 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
111 ret = des->prepare(mConfig);
112 RKAIQCORE_CHECK_RET(ret, "asd algo prepare failed");
113
114 EXIT_ANALYZER_FUNCTION();
115 return XCAM_RETURN_NO_ERROR;
116 }
117
preProcess()118 XCamReturn RkAiqAsdHandleInt::preProcess() {
119 ENTER_ANALYZER_FUNCTION();
120
121 XCamReturn ret = XCAM_RETURN_NO_ERROR;
122
123 RkAiqAlgoPreAsd* asd_pre_int = (RkAiqAlgoPreAsd*)mPreInParam;
124 RkAiqAlgoPreResAsd* asd_pre_res_int = (RkAiqAlgoPreResAsd*)mPreOutParam;
125 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
126 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
127 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
128
129 ret = RkAiqHandle::preProcess();
130 if (ret) {
131 RKAIQCORE_CHECK_RET(ret, "asd handle preProcess failed");
132 }
133
134 asd_pre_int->pre_params.cpsl_mode = sharedCom->cpslCfg.mode;
135 asd_pre_int->pre_params.cpsl_on = sharedCom->cpslCfg.u.m.on;
136 asd_pre_int->pre_params.cpsl_sensitivity = sharedCom->cpslCfg.u.a.sensitivity;
137 asd_pre_int->pre_params.cpsl_sw_interval = sharedCom->cpslCfg.u.a.sw_interval;
138 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
139 ret = des->pre_process(mPreInParam, mPreOutParam);
140 RKAIQCORE_CHECK_RET(ret, "asd algo pre_process failed");
141
142 EXIT_ANALYZER_FUNCTION();
143 return XCAM_RETURN_NO_ERROR;
144 }
145
processing()146 XCamReturn RkAiqAsdHandleInt::processing() {
147 ENTER_ANALYZER_FUNCTION();
148
149 XCamReturn ret = XCAM_RETURN_NO_ERROR;
150
151 RkAiqAlgoProcAsd* asd_proc_int = (RkAiqAlgoProcAsd*)mProcInParam;
152 RkAiqAlgoProcResAsd* asd_proc_res_int = (RkAiqAlgoProcResAsd*)mProcOutParam;
153 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
154 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
155 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
156
157 ret = RkAiqHandle::processing();
158 if (ret) {
159 RKAIQCORE_CHECK_RET(ret, "asd handle processing failed");
160 }
161
162 #ifdef DISABLE_HANDLE_ATTRIB
163 mCfgMutex.lock();
164 #endif
165 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
166 ret = des->processing(mProcInParam, mProcOutParam);
167 #ifdef DISABLE_HANDLE_ATTRIB
168 mCfgMutex.unlock();
169 #endif
170 RKAIQCORE_CHECK_RET(ret, "asd algo processing failed");
171
172 EXIT_ANALYZER_FUNCTION();
173 return ret;
174 }
175
postProcess()176 XCamReturn RkAiqAsdHandleInt::postProcess() {
177 ENTER_ANALYZER_FUNCTION();
178
179 XCamReturn ret = XCAM_RETURN_NO_ERROR;
180 #if 0
181 RkAiqAlgoPostAsd* asd_post_int = (RkAiqAlgoPostAsd*)mPostInParam;
182 RkAiqAlgoPostResAsd* asd_post_res_int = (RkAiqAlgoPostResAsd*)mPostOutParam;
183 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
184 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
185 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
186
187 ret = RkAiqHandle::postProcess();
188 if (ret) {
189 RKAIQCORE_CHECK_RET(ret, "asd handle postProcess failed");
190 return ret;
191 }
192
193 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
194 ret = des->post_process(mPostInParam, mPostOutParam);
195 RKAIQCORE_CHECK_RET(ret, "asd algo post_process failed");
196
197 EXIT_ANALYZER_FUNCTION();
198 #endif
199 return ret;
200 }
201
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)202 XCamReturn RkAiqAsdHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
203 ENTER_ANALYZER_FUNCTION();
204
205 XCamReturn ret = XCAM_RETURN_NO_ERROR;
206 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
207 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
208 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
209 RkAiqAlgoPreResAsd* asd_pre_res_int = (RkAiqAlgoPreResAsd*)mPreOutParam;
210
211 if (!asd_pre_res_int) {
212 LOGD_ANALYZER("no asd result");
213 return XCAM_RETURN_NO_ERROR;
214 }
215
216 if (!this->getAlgoId()) {
217 mAiqCore->genCpslResult(params, asd_pre_res_int);
218 cur_params->mCpslParams = params->mCpslParams;
219 }
220
221 EXIT_ANALYZER_FUNCTION();
222
223 return ret;
224 }
225
226 } // namespace RkCam
227