1 /*
2  * rk_aiq_algo_camgroup_awb_itf.c
3  *
4  *  Copyright (c) 2021 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 "rk_aiq_algo_camgroup_asharp_itf_v4.h"
21 #include "rk_aiq_algo_camgroup_types.h"
22 #include "rk_aiq_types_camgroup_asharp_prvt_v4.h"
23 #include "asharp4/rk_aiq_asharp_algo_itf_v4.h"
24 #include "asharp4/rk_aiq_asharp_algo_v4.h"
25 
26 
27 
28 RKAIQ_BEGIN_DECLARE
29 
30 
groupAsharpV4CreateCtx(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)31 static XCamReturn groupAsharpV4CreateCtx(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
32 {
33     LOGI_ASHARP("%s enter \n", __FUNCTION__ );
34 
35     XCamReturn ret = XCAM_RETURN_NO_ERROR;
36     CamGroup_AsharpV4_Contex_t *asharp_group_contex = NULL;
37     AlgoCtxInstanceCfgCamGroup *cfgInt = (AlgoCtxInstanceCfgCamGroup*)cfg;
38 
39     if(CHECK_ISP_HW_V30()) {
40         asharp_group_contex = (CamGroup_AsharpV4_Contex_t*)malloc(sizeof(CamGroup_AsharpV4_Contex_t));
41 #if (ASHARP_USE_JSON_FILE_V4)
42         Asharp4_result_t ret_v4 = ASHARP4_RET_SUCCESS;
43         ret_v4 = Asharp_Init_V4(&(asharp_group_contex->asharp_contex_v4), (void *)cfgInt->s_calibv2);
44         if(ret_v4 != ASHARP4_RET_SUCCESS) {
45             ret = XCAM_RETURN_ERROR_FAILED;
46             LOGE_ASHARP("%s: Initializaion ASHARP failed (%d)\n", __FUNCTION__, ret);
47         }
48 #endif
49     } else {
50         ret = XCAM_RETURN_ERROR_FAILED;
51         LOGE_ASHARP("module_hw_version of asharp  is invalid!!!!");
52     }
53 
54     if(ret != XCAM_RETURN_NO_ERROR) {
55         LOGE_ASHARP("%s: Initializaion group sharp failed (%d)\n", __FUNCTION__, ret);
56     } else {
57         // to do got asharpSurrViewClib and initinal paras for for surround view
58         asharp_group_contex->group_CalibV2.groupMethod = CalibDbV2_CAMGROUP_ASHARPV4_METHOD_MEAN;// to do from json
59         asharp_group_contex->camera_Num = cfgInt->camIdArrayLen;
60 
61         *context = (RkAiqAlgoContext *)(asharp_group_contex);
62 
63         LOGI_ASHARP("%s:%d surrViewMethod(1-mean):%d, cameraNum %d \n",
64                     __FUNCTION__, __LINE__,
65                     asharp_group_contex->group_CalibV2.groupMethod,
66                     asharp_group_contex->camera_Num);
67     }
68 
69     LOGI_ASHARP("%s exit ret:%d\n", __FUNCTION__, ret);
70     return ret;
71 
72 }
73 
groupAsharpV4DestroyCtx(RkAiqAlgoContext * context)74 static XCamReturn groupAsharpV4DestroyCtx(RkAiqAlgoContext *context)
75 {
76     LOGI_ASHARP("%s enter \n", __FUNCTION__ );
77 
78     XCamReturn ret = XCAM_RETURN_NO_ERROR;
79 
80     CamGroup_AsharpV4_Contex_t *asharp_group_contex = (CamGroup_AsharpV4_Contex_t*)context;
81 
82     if(CHECK_ISP_HW_V30()) {
83         Asharp4_result_t ret_v4 = ASHARP4_RET_SUCCESS;
84         ret_v4 = Asharp_Release_V4(asharp_group_contex->asharp_contex_v4);
85         if(ret_v4 != ASHARP4_RET_SUCCESS) {
86             ret = XCAM_RETURN_ERROR_FAILED;
87             LOGE_ASHARP("%s: Initializaion ASHARP failed (%d)\n", __FUNCTION__, ret);
88         }
89     }
90     else {
91         ret = XCAM_RETURN_ERROR_FAILED;
92         LOGE_ASHARP("module_hw_version of asharp  is isvalid!!!!");
93     }
94 
95     if(ret != XCAM_RETURN_NO_ERROR) {
96         LOGE_ASHARP("%s: release asharp group failed (%d)\n", __FUNCTION__, ret);
97     } else {
98         free(asharp_group_contex);
99     }
100 
101 
102     LOGI_ASHARP("%s exit ret:%d\n", __FUNCTION__, ret);
103     return ret;
104 }
105 
groupAsharpV4Prepare(RkAiqAlgoCom * params)106 static XCamReturn groupAsharpV4Prepare(RkAiqAlgoCom* params)
107 {
108     LOGI_ASHARP("%s enter \n", __FUNCTION__ );
109 
110     XCamReturn ret = XCAM_RETURN_NO_ERROR;
111 
112     CamGroup_AsharpV4_Contex_t * asharp_group_contex = (CamGroup_AsharpV4_Contex_t *)params->ctx;
113     RkAiqAlgoCamGroupPrepare* para = (RkAiqAlgoCamGroupPrepare*)params;
114 
115     if(CHECK_ISP_HW_V30()) {
116         Asharp_Context_V4_t * asharp_contex_v4 = asharp_group_contex->asharp_contex_v4;
117         if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
118             // todo  update calib pars for surround view
119 #if ASHARP_USE_JSON_FILE_V4
120             void *pCalibdbV2 = (void*)(para->s_calibv2);
121             CalibDbV2_SharpV4_t *sharp_v4 = (CalibDbV2_SharpV4_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibdbV2, sharp_v4));
122             asharp_contex_v4->sharp_v4 = *sharp_v4;
123             asharp_contex_v4->isIQParaUpdate = true;
124             asharp_contex_v4->isReCalculate |= 1;
125 #endif
126         }
127         Asharp_Config_V4_t stAsharpConfigV4;
128         stAsharpConfigV4.rawHeight =  params->u.prepare.sns_op_height;
129         stAsharpConfigV4.rawWidth = params->u.prepare.sns_op_width;
130         Asharp4_result_t ret_v4 = ASHARP4_RET_SUCCESS;
131         ret_v4 = Asharp_Prepare_V4(asharp_contex_v4, &stAsharpConfigV4);
132         if(ret_v4 != ASHARP4_RET_SUCCESS) {
133             ret = XCAM_RETURN_ERROR_FAILED;
134             LOGE_ASHARP("%s: config ASHARP failed (%d)\n", __FUNCTION__, ret);
135         }
136     }
137     else {
138         ret = XCAM_RETURN_ERROR_FAILED;
139         LOGE_ASHARP("module_hw_version of asharp is isvalid!!!!");
140     }
141 
142     LOGI_ASHARP("%s exit ret:%d\n", __FUNCTION__, ret);
143     return ret;
144 }
145 
groupAsharpV4Processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)146 static XCamReturn groupAsharpV4Processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
147 {
148     LOGI_ASHARP("%s enter \n", __FUNCTION__ );
149     LOGI_ASHARP("----------------------------------------------frame_id (%d)----------------------------------------------\n", inparams->frame_id);
150 
151     XCamReturn ret = XCAM_RETURN_NO_ERROR;
152     RkAiqAlgoCamGroupProcIn* procParaGroup = (RkAiqAlgoCamGroupProcIn*)inparams;
153     RkAiqAlgoCamGroupProcOut* procResParaGroup = (RkAiqAlgoCamGroupProcOut*)outparams;
154     CamGroup_AsharpV4_Contex_t * asharp_group_contex = (CamGroup_AsharpV4_Contex_t *)inparams->ctx;
155     int deltaIso = 0;
156 
157     //method error
158     if (asharp_group_contex->group_CalibV2.groupMethod <= CalibDbV2_CAMGROUP_ASHARPV4_METHOD_MIN
159             ||  asharp_group_contex->group_CalibV2.groupMethod >=  CalibDbV2_CAMGROUP_ASHARPV4_METHOD_MAX) {
160         return (ret);
161     }
162 
163     //group empty
164     if(procParaGroup->camgroupParmasArray == nullptr) {
165         LOGE_ASHARP("camgroupParmasArray is null");
166         return(XCAM_RETURN_ERROR_FAILED);
167     }
168 
169     //get cur ae exposure
170     Asharp4_ExpInfo_t stExpInfoV4;
171     memset(&stExpInfoV4, 0x00, sizeof(Asharp3_ExpInfo_t));
172     stExpInfoV4.hdr_mode = 0; //pAnrProcParams->hdr_mode;
173     stExpInfoV4.snr_mode = 0;
174     for(int i = 0; i < 3; i++) {
175         stExpInfoV4.arIso[i] = 50;
176         stExpInfoV4.arAGain[i] = 1.0;
177         stExpInfoV4.arDGain[i] = 1.0;
178         stExpInfoV4.arTime[i] = 0.01;
179     }
180 
181 
182     //merge ae result, iso mean value
183     rk_aiq_singlecam_3a_result_t* scam_3a_res = procParaGroup->camgroupParmasArray[0];
184     if(scam_3a_res->aec._bEffAecExpValid) {
185         RKAiqAecExpInfo_t* pCurExp = &scam_3a_res->aec._effAecExpInfo;
186         stExpInfoV4.snr_mode = pCurExp->CISFeature.SNR;
187         if((rk_aiq_working_mode_t)procParaGroup->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
188             stExpInfoV4.hdr_mode = 0;
189             stExpInfoV4.arAGain[0] = pCurExp->LinearExp.exp_real_params.analog_gain;
190             stExpInfoV4.arDGain[0] = pCurExp->LinearExp.exp_real_params.digital_gain;
191             stExpInfoV4.arTime[0] = pCurExp->LinearExp.exp_real_params.integration_time;
192             stExpInfoV4.arIso[0] = stExpInfoV4.arAGain[0] * stExpInfoV4.arDGain[0] * 50;
193 
194         } else {
195             if(procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
196                     || procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR)
197                 stExpInfoV4.hdr_mode = 1;
198             else if (procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
199                      || procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR)
200                 stExpInfoV4.hdr_mode = 2;
201             else {
202                 stExpInfoV4.hdr_mode = 0;
203                 LOGE_ANR("mode error\n");
204             }
205 
206             for(int i = 0; i < 3; i++) {
207                 stExpInfoV4.arAGain[i] = pCurExp->HdrExp[i].exp_real_params.analog_gain;
208                 stExpInfoV4.arDGain[i] = pCurExp->HdrExp[i].exp_real_params.digital_gain;
209                 stExpInfoV4.arTime[i] = pCurExp->HdrExp[i].exp_real_params.integration_time;
210                 stExpInfoV4.arIso[i] = stExpInfoV4.arAGain[i] * stExpInfoV4.arDGain[i] * 50;
211             }
212 
213         }
214     } else {
215         LOGW("fail to get sensor gain form AE module,use default value ");
216     }
217 
218 
219 
220     if(CHECK_ISP_HW_V30()) {
221         Asharp_Context_V4_t * asharp_contex_v4 = asharp_group_contex->asharp_contex_v4;
222         Asharp_ProcResult_V4_t stAsharpResultV4;
223         RK_SHARP_Fix_V4_t stFix;
224         stAsharpResultV4.stFix = &stFix;
225 
226         deltaIso = abs(stExpInfoV4.arIso[stExpInfoV4.hdr_mode] - asharp_contex_v4->stExpInfo.arIso[stExpInfoV4.hdr_mode]);
227         if(deltaIso > ASHARPV4_RECALCULATE_DELTA_ISO) {
228             asharp_contex_v4->isReCalculate |= 1;
229         }
230         if(asharp_contex_v4->isReCalculate) {
231             Asharp4_result_t ret_v4 = ASHARP4_RET_SUCCESS;
232             ret_v4 = Asharp_Process_V4(asharp_contex_v4, &stExpInfoV4);
233             if(ret_v4 != ASHARP4_RET_SUCCESS) {
234                 ret = XCAM_RETURN_ERROR_FAILED;
235                 LOGE_ASHARP("%s: processing ASHARP failed (%d)\n", __FUNCTION__, ret);
236             }
237             outparams->cfg_update = true;
238             LOGD_ASHARP("recalculate: %d delta_iso:%d \n ", asharp_contex_v4->isReCalculate, deltaIso);
239         } else {
240             outparams->cfg_update = false;
241         }
242         Asharp_GetProcResult_V4(asharp_contex_v4, &stAsharpResultV4);
243         for (int i = 0; i < procResParaGroup->arraySize; i++) {
244             *(procResParaGroup->camgroupParmasArray[i]->asharp._asharp_procRes_v4) = *stAsharpResultV4.stFix;
245             IS_UPDATE_MEM((procResParaGroup->camgroupParmasArray[i]->asharp._asharp_procRes_v4), procParaGroup->_offset_is_update) =
246                 outparams->cfg_update;
247         }
248         asharp_contex_v4->isReCalculate = 0;
249 
250     }
251     else {
252         ret = XCAM_RETURN_ERROR_FAILED;
253         LOGE_ASHARP("module_hw_version of asharp is isvalid!!!!");
254     }
255 
256     LOGI_ASHARP("%s exit\n", __FUNCTION__);
257     return ret;
258 }
259 
260 RkAiqAlgoDescription g_RkIspAlgoDescCamgroupAsharpV4 = {
261     .common = {
262         .version = RKISP_ALGO_CAMGROUP_ASHARPV4_VERSION,
263         .vendor  = RKISP_ALGO_CAMGROUP_ASHARPV4_VENDOR,
264         .description = RKISP_ALGO_CAMGROUP_ASHARPV4_DESCRIPTION,
265         .type    = RK_AIQ_ALGO_TYPE_ASHARP,
266         .id      = 0,
267         .create_context  = groupAsharpV4CreateCtx,
268         .destroy_context = groupAsharpV4DestroyCtx,
269     },
270     .prepare = groupAsharpV4Prepare,
271     .pre_process = NULL,
272     .processing = groupAsharpV4Processing,
273     .post_process = NULL,
274 };
275 
276 RKAIQ_END_DECLARE
277