1 /*
2 * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "uAPI2/rk_aiq_user_api2_agamma.h"
17 #include "RkAiqCamGroupHandleInt.h"
18 #include "algo_handlers/RkAiqAgammaHandle.h"
19
20 RKAIQ_BEGIN_DECLARE
21
22
23 #ifdef RK_SIMULATOR_HW
24 #define CHECK_USER_API_ENABLE
25 #endif
26
rk_aiq_user_api2_agamma_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_gamma_attrib_V2_t attr)27 XCamReturn rk_aiq_user_api2_agamma_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
28 rk_aiq_gamma_attrib_V2_t attr) {
29 XCamReturn ret = XCAM_RETURN_NO_ERROR;
30 #if RKAIQ_HAVE_GAMMA_V10
31 rk_aiq_gamma_v10_attr_t attr_v10;
32 memset(&attr_v10, 0x0, sizeof(rk_aiq_gamma_v10_attr_t));
33
34 attr_v10.sync.done = attr.sync.done;
35 attr_v10.sync.sync_mode = attr.sync.sync_mode;
36 if (attr.atrrV21.mode == GAMMA_MODE_OFF)
37 attr_v10.mode = RK_AIQ_GAMMA_MODE_AUTO;
38 else if (attr.atrrV21.mode == GAMMA_MODE_MANUAL || attr.atrrV21.mode == GAMMA_MODE_FAST)
39 attr_v10.mode = RK_AIQ_GAMMA_MODE_MANUAL;
40
41 attr_v10.stManual.Gamma_en = attr.atrrV21.stManual.Gamma_en;
42 attr_v10.stManual.Gamma_out_offset = attr.atrrV21.stManual.Gamma_out_offset;
43 attr_v10.stManual.Gamma_out_segnum = attr.atrrV21.stManual.Gamma_out_segnum;
44 for (int i = 0; i < CALIBDB_AGAMMA_KNOTS_NUM_V10; i++)
45 attr_v10.stManual.Gamma_curve[i] = attr.atrrV21.stManual.Gamma_curve[i];
46
47 if (attr.atrrV21.mode == GAMMA_MODE_FAST) {
48 attr_v10.stManual.Gamma_en = attr.atrrV21.stFast.en;
49 attr_v10.stManual.Gamma_out_offset = 0;
50 attr_v10.stManual.Gamma_out_segnum = GAMMATYPE_LOG;
51 float gamma_X_v10[CALIBDB_AGAMMA_KNOTS_NUM_V10] = {
52 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24,
53 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,
54 384, 448, 512, 640, 768, 896, 1024, 1280, 1536, 1792, 2048, 2560, 3072, 3584, 4095};
55 float gamma_Y_v10[CALIBDB_AGAMMA_KNOTS_NUM_V10];
56 for (int i = 0; i < CALIBDB_AGAMMA_KNOTS_NUM_V10; i++) {
57 gamma_Y_v10[i] = 4095 * pow(gamma_X_v10[i] / 4095, 1 / attr.atrrV21.stFast.GammaCoef +
58 attr.atrrV21.stFast.SlopeAtZero);
59 gamma_Y_v10[i] = gamma_Y_v10[i] > 4095 ? 4095 : gamma_Y_v10[i] < 0 ? 0 : gamma_Y_v10[i];
60 attr_v10.stManual.Gamma_curve[i] = (int)(gamma_Y_v10[i] + 0.5);
61 }
62 }
63 ret = rk_aiq_user_api2_agamma_v10_SetAttrib(sys_ctx, &attr_v10);
64 #endif
65 #if RKAIQ_HAVE_GAMMA_V11
66 rk_aiq_gamma_v11_attr_t attr_v11;
67 memset(&attr_v11, 0x0, sizeof(rk_aiq_gamma_v11_attr_t));
68
69 attr_v11.sync.done = attr.sync.done;
70 attr_v11.sync.sync_mode = attr.sync.sync_mode;
71 if (attr.atrrV30.mode == GAMMA_MODE_OFF)
72 attr_v11.mode = RK_AIQ_GAMMA_MODE_AUTO;
73 else if (attr.atrrV30.mode == GAMMA_MODE_MANUAL || attr.atrrV30.mode == GAMMA_MODE_FAST)
74 attr_v11.mode = RK_AIQ_GAMMA_MODE_MANUAL;
75
76 attr_v11.stManual.Gamma_en = attr.atrrV30.stManual.Gamma_en;
77 attr_v11.stManual.Gamma_out_offset = attr.atrrV30.stManual.Gamma_out_offset;
78 for (int i = 0; i < CALIBDB_AGAMMA_KNOTS_NUM_V11; i++)
79 attr_v11.stManual.Gamma_curve[i] = attr.atrrV30.stManual.Gamma_curve[i];
80
81 if (attr.atrrV30.mode == GAMMA_MODE_FAST) {
82 attr_v11.stManual.Gamma_en = attr.atrrV30.stFast.en;
83 attr_v11.stManual.Gamma_out_offset = 0;
84 float gamma_X_v11[CALIBDB_AGAMMA_KNOTS_NUM_V11] = {
85 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16,
86 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160,
87 192, 224, 256, 320, 384, 448, 512, 640, 768, 896, 1024, 1280, 1536,
88 1792, 2048, 2304, 2560, 2816, 3072, 3328, 3584, 3840, 4095};
89 float gamma_Y_v11[CALIBDB_AGAMMA_KNOTS_NUM_V11];
90 for (int i = 0; i < CALIBDB_AGAMMA_KNOTS_NUM_V11; i++) {
91 gamma_Y_v11[i] = 4095 * pow(gamma_X_v11[i] / 4095, 1 / attr.atrrV30.stFast.GammaCoef +
92 attr.atrrV30.stFast.SlopeAtZero);
93 gamma_Y_v11[i] = gamma_Y_v11[i] > 4095 ? 4095 : gamma_Y_v11[i] < 0 ? 0 : gamma_Y_v11[i];
94 attr_v11.stManual.Gamma_curve[i] = (int)(gamma_Y_v11[i] + 0.5);
95 }
96 }
97 ret = rk_aiq_user_api2_agamma_v11_SetAttrib(sys_ctx, &attr_v11);
98 #endif
99 return ret;
100 }
rk_aiq_user_api2_agamma_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_gamma_attrib_V2_t * attr)101 XCamReturn rk_aiq_user_api2_agamma_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
102 rk_aiq_gamma_attrib_V2_t* attr) {
103 XCamReturn ret = XCAM_RETURN_NO_ERROR;
104 #if RKAIQ_HAVE_GAMMA_V10
105 rk_aiq_gamma_v10_attr_t attr_v10;
106 memset(&attr_v10, 0x0, sizeof(rk_aiq_gamma_v10_attr_t));
107 ret = rk_aiq_user_api2_agamma_v10_GetAttrib(sys_ctx, &attr_v10);
108
109 attr->sync.done = attr_v10.sync.done;
110 attr->sync.sync_mode = attr_v10.sync.sync_mode;
111 if (attr_v10.mode == RK_AIQ_GAMMA_MODE_AUTO)
112 attr->atrrV21.mode = GAMMA_MODE_OFF;
113 else if (attr_v10.mode == RK_AIQ_GAMMA_MODE_MANUAL)
114 attr->atrrV21.mode = GAMMA_MODE_MANUAL;
115
116 attr->atrrV21.stManual.Gamma_en = attr_v10.stManual.Gamma_en;
117 attr->atrrV21.stManual.Gamma_out_offset = attr_v10.stManual.Gamma_out_offset;
118 attr->atrrV21.stManual.Gamma_out_segnum = attr_v10.stManual.Gamma_out_segnum;
119 for (int i = 0; i < CALIBDB_AGAMMA_KNOTS_NUM_V10; i++)
120 attr->atrrV21.stManual.Gamma_curve[i] = attr_v10.stManual.Gamma_curve[i];
121 #endif
122 #if RKAIQ_HAVE_GAMMA_V11
123 rk_aiq_gamma_v11_attr_t attr_v11;
124 memset(&attr_v11, 0x0, sizeof(rk_aiq_gamma_v11_attr_t));
125 ret = rk_aiq_user_api2_agamma_v11_GetAttrib(sys_ctx, &attr_v11);
126
127 attr->sync.done = attr_v11.sync.done;
128 attr->sync.sync_mode = attr_v11.sync.sync_mode;
129 if (attr_v11.mode == RK_AIQ_GAMMA_MODE_AUTO)
130 attr->atrrV30.mode = GAMMA_MODE_OFF;
131 else if (attr_v11.mode == RK_AIQ_GAMMA_MODE_MANUAL)
132 attr->atrrV30.mode = GAMMA_MODE_MANUAL;
133
134 attr->atrrV30.stManual.Gamma_en = attr_v11.stManual.Gamma_en;
135 attr->atrrV30.stManual.Gamma_out_offset = attr_v11.stManual.Gamma_out_offset;
136 for (int i = 0; i < CALIBDB_AGAMMA_KNOTS_NUM_V11; i++)
137 attr->atrrV30.stManual.Gamma_curve[i] = attr_v11.stManual.Gamma_curve[i];
138 #endif
139 return ret;
140 }
141
142 #if RKAIQ_HAVE_GAMMA_V10
rk_aiq_user_api2_agamma_v10_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_gamma_v10_attr_t * attr)143 XCamReturn rk_aiq_user_api2_agamma_v10_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
144 const rk_aiq_gamma_v10_attr_t* attr) {
145 CHECK_USER_API_ENABLE2(sys_ctx);
146 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AGAMMA);
147 RKAIQ_API_SMART_LOCK(sys_ctx);
148
149 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
150 #ifdef RKAIQ_ENABLE_CAMGROUP
151 RkAiqCamGroupAgammaHandleInt* algo_handle =
152 camgroupAlgoHandle<RkAiqCamGroupAgammaHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AGAMMA);
153
154 if (algo_handle) {
155 return algo_handle->setAttribV10(attr);
156 } else {
157 XCamReturn ret = XCAM_RETURN_NO_ERROR;
158 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
159 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
160 if (!camCtx)
161 continue;
162
163 RkAiqAgammaHandleInt* singleCam_algo_handle =
164 algoHandle<RkAiqAgammaHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AGAMMA);
165 if (singleCam_algo_handle) {
166 ret = singleCam_algo_handle->setAttribV10(attr);
167 if (ret != XCAM_RETURN_NO_ERROR) LOGE("%s returned: %d", __FUNCTION__, ret);
168 }
169 }
170 return ret;
171 }
172 #else
173 return XCAM_RETURN_ERROR_FAILED;
174 #endif
175 } else {
176 RkAiqAgammaHandleInt* algo_handle =
177 algoHandle<RkAiqAgammaHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AGAMMA);
178
179 if (algo_handle) {
180 return algo_handle->setAttribV10(attr);
181 }
182 }
183
184 return XCAM_RETURN_NO_ERROR;
185 }
186
rk_aiq_user_api2_agamma_v10_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_gamma_v10_attr_t * attr)187 XCamReturn rk_aiq_user_api2_agamma_v10_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
188 rk_aiq_gamma_v10_attr_t* attr) {
189 RKAIQ_API_SMART_LOCK(sys_ctx);
190
191 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
192 #ifdef RKAIQ_ENABLE_CAMGROUP
193 RkAiqCamGroupAgammaHandleInt* algo_handle =
194 camgroupAlgoHandle<RkAiqCamGroupAgammaHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AGAMMA);
195
196 if (algo_handle) {
197 return algo_handle->getAttribV10(attr);
198 } else {
199 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
200 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
201 if (!camCtx)
202 continue;
203
204 RkAiqAgammaHandleInt* singleCam_algo_handle =
205 algoHandle<RkAiqAgammaHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AGAMMA);
206 if (singleCam_algo_handle) return singleCam_algo_handle->getAttribV10(attr);
207 }
208 }
209 #else
210 return XCAM_RETURN_ERROR_FAILED;
211 #endif
212 } else {
213 RkAiqAgammaHandleInt* algo_handle =
214 algoHandle<RkAiqAgammaHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AGAMMA);
215
216 if (algo_handle) {
217 return algo_handle->getAttribV10(attr);
218 }
219 }
220
221 return XCAM_RETURN_NO_ERROR;
222 }
223 #else
rk_aiq_user_api2_agamma_v10_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_gamma_v10_attr_t * attr)224 XCamReturn rk_aiq_user_api2_agamma_v10_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
225 const rk_aiq_gamma_v10_attr_t* attr) {
226 return XCAM_RETURN_ERROR_UNKNOWN;
227 }
228
rk_aiq_user_api2_agamma_v10_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_gamma_v10_attr_t * attr)229 XCamReturn rk_aiq_user_api2_agamma_v10_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
230 rk_aiq_gamma_v10_attr_t* attr) {
231 return XCAM_RETURN_ERROR_UNKNOWN;
232 }
233 #endif
234
235 #if RKAIQ_HAVE_GAMMA_V11
rk_aiq_user_api2_agamma_v11_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_gamma_v11_attr_t * attr)236 XCamReturn rk_aiq_user_api2_agamma_v11_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
237 const rk_aiq_gamma_v11_attr_t* attr) {
238 CHECK_USER_API_ENABLE2(sys_ctx);
239 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AGAMMA);
240 RKAIQ_API_SMART_LOCK(sys_ctx);
241 XCamReturn ret = XCAM_RETURN_NO_ERROR;
242
243 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
244 #ifdef RKAIQ_ENABLE_CAMGROUP
245 RkAiqCamGroupAgammaHandleInt* algo_handle =
246 camgroupAlgoHandle<RkAiqCamGroupAgammaHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AGAMMA);
247
248 if (algo_handle) {
249 return algo_handle->setAttribV11(attr);
250 } else {
251 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
252 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
253 if (!camCtx) continue;
254
255 RkAiqAgammaHandleInt* singleCam_algo_handle =
256 algoHandle<RkAiqAgammaHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AGAMMA);
257 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttribV11(attr);
258 }
259 }
260 #else
261 return XCAM_RETURN_ERROR_FAILED;
262 #endif
263 } else {
264 RkAiqAgammaHandleInt* algo_handle =
265 algoHandle<RkAiqAgammaHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AGAMMA);
266
267 if (algo_handle) {
268 return algo_handle->setAttribV11(attr);
269 }
270 }
271
272 return ret;
273 }
274
rk_aiq_user_api2_agamma_v11_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_gamma_v11_attr_t * attr)275 XCamReturn rk_aiq_user_api2_agamma_v11_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
276 rk_aiq_gamma_v11_attr_t* attr) {
277 RKAIQ_API_SMART_LOCK(sys_ctx);
278 XCamReturn ret = XCAM_RETURN_NO_ERROR;
279
280 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
281 #ifdef RKAIQ_ENABLE_CAMGROUP
282 RkAiqCamGroupAgammaHandleInt* algo_handle =
283 camgroupAlgoHandle<RkAiqCamGroupAgammaHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AGAMMA);
284
285 if (algo_handle) {
286 return algo_handle->getAttribV11(attr);
287 } else {
288 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
289 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
290 if (!camCtx) continue;
291
292 RkAiqAgammaHandleInt* singleCam_algo_handle =
293 algoHandle<RkAiqAgammaHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AGAMMA);
294 if (singleCam_algo_handle) return singleCam_algo_handle->getAttribV11(attr);
295 }
296 }
297 #else
298 return XCAM_RETURN_ERROR_FAILED;
299 #endif
300 } else {
301 RkAiqAgammaHandleInt* algo_handle =
302 algoHandle<RkAiqAgammaHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AGAMMA);
303
304 if (algo_handle) {
305 return algo_handle->getAttribV11(attr);
306 }
307 }
308
309 return ret;
310 }
311 #else
rk_aiq_user_api2_agamma_v11_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_gamma_v11_attr_t * attr)312 XCamReturn rk_aiq_user_api2_agamma_v11_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
313 const rk_aiq_gamma_v11_attr_t* attr) {
314 return XCAM_RETURN_ERROR_UNKNOWN;
315 }
316
rk_aiq_user_api2_agamma_v11_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_gamma_v11_attr_t * attr)317 XCamReturn rk_aiq_user_api2_agamma_v11_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
318 rk_aiq_gamma_v11_attr_t* attr) {
319 return XCAM_RETURN_ERROR_UNKNOWN;
320 }
321 #endif
322
323 RKAIQ_END_DECLARE
324