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
17 #include "RkAiqAfdHandle.h"
18 #include "RkAiqAeHandle.h"
19 #include "RkAiqCore.h"
20
21 namespace RkCam {
22
23 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAfdHandleInt);
24
init()25 void RkAiqAfdHandleInt::init() {
26 ENTER_ANALYZER_FUNCTION();
27
28 RkAiqHandle::deInit();
29 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAfd());
30 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAfd());
31 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAfd());
32 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAfd());
33 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAfd());
34
35 EXIT_ANALYZER_FUNCTION();
36 }
37
updateConfig(bool needSync)38 XCamReturn RkAiqAfdHandleInt::updateConfig(bool needSync) {
39 ENTER_ANALYZER_FUNCTION();
40
41 XCamReturn ret = XCAM_RETURN_NO_ERROR;
42
43 #if 0
44 if (needSync) mCfgMutex.lock();
45 // if something changed
46 if (updateAtt) {
47 updateAtt = false;
48 sendSignal(mCurAtt.sync.sync_mode);
49 }
50 if (needSync) mCfgMutex.unlock();
51 EXIT_ANALYZER_FUNCTION();
52 #endif
53
54 return ret;
55 }
56
getScaleRatio(int * scale_ratio)57 XCamReturn RkAiqAfdHandleInt::getScaleRatio(int* scale_ratio) {
58 ENTER_ANALYZER_FUNCTION();
59
60 XCamReturn ret = XCAM_RETURN_NO_ERROR;
61
62 Uapi_AfdAttr_t AfdAttr;
63 rk_aiq_uapi_afd_v2_GetAttr(mAlgoCtx, &AfdAttr);
64 *scale_ratio = AfdAttr.scale_ratio;
65
66 EXIT_ANALYZER_FUNCTION();
67 return ret;
68 }
69
getAfdEn(bool * en)70 XCamReturn RkAiqAfdHandleInt::getAfdEn(bool* en) {
71 ENTER_ANALYZER_FUNCTION();
72
73 XCamReturn ret = XCAM_RETURN_NO_ERROR;
74
75 Uapi_AfdAttr_t AfdAttr;
76 rk_aiq_uapi_afd_v2_GetAttr(mAlgoCtx, &AfdAttr);
77 *en = AfdAttr.enable;
78
79 EXIT_ANALYZER_FUNCTION();
80 return ret;
81 }
82
prepare()83 XCamReturn RkAiqAfdHandleInt::prepare() {
84 ENTER_ANALYZER_FUNCTION();
85 XCamReturn ret = XCAM_RETURN_NO_ERROR;
86
87 ret = RkAiqHandle::prepare();
88 RKAIQCORE_CHECK_RET(ret, "afd handle prepare failed");
89
90 // TODO config ae common params:
91 RkAiqAlgoConfigAfd* afd_config = (RkAiqAlgoConfigAfd*)mConfig;
92 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
93
94 /*****************AfdConfig Sensor Exp related info*****************/
95 afd_config->LinePeriodsPerField = (float)sharedCom->snsDes.frame_length_lines;
96 afd_config->PixelPeriodsPerLine = (float)sharedCom->snsDes.line_length_pck;
97 afd_config->PixelClockFreqMHZ = (float) sharedCom->snsDes.pixel_clock_freq_mhz;
98
99 /*****************AecConfig pic-info params*****************/
100 afd_config->RawWidth = sharedCom->snsDes.isp_acq_width;
101 afd_config->RawHeight = sharedCom->snsDes.isp_acq_height;
102
103 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
104 ret = des->prepare(mConfig);
105 RKAIQCORE_CHECK_RET(ret, "afd algo prepare failed");
106
107 EXIT_ANALYZER_FUNCTION();
108 return XCAM_RETURN_NO_ERROR;
109
110 }
111
preProcess()112 XCamReturn RkAiqAfdHandleInt::preProcess() {
113 ENTER_ANALYZER_FUNCTION();
114
115 XCamReturn ret = XCAM_RETURN_NO_ERROR;
116
117 RkAiqAlgoPreAfd* afd_pre_int = (RkAiqAlgoPreAfd*)mPreInParam;
118 RkAiqAlgoPreResAfd* afd_pre_res_int = (RkAiqAlgoPreResAfd*)mPreOutParam;
119 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
120 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
121 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
122
123 afd_pre_int->aeProcRes = &mAeProcRes;
124
125 ret = RkAiqHandle::preProcess();
126 if (ret) {
127 RKAIQCORE_CHECK_RET(ret, "afd handle preProcess failed");
128 }
129
130 if(sharedCom->init)
131 {
132 LOGV("init: no thumb data, ignore!");
133 return XCAM_RETURN_NO_ERROR;
134 }
135 else
136 {
137 if(shared->scaleRawInfo.raw_s) {
138 afd_pre_int->thumbStatsS = shared->scaleRawInfo.raw_s;
139 afd_pre_int->thumbH = shared->scaleRawInfo.raw_s->info.height;
140 afd_pre_int->thumbW = shared->scaleRawInfo.raw_s->info.width;
141 } else {
142 afd_pre_int->thumbStatsS = NULL;
143 }
144
145 if((rk_aiq_working_mode_t)sharedCom->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2) {
146 if(shared->scaleRawInfo.raw_l) {
147 afd_pre_int->thumbStatsL = shared->scaleRawInfo.raw_l;
148 } else {
149 afd_pre_int->thumbStatsL = NULL;
150 }
151 }
152 }
153
154 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
155 ret = des->pre_process(mPreInParam, mPreOutParam);
156 RKAIQCORE_CHECK_RET(ret, "afd algo pre_process failed");
157
158 EXIT_ANALYZER_FUNCTION();
159 return XCAM_RETURN_NO_ERROR;
160 }
161
processing()162 XCamReturn RkAiqAfdHandleInt::processing() {
163 ENTER_ANALYZER_FUNCTION();
164
165 XCamReturn ret = XCAM_RETURN_NO_ERROR;
166
167 RkAiqAlgoProcAfd* afd_proc_int = (RkAiqAlgoProcAfd*)mProcInParam;
168 RkAiqAlgoProcResAfd* afd_proc_res_int =
169 (RkAiqAlgoProcResAfd*)mProcOutParam;
170 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
171 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
172 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
173
174 ret = RkAiqHandle::processing();
175 if (ret) {
176 RKAIQCORE_CHECK_RET(ret, "afd handle processing failed");
177 }
178
179 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
180 ret = des->processing(mProcInParam, mProcOutParam);
181 RKAIQCORE_CHECK_RET(ret, "afd algo processing failed");
182
183 #if RKAIQ_HAVE_AFD_V2
184 RkAiqAlgoProcResAfd* afd_res = (RkAiqAlgoProcResAfd*)mProcOutParam;
185 SmartPtr<RkAiqHandle>* ae_handle = mAiqCore->getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AE);
186 int algo_id = (*ae_handle)->getAlgoId();
187
188 if (ae_handle) {
189 if (algo_id == 0) {
190 RkAiqAeHandleInt* ae_algo = dynamic_cast<RkAiqAeHandleInt*>(ae_handle->ptr());
191 ae_algo->getAfdResForAE(afd_res->afdRes.PeakRes);
192 }
193 }
194 #endif
195
196 EXIT_ANALYZER_FUNCTION();
197 return ret;
198 }
199
postProcess()200 XCamReturn RkAiqAfdHandleInt::postProcess() {
201 ENTER_ANALYZER_FUNCTION();
202
203 XCamReturn ret = XCAM_RETURN_NO_ERROR;
204 #if 0
205 RkAiqAlgoPostAfd* afd_post_int = (RkAiqAlgoPostAfd*)mPostInParam;
206 RkAiqAlgoPostResAfd* afd_post_res_int =
207 (RkAiqAlgoPostResAfd*)mPostOutParam;
208 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
209 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
210 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
211
212 ret = RkAiqHandle::postProcess();
213 if (ret) {
214 RKAIQCORE_CHECK_RET(ret, "afd handle postProcess failed");
215 return ret;
216 }
217
218 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
219 ret = des->post_process(mPostInParam, mPostOutParam);
220 RKAIQCORE_CHECK_RET(ret, "afd algo post_process failed");
221
222 EXIT_ANALYZER_FUNCTION();
223 #endif
224 return ret;
225 }
226
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)227 XCamReturn RkAiqAfdHandleInt::genIspResult(RkAiqFullParams* params,
228 RkAiqFullParams* cur_params) {
229 ENTER_ANALYZER_FUNCTION();
230 XCamReturn ret = XCAM_RETURN_NO_ERROR;
231 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
232 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
233 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
234 RkAiqAlgoProcResAfd* afd_com = (RkAiqAlgoProcResAfd*)mProcOutParam;
235 rk_aiq_isp_afd_params_t* afd_param = params->mAfdParams->data().ptr();
236 afd_param->result.enable = mAeProcRes.IsAutoAfd;
237 getScaleRatio(&afd_param->result.ratio);
238 cur_params->mAfdParams = params->mAfdParams;
239 if (!afd_com) {
240 LOGD_ANALYZER("no afd result");
241 return XCAM_RETURN_NO_ERROR;
242 }
243 if (mAfdSyncAly != afd_param->result.enable) {
244 mAfdSyncAly = afd_param->result.enable;
245 mAiqCore->setVicapScaleFlag(mAfdSyncAly);
246 }
247
248 EXIT_ANALYZER_FUNCTION();
249
250 return ret;
251 }
252
253 } // namespace RkCam
254