1 /*
2 * rk_aiq_algo_adhaz_itf.c
3 *
4 * Copyright (c) 2019 Rockchip Corporation
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 */
19 /* for rockchip v2.0.0*/
20
21 #include "rk_aiq_algo_adehaze_itf.h"
22
23 #include "RkAiqCalibDbTypes.h"
24 #if RKAIQ_HAVE_DEHAZE_V10
25 #include "adehaze/rk_aiq_adehaze_algo_v10.h"
26 #endif
27 #if RKAIQ_HAVE_DEHAZE_V11
28 #include "adehaze/rk_aiq_adehaze_algo_v11.h"
29 #endif
30 #if RKAIQ_HAVE_DEHAZE_V11_DUO
31 #include "adehaze/rk_aiq_adehaze_algo_v11_duo.h"
32 #endif
33 #if RKAIQ_HAVE_DEHAZE_V12
34 #include "adehaze/rk_aiq_adehaze_algo_v12.h"
35 #endif
36 #include "RkAiqCalibDbTypes.h"
37 #include "rk_aiq_algo_types.h"
38 #include "xcam_log.h"
39
40 RKAIQ_BEGIN_DECLARE
41
create_context(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)42 static XCamReturn create_context(RkAiqAlgoContext** context, const AlgoCtxInstanceCfg* cfg) {
43 LOG1_ADEHAZE("ENTER: %s \n", __func__);
44 XCamReturn ret = XCAM_RETURN_NO_ERROR;
45 AdehazeHandle_t* pAdehazeHandle = NULL;
46
47 ret = AdehazeInit(&pAdehazeHandle, (CamCalibDbV2Context_t*)(cfg->calibv2));
48
49 if (ret != XCAM_RETURN_NO_ERROR) {
50 LOGE_ADEHAZE("%s Adehaze Init failed: %d", __FUNCTION__, ret);
51 return (XCAM_RETURN_ERROR_FAILED);
52 }
53
54 *context = (RkAiqAlgoContext*)(pAdehazeHandle);
55
56 LOG1_ADEHAZE("EIXT: %s \n", __func__);
57 return ret;
58 }
59
destroy_context(RkAiqAlgoContext * context)60 static XCamReturn destroy_context(RkAiqAlgoContext* context) {
61 LOG1_ADEHAZE("ENTER: %s \n", __func__);
62 XCamReturn ret = XCAM_RETURN_NO_ERROR;
63 AdehazeHandle_t* pAdehazeHandle = (AdehazeHandle_t*)context;
64
65 ret = AdehazeRelease(pAdehazeHandle);
66
67 LOG1_ADEHAZE("EIXT: %s \n", __func__);
68 return ret;
69 }
70
prepare(RkAiqAlgoCom * params)71 static XCamReturn prepare(RkAiqAlgoCom* params) {
72 LOG1_ADEHAZE("ENTER: %s \n", __func__);
73
74 XCamReturn ret = XCAM_RETURN_NO_ERROR;
75
76 RkAiqAlgoConfigAdhaz* config = (RkAiqAlgoConfigAdhaz*)params;
77 AdehazeHandle_t* pAdehazeHandle = (AdehazeHandle_t*)params->ctx;
78 const CamCalibDbV2Context_t* pCalibDb = config->com.u.prepare.calibv2;
79
80 pAdehazeHandle->working_mode = config->com.u.prepare.working_mode;
81 pAdehazeHandle->is_multi_isp_mode = config->is_multi_isp_mode;
82 pAdehazeHandle->width = config->com.u.prepare.sns_op_width;
83 pAdehazeHandle->height = config->com.u.prepare.sns_op_height;
84
85 if (pAdehazeHandle->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR2)
86 pAdehazeHandle->FrameNumber = LINEAR_NUM;
87 else if (pAdehazeHandle->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3 &&
88 pAdehazeHandle->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2)
89 pAdehazeHandle->FrameNumber = HDR_2X_NUM;
90 else
91 pAdehazeHandle->FrameNumber = HDR_3X_NUM;
92
93 if (!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB)) {
94 LOGD_ADEHAZE("%s: Adehaze Reload Para!\n", __FUNCTION__);
95 #if RKAIQ_HAVE_DEHAZE_V10
96 CalibDbV2_dehaze_v10_t* calibv2_adehaze_calib_V10 =
97 (CalibDbV2_dehaze_v10_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adehaze_calib));
98 if (calibv2_adehaze_calib_V10) {
99 memcpy(&pAdehazeHandle->CalibV10, calibv2_adehaze_calib_V10,
100 sizeof(CalibDbV2_dehaze_v10_t));
101 // memcpy(&pAdehazeHandle->AdehazeAtrrV10., calibv2_adehaze_calib_V10,
102 // sizeof(CalibDbV2_dehaze_v10_t));
103 }
104 #endif
105 #if RKAIQ_HAVE_DEHAZE_V11
106 CalibDbV2_dehaze_v11_t* calibv2_adehaze_calib_V11 =
107 (CalibDbV2_dehaze_v11_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adehaze_calib));
108 if (calibv2_adehaze_calib_V11)
109 memcpy(&pAdehazeHandle->AdehazeAtrrV11.stAuto, calibv2_adehaze_calib_V11,
110 sizeof(CalibDbV2_dehaze_v11_t));
111 #endif
112 #if RKAIQ_HAVE_DEHAZE_V11_DUO
113 CalibDbV2_dehaze_v11_t* calibv2_adehaze_calib_V11_duo =
114 (CalibDbV2_dehaze_v11_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adehaze_calib));
115 if (calibv2_adehaze_calib_V11_duo)
116 memcpy(&pAdehazeHandle->AdehazeAtrrV11duo.stAuto, calibv2_adehaze_calib_V11_duo,
117 sizeof(CalibDbV2_dehaze_v11_t));
118 #endif
119 #if RKAIQ_HAVE_DEHAZE_V12
120 CalibDbV2_dehaze_v12_t* calibv2_adehaze_calib_V12 =
121 (CalibDbV2_dehaze_v12_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adehaze_calib));
122 if (calibv2_adehaze_calib_V12)
123 memcpy(&pAdehazeHandle->AdehazeAtrrV12.stAuto, calibv2_adehaze_calib_V12,
124 sizeof(CalibDbV2_dehaze_v12_t));
125 #endif
126 pAdehazeHandle->ifReCalcStAuto = true;
127 } else if (params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_CHANGERES) {
128 pAdehazeHandle->isCapture = true;
129 }
130
131 LOG1_ADEHAZE("EIXT: %s \n", __func__);
132 return ret;
133 }
134
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)135 static XCamReturn processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams) {
136 LOG1_ADEHAZE("ENTER: %s \n", __func__);
137 XCamReturn ret = XCAM_RETURN_NO_ERROR;
138 bool dehaze_bypass_processing = true;
139 AdehazeHandle_t* pAdehazeHandle = (AdehazeHandle_t*)inparams->ctx;
140 RkAiqAlgoProcAdhaz* pProcPara = (RkAiqAlgoProcAdhaz*)inparams;
141 RkAiqAlgoProcResAdhaz* pProcRes = (RkAiqAlgoProcResAdhaz*)outparams;
142 pAdehazeHandle->FrameID = inparams->frame_id;
143
144 LOGD_ADEHAZE("/*************************Adehaze Start******************/ \n");
145
146 AdehazeGetCurrData(pAdehazeHandle, pProcPara);
147
148 if (DehazeEnableSetting(pAdehazeHandle, pProcRes->AdehzeProcRes)) {
149 dehaze_bypass_processing = AdehazeByPassProcessing(pAdehazeHandle);
150 // process
151 if (!dehaze_bypass_processing) {
152 #if RKAIQ_HAVE_DEHAZE_V10
153 ret = AdehazeProcess(pAdehazeHandle, pProcPara->dehaze_stats_v10, pProcRes->AdehzeProcRes);
154 #endif
155 #if RKAIQ_HAVE_DEHAZE_V11
156 ret = AdehazeProcess(pAdehazeHandle, pProcPara->dehaze_stats_v11, pProcRes->AdehzeProcRes);
157 #endif
158 #if RKAIQ_HAVE_DEHAZE_V11_DUO
159 ret = AdehazeProcess(pAdehazeHandle, pProcPara->dehaze_stats_v11_duo, pProcRes->AdehzeProcRes);
160 #endif
161 #if RKAIQ_HAVE_DEHAZE_V12
162 ret = AdehazeProcess(pAdehazeHandle, pProcPara->dehaze_stats_v12, pProcPara->stats_true,
163 pProcRes->AdehzeProcRes);
164 #endif
165 }
166 } else {
167 LOGD_ADEHAZE("Dehaze Enable is OFF, Bypass Dehaze !!! \n");
168 }
169
170 LOGD_ADEHAZE("/*************************Adehaze over******************/ \n");
171
172 // proc res
173 outparams->cfg_update = !dehaze_bypass_processing || inparams->u.proc.init;
174 if (pAdehazeHandle->ifReCalcStManual) pAdehazeHandle->ifReCalcStManual = false;
175 if (pAdehazeHandle->ifReCalcStAuto) pAdehazeHandle->ifReCalcStAuto = false;
176
177 LOG1_ADEHAZE("EIXT: %s \n", __func__);
178 return ret;
179 }
180
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)181 static XCamReturn post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams) {
182 return XCAM_RETURN_NO_ERROR;
183 }
184
185 RkAiqAlgoDescription g_RkIspAlgoDescAdhaz = {
186 .common =
187 {
188 .version = RKISP_ALGO_ADHAZ_VERSION,
189 .vendor = RKISP_ALGO_ADHAZ_VENDOR,
190 .description = RKISP_ALGO_ADHAZ_DESCRIPTION,
191 .type = RK_AIQ_ALGO_TYPE_ADHAZ,
192 .id = 0,
193 .create_context = create_context,
194 .destroy_context = destroy_context,
195 },
196 .prepare = prepare,
197 .pre_process = NULL,
198 .processing = processing,
199 .post_process = NULL,
200 };
201
202 RKAIQ_END_DECLARE
203