1 #include "rk_aiq_uapi_asharp_int.h"
2 #include "asharp/rk_aiq_types_asharp_algo_prvt.h"
3 #include "asharp/rk_aiq_asharp_algo.h"
4 #include "sharp_xml2json_v1.h"
5 #include "edgefilter_xml2json_v1.h"
6
7
8
9
10 XCamReturn
rk_aiq_uapi_asharp_SetAttrib(RkAiqAlgoContext * ctx,rk_aiq_sharp_attrib_t * attr,bool need_sync)11 rk_aiq_uapi_asharp_SetAttrib(RkAiqAlgoContext *ctx,
12 rk_aiq_sharp_attrib_t *attr,
13 bool need_sync)
14 {
15
16 AsharpContext_t* pAsharpCtx = (AsharpContext_t*)ctx;
17
18 pAsharpCtx->eMode = attr->eMode;
19 pAsharpCtx->stAuto = attr->stAuto;
20 pAsharpCtx->stManual = attr->stManual;
21
22 return XCAM_RETURN_NO_ERROR;
23 }
24
25 XCamReturn
rk_aiq_uapi_asharp_GetAttrib(const RkAiqAlgoContext * ctx,rk_aiq_sharp_attrib_t * attr)26 rk_aiq_uapi_asharp_GetAttrib(const RkAiqAlgoContext *ctx,
27 rk_aiq_sharp_attrib_t *attr)
28 {
29
30 AsharpContext_t* pAsharpCtx = (AsharpContext_t*)ctx;
31
32 attr->eMode = pAsharpCtx->eMode;
33 memcpy(&attr->stAuto, &pAsharpCtx->stAuto, sizeof(Asharp_Auto_Attr_t));
34 memcpy(&attr->stManual, &pAsharpCtx->stManual, sizeof(Asharp_Manual_Attr_t));
35
36 return XCAM_RETURN_NO_ERROR;
37 }
38
39 XCamReturn
rk_aiq_uapi_asharp_SetIQpara(RkAiqAlgoContext * ctx,rk_aiq_sharp_IQpara_t * para,bool need_sync)40 rk_aiq_uapi_asharp_SetIQpara(RkAiqAlgoContext *ctx,
41 rk_aiq_sharp_IQpara_t *para,
42 bool need_sync)
43 {
44
45 #ifdef RKAIQ_ENABLE_PARSER_V1
46 AsharpContext_t* pAsharpCtx = (AsharpContext_t*)ctx;
47
48 if(para->module_bits & (1 << ASHARP_MODULE_SHARP)) {
49 CalibDb_Sharp_2_t stSharpCalib;
50 stSharpCalib.mode_num = sizeof(para->stSharpPara.mode_cell) / sizeof(CalibDb_Sharp_ModeCell_t);
51 stSharpCalib.mode_cell = (CalibDb_Sharp_ModeCell_t *)malloc(stSharpCalib.mode_num * sizeof(CalibDb_Sharp_ModeCell_t));
52
53 stSharpCalib.enable = para->stSharpPara.enable;
54 memcpy(stSharpCalib.version, para->stSharpPara.version, sizeof(para->stSharpPara.version));
55 for(int i = 0; i < 8; i++) {
56 stSharpCalib.luma_point[i] = para->stSharpPara.luma_point[i];
57 }
58 for(int i = 0; i < stSharpCalib.mode_num; i++) {
59 stSharpCalib.mode_cell[i] = para->stSharpPara.mode_cell[i];
60 }
61 pAsharpCtx->isIQParaUpdate = true;
62
63 #if(ASHARP_USE_JSON_PARA)
64 sharpV1_calibdb_to_calibdbV2(&stSharpCalib, &pAsharpCtx->sharp_v1, 0);
65 #else
66 pAsharpCtx->stSharpCalib.enable = stSharpCalib.enable;
67 memcpy(pAsharpCtx->stSharpCalib.version, stSharpCalib.version, sizeof(para->stSharpPara.version));
68 for(int i = 0; i < 8; i++) {
69 pAsharpCtx->stSharpCalib.luma_point[i] = stSharpCalib.luma_point[i];
70 }
71 for(int i = 0; i < stSharpCalib.mode_num && i < pAsharpCtx->stSharpCalib.mode_num; i++) {
72 pAsharpCtx->stSharpCalib.mode_cell[i] = stSharpCalib.mode_cell[i];
73 }
74 #endif
75
76 free(stSharpCalib.mode_cell);
77 }
78
79 if(para->module_bits & (1 << ASHARP_MODULE_EDGEFILTER)) {
80 //pAsharpCtx->stEdgeFltCalib = para->stEdgeFltPara;
81 CalibDb_EdgeFilter_2_t stEdgeFltCalib;
82 stEdgeFltCalib.mode_num = sizeof(para->stEdgeFltPara.mode_cell) / sizeof(CalibDb_EdgeFilter_ModeCell_t);
83 stEdgeFltCalib.mode_cell = (CalibDb_EdgeFilter_ModeCell_t *)malloc(stEdgeFltCalib.mode_num * sizeof(CalibDb_EdgeFilter_ModeCell_t));
84
85 stEdgeFltCalib.enable = para->stEdgeFltPara.enable;
86 memcpy(stEdgeFltCalib.version, para->stEdgeFltPara.version, sizeof(para->stEdgeFltPara.version));
87 for(int i = 0; i < 8; i++) {
88 stEdgeFltCalib.luma_point[i] = para->stEdgeFltPara.luma_point[i];
89 }
90 for(int i = 0; i < stEdgeFltCalib.mode_num; i++) {
91 stEdgeFltCalib.mode_cell[i] = para->stEdgeFltPara.mode_cell[i];
92 }
93
94 #if(ASHARP_USE_JSON_PARA)
95 edgefilterV1_calibdb_to_calibdbV2(&stEdgeFltCalib, &pAsharpCtx->edgefilter_v1, 0);
96 #else
97 pAsharpCtx->stEdgeFltCalib.enable = stEdgeFltCalib.enable;
98 memcpy(pAsharpCtx->stEdgeFltCalib.version, stEdgeFltCalib.version, sizeof(stEdgeFltCalib.version));
99 for(int i = 0; i < 8; i++) {
100 pAsharpCtx->stEdgeFltCalib.luma_point[i] = stEdgeFltCalib.luma_point[i];
101 }
102 for(int i = 0; i < pAsharpCtx->stEdgeFltCalib.mode_num && i < stEdgeFltCalib.mode_num; i++) {
103 pAsharpCtx->stEdgeFltCalib.mode_cell[i] = stEdgeFltCalib.mode_cell[i];
104 }
105 #endif
106
107 pAsharpCtx->isIQParaUpdate = true;
108
109 free(stEdgeFltCalib.mode_cell);
110
111 }
112
113 return XCAM_RETURN_NO_ERROR;
114 #else
115 return XCAM_RETURN_ERROR_PARAM;
116 #endif
117 }
118
119 XCamReturn
rk_aiq_uapi_asharp_GetIQpara(const RkAiqAlgoContext * ctx,rk_aiq_sharp_IQpara_t * para)120 rk_aiq_uapi_asharp_GetIQpara(const RkAiqAlgoContext *ctx,
121 rk_aiq_sharp_IQpara_t *para)
122 {
123
124 #ifdef RKAIQ_ENABLE_PARSER_V1
125 AsharpContext_t* pAsharpCtx = (AsharpContext_t*)ctx;
126
127 if(ctx != NULL && para != NULL) {
128 //sharp
129 CalibDb_Sharp_2_t stSharpCalib;
130 stSharpCalib.mode_num = sizeof(para->stSharpPara.mode_cell) / sizeof(CalibDb_Sharp_ModeCell_t);
131 stSharpCalib.mode_cell = (CalibDb_Sharp_ModeCell_t *)malloc(stSharpCalib.mode_num * sizeof(CalibDb_Sharp_ModeCell_t));
132 #if(ASHARP_USE_JSON_PARA)
133 sharpV1_calibdbV2_to_calibdb(&pAsharpCtx->sharp_v1, &stSharpCalib, 0);
134 #else
135 stSharpCalib.enable = pAsharpCtx->stSharpCalib.enable;
136 memcpy(stSharpCalib.version, pAsharpCtx->stSharpCalib.version, sizeof(pAsharpCtx->stSharpCalib.version));
137 for(int i = 0; i < 8; i++) {
138 stSharpCalib.luma_point[i] = pAsharpCtx->stSharpCalib.luma_point[i];
139 }
140 for(int i = 0; i < stSharpCalib.mode_num && i < pAsharpCtx->stSharpCalib.mode_num; i++) {
141 stSharpCalib.mode_cell[i] = pAsharpCtx->stSharpCalib.mode_cell[i];
142 }
143 #endif
144
145 memset(¶->stSharpPara, 0x00, sizeof(CalibDb_Sharp_t));
146 para->stSharpPara.enable = stSharpCalib.enable;
147 memcpy(para->stSharpPara.version, stSharpCalib.version, sizeof(stSharpCalib.version));
148 for(int i = 0; i < 8; i++) {
149 para->stSharpPara.luma_point[i] = stSharpCalib.luma_point[i];
150 }
151 for(int i = 0; i < stSharpCalib.mode_num && i < CALIBDB_MAX_MODE_NUM; i++) {
152 para->stSharpPara.mode_cell[i] = stSharpCalib.mode_cell[i];
153 }
154
155 //edgefilter
156 CalibDb_EdgeFilter_2_t stEdgeFltCalib;
157 stEdgeFltCalib.mode_num = sizeof(para->stEdgeFltPara.mode_cell) / sizeof(CalibDb_EdgeFilter_ModeCell_t);
158 stEdgeFltCalib.mode_cell = (CalibDb_EdgeFilter_ModeCell_t *)malloc(stEdgeFltCalib.mode_num * sizeof(CalibDb_EdgeFilter_ModeCell_t));
159
160 #if(ASHARP_USE_JSON_PARA)
161 edgefilterV1_calibdbV2_to_calibdb(&pAsharpCtx->edgefilter_v1, &stEdgeFltCalib, 0);
162 #else
163 stEdgeFltCalib.enable = pAsharpCtx->stEdgeFltCalib.enable;
164 memcpy(stEdgeFltCalib.version, pAsharpCtx->stEdgeFltCalib.version, sizeof(stEdgeFltCalib.version));
165 for(int i = 0; i < 8; i++) {
166 stEdgeFltCalib.luma_point[i] = pAsharpCtx->stEdgeFltCalib.luma_point[i];
167 }
168 for(int i = 0; i < pAsharpCtx->stEdgeFltCalib.mode_num && i < stEdgeFltCalib->mode_num; i++) {
169 stEdgeFltCalib.mode_cell[i] = pAsharpCtx->stEdgeFltCalib.mode_cell[i];
170 }
171 #endif
172
173 memset(¶->stEdgeFltPara, 0x00, sizeof(CalibDb_EdgeFilter_t));
174 para->stEdgeFltPara.enable = stEdgeFltCalib.enable;
175 memcpy(para->stEdgeFltPara.version, stEdgeFltCalib.version, sizeof(para->stEdgeFltPara.version));
176 for(int i = 0; i < 8; i++) {
177 para->stEdgeFltPara.luma_point[i] = stEdgeFltCalib.luma_point[i];
178 }
179 for(int i = 0; i < stEdgeFltCalib.mode_num && i < CALIBDB_MAX_MODE_NUM; i++) {
180 para->stEdgeFltPara.mode_cell[i] = stEdgeFltCalib.mode_cell[i];
181 }
182
183 free(stEdgeFltCalib.mode_cell);
184 free(stSharpCalib.mode_cell);
185 }
186
187 return XCAM_RETURN_NO_ERROR;
188 #else
189 return XCAM_RETURN_ERROR_PARAM;
190 #endif
191 }
192
193
194 XCamReturn
rk_aiq_uapi_asharp_SetStrength(const RkAiqAlgoContext * ctx,float fPercent)195 rk_aiq_uapi_asharp_SetStrength(const RkAiqAlgoContext *ctx,
196 float fPercent)
197 {
198
199 AsharpContext_t* pAsharpCtx = (AsharpContext_t*)ctx;
200 float fMax = SHARP_MAX_STRENGTH_PERCENT;
201 float fStrength = 1.0;
202
203
204 if(fPercent <= 0.5) {
205 fStrength = fPercent / 0.5;
206 } else {
207 fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
208 }
209
210 pAsharpCtx->fStrength = fStrength;
211
212 return XCAM_RETURN_NO_ERROR;
213 }
214
215 XCamReturn
rk_aiq_uapi_asharp_GetStrength(const RkAiqAlgoContext * ctx,float * pPercent)216 rk_aiq_uapi_asharp_GetStrength(const RkAiqAlgoContext *ctx,
217 float *pPercent)
218 {
219
220 AsharpContext_t* pAsharpCtx = (AsharpContext_t*)ctx;
221 float fMax = SHARP_MAX_STRENGTH_PERCENT;
222 float fStrength = 1.0;
223
224 fStrength = pAsharpCtx->fStrength;
225
226 if(fStrength <= 1) {
227 *pPercent = fStrength * 0.5;
228 } else {
229 *pPercent = 2 * (fStrength - 1) / (fMax - 1) + 0.5;
230 }
231
232 return XCAM_RETURN_NO_ERROR;
233 }
234
235 XCamReturn
rk_aiq_uapi_asharp_SetJsonpara(RkAiqAlgoContext * ctx,rk_aiq_sharp_JsonPara_t * para,bool need_sync)236 rk_aiq_uapi_asharp_SetJsonpara(RkAiqAlgoContext *ctx,
237 rk_aiq_sharp_JsonPara_t *para,
238 bool need_sync)
239 {
240
241 AsharpContext_t* pAsharpCtx = (AsharpContext_t*)ctx;
242
243 if(para->module_bits & (1 << ASHARP_MODULE_SHARP)) {
244 sharp_calibdbV2_assign(&pAsharpCtx->sharp_v1, ¶->sharp_v1);
245 pAsharpCtx->isIQParaUpdate = true;
246 }
247
248 if(para->module_bits & (1 << ASHARP_MODULE_EDGEFILTER)) {
249 edgefilter_calibdbV2_assign(&pAsharpCtx->edgefilter_v1, ¶->edgefilter_v1);
250 pAsharpCtx->isIQParaUpdate = true;
251 }
252
253 return XCAM_RETURN_NO_ERROR;
254 }
255
256 XCamReturn
rk_aiq_uapi_asharp_GetJsonpara(const RkAiqAlgoContext * ctx,rk_aiq_sharp_JsonPara_t * para)257 rk_aiq_uapi_asharp_GetJsonpara(const RkAiqAlgoContext *ctx,
258 rk_aiq_sharp_JsonPara_t *para)
259 {
260
261 AsharpContext_t* pAsharpCtx = (AsharpContext_t*)ctx;
262
263 sharp_calibdbV2_assign(¶->sharp_v1, &pAsharpCtx->sharp_v1);
264 edgefilter_calibdbV2_assign(¶->edgefilter_v1, &pAsharpCtx->edgefilter_v1);
265
266 return XCAM_RETURN_NO_ERROR;
267 }
268
269