1 /*
2 * rk_aiq_accm_algo_v1.cpp
3
4 * for rockchip v2.0.0
5 *
6 * Copyright (c) 2019 Rockchip Corporation
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 */
21 /* for rockchip v2.0.0*/
22
23 #include "accm/rk_aiq_accm_algo_com.h"
24 #include "interpolation.h"
25 #include "xcam_log.h"
26
27 RKAIQ_BEGIN_DECLARE
28
CCMV2PrintReg(const rk_aiq_ccm_cfg_v2_t * hw_param)29 void CCMV2PrintReg(const rk_aiq_ccm_cfg_v2_t* hw_param) {
30 LOG1_ACCM(
31 " CCM V2 reg values: "
32 " sw_ccm_asym_adj_en %d"
33 " sw_ccm_enh_adj_en %d"
34 " sw_ccm_highy_adjust %d"
35 " sw_ccm_en_i %d"
36 " sw_ccm_coeff ([%f,%f,%f,%f,%f,%f,%f,%f,%f]-E)X128"
37 " sw_ccm_offset [%f,%f,%f]"
38 " sw_ccm_coeff_y [%f,%f,%f]"
39 " sw_ccm_alp_y [%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f]"
40 " sw_ccm_right_bit %f"
41 " sw_ccm_bound_bit %f"
42 " sw_ccm_color_coef_y [%d,%d,%d]"
43 " sw_ccm_color_enh_rat_max %f",
44 hw_param->asym_adj_en, hw_param->enh_adj_en, hw_param->highy_adj_en, hw_param->ccmEnable,
45 hw_param->matrix[0], hw_param->matrix[1], hw_param->matrix[2], hw_param->matrix[3],
46 hw_param->matrix[4], hw_param->matrix[5], hw_param->matrix[6], hw_param->matrix[7],
47 hw_param->matrix[8], hw_param->offs[0], hw_param->offs[1], hw_param->offs[2],
48 hw_param->rgb2y_para[0], hw_param->rgb2y_para[1], hw_param->rgb2y_para[2],
49 hw_param->alp_y[0], hw_param->alp_y[1], hw_param->alp_y[2], hw_param->alp_y[3],
50 hw_param->alp_y[4], hw_param->alp_y[5], hw_param->alp_y[6], hw_param->alp_y[7],
51 hw_param->alp_y[8], hw_param->alp_y[9], hw_param->alp_y[10], hw_param->alp_y[11],
52 hw_param->alp_y[12], hw_param->alp_y[13], hw_param->alp_y[14], hw_param->alp_y[15],
53 hw_param->alp_y[16], hw_param->alp_y[17], hw_param->right_bit, hw_param->bound_bit,
54 hw_param->enh_rgb2y_para[0], hw_param->enh_rgb2y_para[1], hw_param->enh_rgb2y_para[2],
55 hw_param->enh_rat_max);
56 }
57
CCMV2PrintDBG(const accm_context_t * accm_context)58 void CCMV2PrintDBG(const accm_context_t* accm_context) {
59 const CalibDbV2_Ccm_Para_V32_t* pCcm = accm_context->ccm_v2;
60 const float* pMatrixUndamped = accm_context->accmRest.undampedCcmMatrix;
61 const float* pOffsetUndamped = accm_context->accmRest.undampedCcOffset;
62 const float* pMatrixDamped = accm_context->ccmHwConf_v2.matrix;
63 const float* pOffsetDamped = accm_context->ccmHwConf_v2.offs;
64
65 LOG1_ACCM(
66 "Illu Probability Estimation Enable: %d"
67 "color_inhibition sensorGain: %f,%f,%f,%f "
68 "color_inhibition level: %f,%f,%f,%f"
69 "color_saturation sensorGain: %f,%f,%f,%f "
70 "color_saturation level: %f,%f,%f,%f"
71 "dampfactor: %f"
72 " undampedCcmMatrix: %f,%f,%f,%f,%f,%f,%f,%f,%f"
73 " undampedCcOffset: %f,%f,%f "
74 " dampedCcmMatrix: %f,%f,%f,%f,%f,%f,%f,%f,%f"
75 " dampedCcOffset:%f,%f,%f",
76 pCcm->TuningPara.illu_estim.interp_enable,
77 accm_context->mCurAttV2.stAuto.color_inhibition.sensorGain[0],
78 accm_context->mCurAttV2.stAuto.color_inhibition.sensorGain[1],
79 accm_context->mCurAttV2.stAuto.color_inhibition.sensorGain[2],
80 accm_context->mCurAttV2.stAuto.color_inhibition.sensorGain[3],
81 accm_context->mCurAttV2.stAuto.color_inhibition.level[0],
82 accm_context->mCurAttV2.stAuto.color_inhibition.level[1],
83 accm_context->mCurAttV2.stAuto.color_inhibition.level[2],
84 accm_context->mCurAttV2.stAuto.color_inhibition.level[3],
85 accm_context->mCurAttV2.stAuto.color_saturation.sensorGain[0],
86 accm_context->mCurAttV2.stAuto.color_saturation.sensorGain[1],
87 accm_context->mCurAttV2.stAuto.color_saturation.sensorGain[2],
88 accm_context->mCurAttV2.stAuto.color_saturation.sensorGain[3],
89 accm_context->mCurAttV2.stAuto.color_saturation.level[0],
90 accm_context->mCurAttV2.stAuto.color_saturation.level[1],
91 accm_context->mCurAttV2.stAuto.color_saturation.level[2],
92 accm_context->mCurAttV2.stAuto.color_saturation.level[3], pCcm->TuningPara.damp_enable,
93 pMatrixUndamped[0], pMatrixUndamped[1], pMatrixUndamped[2], pMatrixUndamped[3],
94 pMatrixUndamped[4], pMatrixUndamped[5], pMatrixUndamped[6], pMatrixUndamped[7],
95 pMatrixUndamped[8], pOffsetUndamped[0], pOffsetUndamped[1], pOffsetUndamped[2],
96 pMatrixDamped[0], pMatrixDamped[1], pMatrixDamped[2], pMatrixDamped[3], pMatrixDamped[4],
97 pMatrixDamped[5], pMatrixDamped[6], pMatrixDamped[7], pMatrixDamped[8], pOffsetDamped[0],
98 pOffsetDamped[1], pOffsetDamped[2]);
99 }
100
AccmAutoConfig(accm_handle_t hAccm)101 XCamReturn AccmAutoConfig(accm_handle_t hAccm) {
102 LOG1_ACCM("%s: (enter)\n", __FUNCTION__);
103
104 XCamReturn ret = XCAM_RETURN_NO_ERROR;
105
106 if (hAccm == NULL) {
107 return XCAM_RETURN_ERROR_PARAM;
108 }
109
110 const CalibDbV2_Ccm_Para_V32_t* pCcm = NULL;
111 float sensorGain = hAccm->accmSwInfo.sensorGain;
112 float fSaturation = 0;
113 pCcm = hAccm->ccm_v2;
114 if (hAccm->update) {
115 if (pCcm->TuningPara.illu_estim.interp_enable) {
116 hAccm->isReCal_ = true;
117 ret = interpCCMbywbgain(&pCcm->TuningPara, hAccm, fSaturation);
118 RETURN_RESULT_IF_DIFFERENT(ret, XCAM_RETURN_NO_ERROR);
119 } else {
120 ret = selectCCM(&pCcm->TuningPara, hAccm, fSaturation);
121 RETURN_RESULT_IF_DIFFERENT(ret, XCAM_RETURN_NO_ERROR);
122 }
123 }
124 // 4) calc scale for y_alpha_curve and
125 if (hAccm->update || hAccm->updateAtt) {
126 float fScale = 1.0;
127 #if 1
128 // real use
129 interpolation(pCcm->lumaCCM.gain_alphaScale_curve.gain,
130 pCcm->lumaCCM.gain_alphaScale_curve.scale, 9, sensorGain, &fScale);
131 #else
132 // for test, to be same with demo
133 for (int i = 0; i < 9; i++) {
134 int j = uint16_t(sensorGain);
135 j = (j > (1 << 8)) ? (1 << 8) : j;
136
137 if (j <= (1 << i)) {
138 fScale = pCcm->lumaCCM.gain_alphaScale_curve.scale[i];
139 break;
140 }
141 }
142 #endif
143 // 5) color inhibition adjust for api
144 interpolation(hAccm->mCurAttV2.stAuto.color_inhibition.sensorGain,
145 hAccm->mCurAttV2.stAuto.color_inhibition.level, RK_AIQ_ACCM_COLOR_GAIN_NUM,
146 sensorGain, &hAccm->accmRest.color_inhibition_level);
147
148 if (hAccm->accmRest.color_inhibition_level > 100 || hAccm->accmRest.color_inhibition_level < 0) {
149 LOGE_ACCM("flevel2: %f is out of range [0 100]\n", hAccm->accmRest.color_inhibition_level);
150 return XCAM_RETURN_ERROR_PARAM;
151 }
152
153 fScale *= (100 - hAccm->accmRest.color_inhibition_level) / 100;
154
155 // 6) saturation adjust for api
156 float saturation_level = 100;
157 interpolation(hAccm->mCurAttV2.stAuto.color_saturation.sensorGain,
158 hAccm->mCurAttV2.stAuto.color_saturation.level, RK_AIQ_ACCM_COLOR_GAIN_NUM,
159 sensorGain, &saturation_level);
160
161 if (saturation_level > 100 || saturation_level < 0) {
162 LOGE_ACCM("flevel1: %f is out of range [0 100]\n", saturation_level);
163 return XCAM_RETURN_ERROR_PARAM;
164 }
165
166 LOGD_ACCM("CcmProfile changed: %d, fScale: %f->%f, sat_level: %f->%f",
167 hAccm->isReCal_, hAccm->accmRest.fScale, fScale,
168 hAccm->accmRest.color_saturation_level, saturation_level);
169
170 hAccm->isReCal_ = hAccm->isReCal_ ||
171 fabs(fScale - hAccm->accmRest.fScale) > DIVMIN ||
172 fabs(saturation_level - hAccm->accmRest.color_saturation_level) > DIVMIN;
173
174 if (hAccm->isReCal_) {
175 hAccm->accmRest.fScale = fScale;
176 hAccm->accmRest.color_saturation_level = saturation_level;
177 Saturationadjust(fScale, saturation_level, hAccm->accmRest.undampedCcmMatrix);
178 LOGD_ACCM("Adjust ccm by sat: %d, undampedCcmMatrix[0]: %f", hAccm->isReCal_, hAccm->accmRest.undampedCcmMatrix[0]);
179
180 if (pCcm->lumaCCM.asym_enable) {
181 int mid = CCM_CURVE_DOT_NUM_V2 >> 1;
182 for (int i = 0; i < mid; i++) {
183 hAccm->ccmHwConf_v2.alp_y[i] =
184 fScale * pCcm->lumaCCM.y_alp_asym.y_alpha_left_curve[i];
185 hAccm->ccmHwConf_v2.alp_y[mid + i] =
186 fScale * pCcm->lumaCCM.y_alp_asym.y_alpha_right_curve[i];
187 }
188 } else {
189 for (int i = 0; i < CCM_CURVE_DOT_NUM; i++) { // set to ic to do bit check
190 hAccm->ccmHwConf_v2.alp_y[i] = fScale * pCcm->lumaCCM.y_alp_sym.y_alpha_curve[i];
191 }
192 hAccm->ccmHwConf_v2.alp_y[CCM_CURVE_DOT_NUM] = 1024;
193 }
194 }
195 }
196 // 7) . Damping
197 float dampCoef = (pCcm->TuningPara.damp_enable && (hAccm->count > 1 || hAccm->invarMode > 0)) ? hAccm->accmSwInfo.awbIIRDampCoef : 0;
198 if (!hAccm->accmSwInfo.ccmConverged || hAccm->isReCal_) {
199 ret = Damping(dampCoef,
200 hAccm->accmRest.undampedCcmMatrix, hAccm->ccmHwConf_v2.matrix,
201 hAccm->accmRest.undampedCcOffset, hAccm->ccmHwConf_v2.offs,
202 &hAccm->accmSwInfo.ccmConverged);
203 hAccm->isReCal_ = true;
204 LOGD_ACCM(
205 "damping: %f, ccm coef[0]: %f->%f, ccm coef[8]: %f->%f",
206 dampCoef, hAccm->accmRest.undampedCcmMatrix[0], hAccm->ccmHwConf_v2.matrix[0],
207 hAccm->accmRest.undampedCcmMatrix[8], hAccm->ccmHwConf_v2.matrix[8]);
208 }
209
210 if (hAccm->update) {
211 unsigned short enh_adj_en = 0;
212 float enh_rat_max = 0;
213 interpolation(pCcm->enhCCM.enh_ctl.gains, pCcm->enhCCM.enh_ctl.enh_adj_en, 9,
214 sensorGain, &enh_adj_en);
215 if (enh_adj_en) {
216 interpolation(pCcm->enhCCM.enh_ctl.gains, pCcm->enhCCM.enh_ctl.enh_rat_max, 9,
217 sensorGain, &enh_rat_max);
218 }
219 hAccm->isReCal_ = hAccm->isReCal_ ||
220 (enh_adj_en != hAccm->ccmHwConf_v2.enh_adj_en) ||
221 fabs(enh_rat_max - hAccm->ccmHwConf_v2.enh_rat_max) > DIVMIN;
222 }
223
224 LOGD_ACCM("final isReCal_ = %d \n", hAccm->isReCal_);
225
226 LOG1_ACCM("%s: (exit)\n", __FUNCTION__);
227
228 return (ret);
229 }
230
AccmManualConfig(accm_handle_t hAccm)231 XCamReturn AccmManualConfig(accm_handle_t hAccm) {
232 LOG1_ACCM("%s: (enter)\n", __FUNCTION__);
233
234 XCamReturn ret = XCAM_RETURN_NO_ERROR;
235
236 memcpy(hAccm->ccmHwConf_v2.matrix, hAccm->mCurAttV2.stManual.ccMatrix,
237 sizeof(hAccm->mCurAttV2.stManual.ccMatrix));
238 memcpy(hAccm->ccmHwConf_v2.offs, hAccm->mCurAttV2.stManual.ccOffsets,
239 sizeof(hAccm->mCurAttV2.stManual.ccOffsets));
240 hAccm->ccmHwConf_v2.highy_adj_en = hAccm->mCurAttV2.stManual.highy_adj_en;
241 hAccm->ccmHwConf_v2.asym_adj_en = hAccm->mCurAttV2.stManual.asym_enable;
242 hAccm->ccmHwConf_v2.bound_bit = hAccm->mCurAttV2.stManual.bound_pos_bit;
243 hAccm->ccmHwConf_v2.right_bit = hAccm->mCurAttV2.stManual.right_pos_bit;
244 memcpy(hAccm->ccmHwConf_v2.alp_y, hAccm->mCurAttV2.stManual.y_alpha_curve,
245 sizeof(hAccm->mCurAttV2.stManual.y_alpha_curve));
246
247 memcpy(hAccm->ccmHwConf_v2.enh_rgb2y_para, hAccm->mCurAttV2.stManual.enh_rgb2y_para,
248 sizeof(hAccm->mCurAttV2.stManual.enh_rgb2y_para));
249 hAccm->ccmHwConf_v2.enh_adj_en = hAccm->mCurAttV2.stManual.enh_adj_en;
250 hAccm->ccmHwConf_v2.enh_rat_max = hAccm->mCurAttV2.stManual.enh_rat_max;
251
252 LOG1_ACCM("%s: (exit)\n", __FUNCTION__);
253 return ret;
254 }
255
AccmConfig(accm_handle_t hAccm)256 XCamReturn AccmConfig(accm_handle_t hAccm) {
257 LOG1_ACCM("%s: (enter)\n", __FUNCTION__);
258
259 XCamReturn ret = XCAM_RETURN_NO_ERROR;
260
261 LOGD_ACCM("%s: byPass: %d mode:%d updateAtt: %d \n", __FUNCTION__, hAccm->mCurAttV2.byPass,
262 hAccm->mCurAttV2.mode, hAccm->updateAtt);
263 if (hAccm->mCurAttV2.byPass != true && hAccm->accmSwInfo.grayMode != true) {
264 hAccm->ccmHwConf_v2.ccmEnable = true;
265
266 if (hAccm->mCurAttV2.mode == RK_AIQ_CCM_MODE_AUTO) {
267 hAccm->update = JudgeCcmRes3aConverge(&hAccm->accmRest.res3a_info, &hAccm->accmSwInfo,
268 hAccm->ccm_v2->control.gain_tolerance,
269 hAccm->ccm_v2->control.wbgain_tolerance);
270 hAccm->update = hAccm->update || hAccm->calib_update; // wbgain/gain/calib changed
271 LOGD_ACCM("%s: CCM update (gain/awbgain/calib): %d, CCM Converged: %d\n",
272 __FUNCTION__, hAccm->update, hAccm->accmSwInfo.ccmConverged);
273 if (hAccm->updateAtt || hAccm->update || (!hAccm->accmSwInfo.ccmConverged)) {
274 AccmAutoConfig(hAccm);
275 CCMV2PrintDBG(hAccm);
276 }
277 } else if (hAccm->mCurAttV2.mode == RK_AIQ_CCM_MODE_MANUAL) {
278 if (hAccm->updateAtt) {
279 AccmManualConfig(hAccm);
280 hAccm->isReCal_ = true;
281 }
282 } else {
283 LOGE_ACCM("%s: hAccm->mCurAttV2.mode(%d) is invalid \n", __FUNCTION__,
284 hAccm->mCurAttV2.mode);
285 }
286
287 } else {
288 hAccm->ccmHwConf_v2.ccmEnable = false;
289 // graymode/api/calib changed
290 hAccm->isReCal_ = hAccm->isReCal_ || hAccm->updateAtt || hAccm->calib_update;
291 }
292 hAccm->updateAtt = false;
293 hAccm->calib_update = false;
294 hAccm->count = ((hAccm->count + 2) > (65536)) ? 2 : (hAccm->count + 1);
295
296 CCMV2PrintReg(&hAccm->ccmHwConf_v2);
297
298 LOG1_ACCM("%s: (exit)\n", __FUNCTION__);
299 return ret;
300 }
301
302 /**********************************
303 *Update CCM CalibV2 Para
304 * Prepare init
305 * Mode change: reinit
306 * Res change: continue
307 * Calib change: continue
308 ***************************************/
UpdateCcmCalibV2ParaV2(accm_handle_t hAccm)309 static XCamReturn UpdateCcmCalibV2ParaV2(accm_handle_t hAccm) {
310 LOG1_ACCM("%s: (enter) \n", __FUNCTION__);
311 XCamReturn ret = XCAM_RETURN_NO_ERROR;
312
313 bool config_calib = !!(hAccm->accmSwInfo.prepare_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB);
314 const CalibDbV2_Ccm_Para_V32_t* calib_ccm = hAccm->ccm_v2;
315
316 if (!config_calib) {
317 return (ret);
318 }
319
320 #if RKAIQ_ACCM_ILLU_VOTE
321 ReloadCCMCalibV2(hAccm, &calib_ccm->TuningPara);
322 #endif
323
324 ret = pCcmMatrixAll_init(hAccm, &calib_ccm->TuningPara);
325 if (hAccm->mCurAttV2.mode == RK_AIQ_CCM_MODE_AUTO)
326 hAccm->mCurAttV2.byPass = !(calib_ccm->control.enable);
327
328 hAccm->ccmHwConf_v2.asym_adj_en = calib_ccm->lumaCCM.asym_enable;
329
330 if (calib_ccm->lumaCCM.asym_enable) {
331 hAccm->ccmHwConf_v2.highy_adj_en = true;
332 hAccm->ccmHwConf_v2.bound_bit = calib_ccm->lumaCCM.y_alp_asym.bound_pos_bit;
333 hAccm->ccmHwConf_v2.right_bit = calib_ccm->lumaCCM.y_alp_asym.right_pos_bit;
334 int mid = CCM_CURVE_DOT_NUM_V2 >> 1;
335 for (int i = 0; i < mid; i++) {
336 hAccm->ccmHwConf_v2.alp_y[i] = calib_ccm->lumaCCM.y_alp_asym.y_alpha_left_curve[i];
337 hAccm->ccmHwConf_v2.alp_y[mid + i] =
338 calib_ccm->lumaCCM.y_alp_asym.y_alpha_right_curve[i];
339 }
340 } else {
341 hAccm->ccmHwConf_v2.highy_adj_en = calib_ccm->lumaCCM.y_alp_sym.highy_adj_en;
342 hAccm->ccmHwConf_v2.bound_bit = calib_ccm->lumaCCM.y_alp_sym.bound_pos_bit;
343 hAccm->ccmHwConf_v2.right_bit = hAccm->ccmHwConf_v2.bound_bit;
344 memcpy(hAccm->ccmHwConf_v2.alp_y, calib_ccm->lumaCCM.y_alp_sym.y_alpha_curve,
345 sizeof(calib_ccm->lumaCCM.y_alp_sym.y_alpha_curve));
346 hAccm->ccmHwConf_v2.alp_y[CCM_CURVE_DOT_NUM] = 1024;
347 }
348
349 memcpy(hAccm->ccmHwConf_v2.rgb2y_para, calib_ccm->lumaCCM.rgb2y_para,
350 sizeof(calib_ccm->lumaCCM.rgb2y_para));
351
352 memcpy(hAccm->ccmHwConf_v2.enh_rgb2y_para, calib_ccm->enhCCM.enh_rgb2y_para,
353 sizeof(calib_ccm->enhCCM.enh_rgb2y_para));
354
355 hAccm->ccmHwConf_v2.enh_adj_en = calib_ccm->enhCCM.enh_ctl.enh_adj_en[0];
356 hAccm->ccmHwConf_v2.enh_rat_max = calib_ccm->enhCCM.enh_ctl.enh_rat_max[0];
357
358 hAccm->accmSwInfo.ccmConverged = false;
359 hAccm->calib_update = true;
360
361 clear_list(&hAccm->accmRest.problist);
362
363 LOG1_ACCM("%s: (exit)\n", __FUNCTION__);
364 return (ret);
365 }
366
AccmInit(accm_handle_t * hAccm,const CamCalibDbV2Context_t * calibv2)367 XCamReturn AccmInit(accm_handle_t* hAccm, const CamCalibDbV2Context_t* calibv2) {
368 LOGI_ACCM("%s: (enter)\n", __FUNCTION__);
369
370 XCamReturn ret = XCAM_RETURN_NO_ERROR;
371
372 if (calibv2 == NULL) {
373 return XCAM_RETURN_ERROR_PARAM;
374 }
375
376 const CalibDbV2_Ccm_Para_V32_t* calib_ccm =
377 (CalibDbV2_Ccm_Para_V32_t*)(CALIBDBV2_GET_MODULE_PTR((void*)calibv2, ccm_calib_v2));
378 if (calib_ccm == NULL) return XCAM_RETURN_ERROR_MEM;
379
380 *hAccm = (accm_context_t*)malloc(sizeof(accm_context_t));
381 accm_context_t* accm_context = *hAccm;
382 memset(accm_context, 0, sizeof(accm_context_t));
383
384 accm_context->accmSwInfo.sensorGain = 1.0;
385 accm_context->accmSwInfo.awbIIRDampCoef = 0;
386 accm_context->accmSwInfo.varianceLuma = 255;
387 accm_context->accmSwInfo.awbConverged = false;
388
389 accm_context->accmSwInfo.awbGain[0] = 1;
390 accm_context->accmSwInfo.awbGain[1] = 1;
391
392 accm_context->accmRest.res3a_info.sensorGain = 1.0;
393 accm_context->accmRest.res3a_info.awbGain[0] = 1.0;
394 accm_context->accmRest.res3a_info.awbGain[1] = 1.0;
395
396 accm_context->count = 0;
397 accm_context->isReCal_ = 1;
398 accm_context->invarMode = 1;
399
400 accm_context->accmSwInfo.prepare_type =
401 RK_AIQ_ALGO_CONFTYPE_UPDATECALIB | RK_AIQ_ALGO_CONFTYPE_NEEDRESET;
402
403 // todo whm --- CalibDbV2_Ccm_Para_V2
404 accm_context->ccm_v2 = calib_ccm;
405 accm_context->mCurAttV2.mode = RK_AIQ_CCM_MODE_AUTO;
406 #if RKAIQ_ACCM_ILLU_VOTE
407 INIT_LIST_HEAD(&accm_context->accmRest.dominateIlluList);
408 #endif
409 INIT_LIST_HEAD(&accm_context->accmRest.problist);
410 ret = UpdateCcmCalibV2ParaV2(accm_context);
411
412
413 for (int i = 0; i < RK_AIQ_ACCM_COLOR_GAIN_NUM; i++) {
414 accm_context->mCurAttV2.stAuto.color_inhibition.sensorGain[i] = 1;
415 accm_context->mCurAttV2.stAuto.color_inhibition.level[i] = 0;
416 accm_context->mCurAttV2.stAuto.color_saturation.sensorGain[i] = 1;
417 accm_context->mCurAttV2.stAuto.color_saturation.level[i] = 50;
418 }
419 accm_context->accmRest.fScale = 1;
420 accm_context->accmRest.color_inhibition_level = 0;
421 accm_context->accmRest.color_saturation_level = 100;
422
423 LOGI_ACCM("%s: (exit)\n", __FUNCTION__);
424 return (ret);
425 }
426
AccmRelease(accm_handle_t hAccm)427 XCamReturn AccmRelease(accm_handle_t hAccm) {
428 LOGI_ACCM("%s: (enter)\n", __FUNCTION__);
429
430 XCamReturn ret = XCAM_RETURN_NO_ERROR;
431 #if RKAIQ_ACCM_ILLU_VOTE
432 clear_list(&hAccm->accmRest.dominateIlluList);
433 #endif
434 clear_list(&hAccm->accmRest.problist);
435 free(hAccm);
436 hAccm = NULL;
437
438 LOGI_ACCM("%s: (exit)\n", __FUNCTION__);
439 return (ret);
440 }
441
442 // todo whm
AccmPrepare(accm_handle_t hAccm)443 XCamReturn AccmPrepare(accm_handle_t hAccm) {
444 LOGI_ACCM("%s: (enter)\n", __FUNCTION__);
445
446 XCamReturn ret = XCAM_RETURN_NO_ERROR;
447
448 ret = UpdateCcmCalibV2ParaV2(hAccm);
449 RETURN_RESULT_IF_DIFFERENT(ret, XCAM_RETURN_NO_ERROR);
450
451 LOGI_ACCM("%s: (exit)\n", __FUNCTION__);
452 return ret;
453 }
454
AccmPreProc(accm_handle_t hAccm)455 XCamReturn AccmPreProc(accm_handle_t hAccm) {
456 LOG1_ACCM("%s: (enter)\n", __FUNCTION__);
457
458 XCamReturn ret = XCAM_RETURN_NO_ERROR;
459
460 LOG1_ACCM("%s: (exit)\n", __FUNCTION__);
461 return (ret);
462 }
AccmProcessing(accm_handle_t hAccm)463 XCamReturn AccmProcessing(accm_handle_t hAccm) {
464 LOG1_ACCM("%s: (enter)\n", __FUNCTION__);
465
466 XCamReturn ret = XCAM_RETURN_NO_ERROR;
467
468 LOG1_ACCM("%s: (exit)\n", __FUNCTION__);
469 return (ret);
470 }
471
472 RKAIQ_END_DECLARE
473