1 /*
2 * rk_aiq_algo_adpcc_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
20 #include "adpcc/rk_aiq_algo_adpcc_itf.h"
21 #include "adpcc/rk_aiq_adpcc_algo.h"
22 #include "adpcc/rk_aiq_types_adpcc_algo_prvt.h"
23 #include "rk_aiq_algo_types.h"
24
25 RKAIQ_BEGIN_DECLARE
26
27
28 static XCamReturn
create_context(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)29 create_context(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
30 {
31 XCamReturn result = XCAM_RETURN_NO_ERROR;
32
33 LOG1_ADPCC("%s: (enter)", __FUNCTION__ );
34
35 AdpccContext_t* pAdpccCtx = NULL;
36 AdpccResult_t ret = AdpccInit(&pAdpccCtx, cfg->calibv2);//load json paras
37 if(ret != ADPCC_RET_SUCCESS) {
38 result = XCAM_RETURN_ERROR_FAILED;
39 LOGE_ADPCC("%s: Initializaion Adpcc failed (%d)", __FUNCTION__, ret);
40 } else {
41 *context = (RkAiqAlgoContext *)(pAdpccCtx);
42 }
43
44 LOG1_ADPCC("%s: (exit)", __FUNCTION__ );
45 return result;
46 }
47
48 static XCamReturn
destroy_context(RkAiqAlgoContext * context)49 destroy_context(RkAiqAlgoContext *context)
50 {
51 XCamReturn result = XCAM_RETURN_NO_ERROR;
52
53 LOG1_ADPCC("%s: (enter)", __FUNCTION__ );
54
55 #if 1
56 AdpccContext_t* pAdpccCtx = (AdpccContext_t*)context;
57 AdpccResult_t ret = AdpccRelease(pAdpccCtx);
58 if(ret != ADPCC_RET_SUCCESS) {
59 result = XCAM_RETURN_ERROR_FAILED;
60 LOGE_ADPCC("%s: release Adpcc failed (%d)\n", __FUNCTION__, ret);
61 }
62 #endif
63
64 LOG1_ADPCC("%s: (exit)", __FUNCTION__ );
65 return result;
66 }
67
68 static XCamReturn
prepare(RkAiqAlgoCom * params)69 prepare(RkAiqAlgoCom* params)
70 {
71 XCamReturn result = XCAM_RETURN_NO_ERROR;
72
73 LOG1_ADPCC("%s: (enter)", __FUNCTION__ );
74
75 AdpccContext_t* pAdpccCtx = (AdpccContext_t *)params->ctx;
76 RkAiqAlgoConfigAdpcc* pCfgParam = (RkAiqAlgoConfigAdpcc*)params;
77 AdpccConfig_t* pAdpccConfig = &pCfgParam->stAdpccConfig;
78 pAdpccCtx->prepare_type = params->u.prepare.conf_type;
79
80 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
81 AdpccResult_t ret = AdpccReloadPara(pAdpccCtx, pCfgParam->com.u.prepare.calibv2);
82 if(ret != ADPCC_RET_SUCCESS) {
83 result = XCAM_RETURN_ERROR_FAILED;
84 LOGE_ADPCC("%s: Adpcc Reload Para failed (%d)", __FUNCTION__, ret);
85 }
86 }
87
88 pAdpccCtx->isReCal_ = true;
89
90 LOG1_ADPCC("%s: (exit)", __FUNCTION__ );
91 return result;
92 }
93
94 static XCamReturn
pre_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)95 pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
96 {
97 return XCAM_RETURN_NO_ERROR;
98 }
99
100 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)101 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
102 {
103 XCamReturn result = XCAM_RETURN_NO_ERROR;
104 int iso;
105
106 LOG1_ADPCC("%s: (enter)", __FUNCTION__ );
107
108 #if 1
109 RkAiqAlgoProcAdpcc* pAdpccProcParams = (RkAiqAlgoProcAdpcc*)inparams;
110 RkAiqAlgoProcResAdpcc* pAdpccProcResParams = (RkAiqAlgoProcResAdpcc*)outparams;
111 AdpccContext_t* pAdpccCtx = (AdpccContext_t *)inparams->ctx;
112 AdpccExpInfo_t stExpInfo;
113 memset(&stExpInfo, 0x00, sizeof(AdpccExpInfo_t));
114
115 LOGD_ADPCC("%s:%d init:%d hdr mode:%d",
116 __FUNCTION__, __LINE__,
117 inparams->u.proc.init,
118 pAdpccProcParams->hdr_mode);
119
120 stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
121 for(int i = 0; i < 3; i++) {
122 stExpInfo.arPreResIso[i] = 50;
123 stExpInfo.arPreResAGain[i] = 1.0;
124 stExpInfo.arPreResDGain[i] = 1.0;
125 stExpInfo.arPreResTime[i] = 0.01;
126
127 stExpInfo.arProcResIso[i] = 50;
128 stExpInfo.arProcResAGain[i] = 1.0;
129 stExpInfo.arProcResDGain[i] = 1.0;
130 stExpInfo.arProcResTime[i] = 0.01;
131 }
132
133 pAdpccCtx->isBlackSensor = pAdpccProcParams->com.u.proc.is_bw_sensor;
134
135 if(pAdpccProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
136 stExpInfo.hdr_mode = 0;
137 } else if(pAdpccProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
138 || pAdpccProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
139 stExpInfo.hdr_mode = 1;
140 } else if(pAdpccProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
141 || pAdpccProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
142 stExpInfo.hdr_mode = 2;
143 }
144
145 RKAiqAecExpInfo_t* pAERes = pAdpccProcParams->com.u.proc.curExp;
146
147 if(pAERes != NULL) {
148 if(pAdpccProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
149 stExpInfo.arPreResAGain[0] = pAERes->LinearExp.exp_real_params.analog_gain;
150 stExpInfo.arPreResDGain[0] = pAERes->LinearExp.exp_real_params.digital_gain *
151 pAERes->LinearExp.exp_real_params.isp_dgain;
152 stExpInfo.arPreResTime[0] = pAERes->LinearExp.exp_real_params.integration_time;
153 stExpInfo.arPreResIso[0] = stExpInfo.arPreResAGain[0] * stExpInfo.arPreResDGain[0] * 50;
154
155 LOGD_ADPCC("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d",
156 __FUNCTION__, __LINE__,
157 0,
158 stExpInfo.arPreResAGain[0],
159 stExpInfo.arPreResDGain[0],
160 stExpInfo.arPreResTime[0],
161 stExpInfo.arPreResIso[0],
162 stExpInfo.hdr_mode);
163 } else {
164 for(int i = 0; i < 3; i++) {
165 stExpInfo.arPreResAGain[i] = pAERes->HdrExp[i].exp_real_params.analog_gain;
166 stExpInfo.arPreResDGain[i] = pAERes->HdrExp[i].exp_real_params.digital_gain *
167 pAERes->HdrExp[i].exp_real_params.digital_gain;
168 stExpInfo.arPreResTime[i] = pAERes->HdrExp[i].exp_real_params.integration_time;
169 stExpInfo.arPreResIso[i] = stExpInfo.arPreResAGain[i] * stExpInfo.arPreResDGain[i] * 50;
170
171 LOGD_ADPCC("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d",
172 __FUNCTION__, __LINE__,
173 i,
174 stExpInfo.arPreResAGain[i],
175 stExpInfo.arPreResDGain[i],
176 stExpInfo.arPreResTime[i],
177 stExpInfo.arPreResIso[i],
178 stExpInfo.hdr_mode);
179 }
180 }
181 } else {
182 LOGE_ADPCC("%s:%d pAERes is NULL, so use default instead", __FUNCTION__, __LINE__);
183 }
184
185 if (pAdpccCtx->stExpInfo.arPreResIso[pAdpccCtx->stExpInfo.hdr_mode] !=
186 stExpInfo.arPreResIso[pAdpccCtx->stExpInfo.hdr_mode])
187 pAdpccCtx->isReCal_ = true;
188
189 if (pAdpccCtx->isReCal_) {
190 AdpccResult_t ret = AdpccProcess(pAdpccCtx, &stExpInfo, pAdpccProcResParams->stAdpccProcResult);
191 if(ret != ADPCC_RET_SUCCESS) {
192 result = XCAM_RETURN_ERROR_FAILED;
193 LOGE_ADPCC("%s: processing Adpcc failed (%d)", __FUNCTION__, ret);
194 }
195
196 outparams->cfg_update = true;
197 pAdpccCtx->isReCal_ = false;
198 } else {
199 outparams->cfg_update = false;
200 }
201
202 //sensor dpcc setting
203 #if 0
204 pAdpccProcResParams->SenDpccRes.enable = pAdpccCtx->SenDpccRes.enable;
205 pAdpccProcResParams->SenDpccRes.total_dpcc = pAdpccCtx->SenDpccRes.total_dpcc;
206 pAdpccProcResParams->SenDpccRes.cur_single_dpcc = pAdpccCtx->SenDpccRes.cur_single_dpcc;
207 pAdpccProcResParams->SenDpccRes.cur_multiple_dpcc = pAdpccCtx->SenDpccRes.cur_multiple_dpcc;
208 #endif
209
210 #endif
211
212 LOG1_ADPCC("%s: (exit)", __FUNCTION__ );
213 return XCAM_RETURN_NO_ERROR;
214 }
215
216 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)217 post_process(const RkAiqAlgoCom * inparams, RkAiqAlgoResCom * outparams)
218 {
219 return XCAM_RETURN_NO_ERROR;
220 }
221
222 RkAiqAlgoDescription g_RkIspAlgoDescAdpcc = {
223 .common = {
224 .version = RKISP_ALGO_ADPCC_VERSION,
225 .vendor = RKISP_ALGO_ADPCC_VENDOR,
226 .description = RKISP_ALGO_ADPCC_DESCRIPTION,
227 .type = RK_AIQ_ALGO_TYPE_ADPCC,
228 .id = 0,
229 .create_context = create_context,
230 .destroy_context = destroy_context,
231 },
232 .prepare = prepare,
233 .pre_process = NULL,
234 .processing = processing,
235 .post_process = NULL,
236 };
237
238 RKAIQ_END_DECLARE
239