1 /*
2 * rk_aiq_algo_acprc_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 #include <string.h>
20 #include "xcam_common.h"
21 #include "rk_aiq_adegamma_algo.h"
22
23 RKAIQ_BEGIN_DECLARE
24
AdegammaInit(AdegammaHandle_t ** para,CamCalibDbV2Context_t * calib)25 XCamReturn AdegammaInit(AdegammaHandle_t** para, CamCalibDbV2Context_t* calib)
26 {
27 LOG1_ADEGAMMA("ENTER: %s \n", __func__);
28 XCamReturn ret = XCAM_RETURN_NO_ERROR;
29 AdegammaHandle_t* handle = (AdegammaHandle_t*)calloc(sizeof(AdegammaHandle_t), 1);
30 if (NULL == handle)
31 return XCAM_RETURN_ERROR_MEM;
32
33 CalibDbV2_Adegmma_t* calibv2_adegamma_calib =
34 (CalibDbV2_Adegmma_t*)(CALIBDBV2_GET_MODULE_PTR(calib, adegamma_calib));
35 if (!calibv2_adegamma_calib) {
36 free(handle);
37 return XCAM_RETURN_ERROR_MEM;
38 }
39
40 memcpy(&handle->adegammaAttr.stTool, calibv2_adegamma_calib, sizeof(CalibDbV2_Adegmma_t));
41 handle->pCalibDb = calibv2_adegamma_calib; //get adegmma paras from iq
42 *para = handle;
43 LOG1_ADEGAMMA("EXIT: %s \n", __func__);
44 return(ret);
45
46 }
47
AdegammaRelease(AdegammaHandle_t * para)48 XCamReturn AdegammaRelease(AdegammaHandle_t* para)
49 {
50 LOG1_ADEGAMMA("ENTER: %s \n", __func__);
51 XCamReturn ret = XCAM_RETURN_NO_ERROR;
52 if (para)
53 free(para);
54 LOG1_ADEGAMMA("EXIT: %s \n", __func__);
55 return(ret);
56
57 }
58
AdegammaPreProc(AdegammaHandle_t * para)59 XCamReturn AdegammaPreProc(AdegammaHandle_t* para)
60 {
61 LOG1_ADEGAMMA("ENTER: %s \n", __func__);
62
63 XCamReturn ret = XCAM_RETURN_NO_ERROR;
64
65 LOG1_ADEGAMMA("EXIT: %s \n", __func__);
66 return(ret);
67
68 }
69
AdegammaAutoProc(CalibDbV2_Adegmma_t * pAtuoPara,AdegammaProcRes_t * AdegammaProcRes)70 void AdegammaAutoProc(CalibDbV2_Adegmma_t* pAtuoPara, AdegammaProcRes_t* AdegammaProcRes)
71 {
72 LOG1_ADEGAMMA("ENTER: %s \n", __func__);
73
74 AdegammaProcRes->degamma_en = pAtuoPara->DegammaTuningPara.degamma_en;
75
76 //get X_axis
77 int tmp[DEGAMMA_CRUVE_X_KNOTS];
78 for(int i = 0; i < DEGAMMA_CRUVE_X_KNOTS; i++) {
79 tmp[i] = pAtuoPara->DegammaTuningPara.X_axis[i + 1] - pAtuoPara->DegammaTuningPara.X_axis[i];
80 tmp[i] = log(tmp[i]) / log(2) - DEGAMMA_CRUVE_X_NORMALIZE_FACTOR;
81 tmp[i] = DEGAMMA_LIMIT_VALUE(tmp[i], DEGAMMA_CRUVE_X_MAX, DEGAMMA_CRUVE_X_MIN);
82 }
83
84 int tmp0 = 0, tmp1 = 0;
85 for(int i = 0; i < 8; i++) {
86 tmp0 |= ((tmp[i]) << (4 * i));
87 tmp1 |= ((tmp[i + 8]) << (4 * i));
88 }
89 AdegammaProcRes->degamma_X_d0 = tmp0;
90 AdegammaProcRes->degamma_X_d1 = tmp1;
91
92 for(int i = 0; i < DEGAMMA_CRUVE_Y_KNOTS; i++) {
93 AdegammaProcRes->degamma_tableR[i] =
94 DEGAMMA_LIMIT_VALUE(pAtuoPara->DegammaTuningPara.curve_R[i], DEGAMMA_CRUVE_Y_MAX, DEGAMMA_CRUVE_Y_MIN);
95 AdegammaProcRes->degamma_tableG[i] =
96 DEGAMMA_LIMIT_VALUE(pAtuoPara->DegammaTuningPara.curve_G[i], DEGAMMA_CRUVE_Y_MAX, DEGAMMA_CRUVE_Y_MIN);
97 AdegammaProcRes->degamma_tableB[i] =
98 DEGAMMA_LIMIT_VALUE(pAtuoPara->DegammaTuningPara.curve_B[i], DEGAMMA_CRUVE_Y_MAX, DEGAMMA_CRUVE_Y_MIN);
99 }
100
101 LOGD_ADEGAMMA("%s X_axis:%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", __func__, pAtuoPara->DegammaTuningPara.X_axis[0], pAtuoPara->DegammaTuningPara.X_axis[1],
102 pAtuoPara->DegammaTuningPara.X_axis[2], pAtuoPara->DegammaTuningPara.X_axis[3], pAtuoPara->DegammaTuningPara.X_axis[4], pAtuoPara->DegammaTuningPara.X_axis[5],
103 pAtuoPara->DegammaTuningPara.X_axis[6], pAtuoPara->DegammaTuningPara.X_axis[7], pAtuoPara->DegammaTuningPara.X_axis[8], pAtuoPara->DegammaTuningPara.X_axis[9],
104 pAtuoPara->DegammaTuningPara.X_axis[10], pAtuoPara->DegammaTuningPara.X_axis[11], pAtuoPara->DegammaTuningPara.X_axis[12], pAtuoPara->DegammaTuningPara.X_axis[13],
105 pAtuoPara->DegammaTuningPara.X_axis[14], pAtuoPara->DegammaTuningPara.X_axis[15], pAtuoPara->DegammaTuningPara.X_axis[16]);
106
107 LOG1_ADEGAMMA("EXIT: %s \n", __func__);
108 }
109
AdegammaApiManualProc(AdegammaHandle_t * para,AdegammaProcRes_t * AdegammaProcRes)110 void AdegammaApiManualProc(AdegammaHandle_t* para, AdegammaProcRes_t* AdegammaProcRes)
111 {
112 LOG1_ADEGAMMA("ENTER: %s \n", __func__);
113
114 AdegammaProcRes->degamma_en = para->adegammaAttr.stManual.en ;
115
116 //get X_axis
117 int tmp[DEGAMMA_CRUVE_X_KNOTS];
118 for(int i = 0; i < DEGAMMA_CRUVE_X_KNOTS; i++) {
119 tmp[i] = para->adegammaAttr.stManual.X_axis[i + 1] - para->adegammaAttr.stManual.X_axis[i];
120 tmp[i] = log(tmp[i]) / log(2) - DEGAMMA_CRUVE_X_NORMALIZE_FACTOR;
121 tmp[i] = DEGAMMA_LIMIT_VALUE(tmp[i], DEGAMMA_CRUVE_X_MAX, DEGAMMA_CRUVE_X_MIN);
122 }
123
124 int tmp0 = 0, tmp1 = 0;
125 for(int i = 0; i < 8; i++) {
126 tmp0 |= ((tmp[i]) << (4 * i));
127 tmp1 |= ((tmp[i + 8]) << (4 * i));
128 }
129 AdegammaProcRes->degamma_X_d0 = tmp0;
130 AdegammaProcRes->degamma_X_d1 = tmp1;
131
132 for(int i = 0; i < DEGAMMA_CRUVE_Y_KNOTS; i++) {
133 AdegammaProcRes->degamma_tableR[i] =
134 DEGAMMA_LIMIT_VALUE(para->adegammaAttr.stManual.curve_R[i], DEGAMMA_CRUVE_Y_MAX, DEGAMMA_CRUVE_Y_MIN);
135 AdegammaProcRes->degamma_tableG[i] =
136 DEGAMMA_LIMIT_VALUE(para->adegammaAttr.stManual.curve_G[i], DEGAMMA_CRUVE_Y_MAX, DEGAMMA_CRUVE_Y_MIN);
137 AdegammaProcRes->degamma_tableB[i] =
138 DEGAMMA_LIMIT_VALUE(para->adegammaAttr.stManual.curve_B[i], DEGAMMA_CRUVE_Y_MAX, DEGAMMA_CRUVE_Y_MIN);
139 }
140
141 LOG1_ADEGAMMA("EXIT: %s \n", __func__);
142 }
143
AdegammaProcessing(AdegammaHandle_t * para,AdegammaProcRes_t * AdegammaProcRes)144 void AdegammaProcessing(AdegammaHandle_t* para, AdegammaProcRes_t* AdegammaProcRes)
145 {
146 LOG1_ADEGAMMA("ENTER: %s \n", __func__);
147 LOGD_ADEGAMMA("===============================Adegamma Start===============================\n", __func__);
148
149 if(para->adegammaAttr.mode == RK_AIQ_DEGAMMA_MODE_OFF) { //run iq degamma
150 LOGD_ADEGAMMA(" %s: Adegamma api off !!!\n", __func__);
151 AdegammaAutoProc(para->pCalibDb, AdegammaProcRes);
152 }
153 else if(para->adegammaAttr.mode == RK_AIQ_DEGAMMA_MODE_MANUAL) { //run manual degamma, for client api
154 LOGD_ADEGAMMA(" %s: Adegamma api on, Mode is Manual\n", __func__);
155 AdegammaApiManualProc(para, AdegammaProcRes);
156 }
157 else if(para->adegammaAttr.mode == RK_AIQ_DEGAMMA_MODE_TOOL) { //run tool degamma,for tool
158 LOGD_ADEGAMMA(" %s: Adegamma api on, Mode is Tool\n", __func__);
159 AdegammaAutoProc(¶->adegammaAttr.stTool, AdegammaProcRes);
160 }
161 else
162 LOGE_ADEGAMMA(" %s: Wrong degamma mode !!!\n", __func__);
163
164 //transfer scene mode to degamma api
165 para->adegammaAttr.Scene_mode = para->Scene_mode;
166
167 LOGD_ADEGAMMA("%s DEGAMMA_DX0:%d GAMMA_DX1:%d\n", __func__, AdegammaProcRes->degamma_X_d0, AdegammaProcRes->degamma_X_d1);
168 LOGD_ADEGAMMA("%s DEGAMMA_R_Y:%d %d %d %d %d %d %d %d\n", __func__, AdegammaProcRes->degamma_tableR[0], AdegammaProcRes->degamma_tableR[1],
169 AdegammaProcRes->degamma_tableR[2], AdegammaProcRes->degamma_tableR[3], AdegammaProcRes->degamma_tableR[4], AdegammaProcRes->degamma_tableR[5],
170 AdegammaProcRes->degamma_tableR[6], AdegammaProcRes->degamma_tableR[7]);
171 LOGD_ADEGAMMA("%s DEGAMMA_G_Y:%d %d %d %d %d %d %d %d\n", __func__, AdegammaProcRes->degamma_tableG[0], AdegammaProcRes->degamma_tableG[1],
172 AdegammaProcRes->degamma_tableG[2], AdegammaProcRes->degamma_tableG[3], AdegammaProcRes->degamma_tableG[4], AdegammaProcRes->degamma_tableG[5],
173 AdegammaProcRes->degamma_tableG[6], AdegammaProcRes->degamma_tableG[7]);
174 LOGD_ADEGAMMA("%s DEGAMMA_B_Y:%d %d %d %d %d %d %d %d\n", __func__, AdegammaProcRes->degamma_tableB[0], AdegammaProcRes->degamma_tableB[1],
175 AdegammaProcRes->degamma_tableB[2], AdegammaProcRes->degamma_tableB[3], AdegammaProcRes->degamma_tableB[4], AdegammaProcRes->degamma_tableB[5],
176 AdegammaProcRes->degamma_tableB[6], AdegammaProcRes->degamma_tableB[7]);
177 LOGD_ADEGAMMA("===============================Adegamma Stop================================\n", __func__);
178
179 LOG1_ADEGAMMA("EXIT: %s \n", __func__);
180 }
181
182 RKAIQ_END_DECLARE
183
184
185