1 /*
2 * Copyright (c) 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 "sample_cac_module.h"
17
18 #include "sample_comm.h"
19 #include "uAPI2/rk_aiq_user_api2_acac.h"
20
21 static int g_cac_ver = 3;
22
sample_cac_usage()23 static void sample_cac_usage() {
24 printf("Usage : \n");
25 printf(" Module API: \n");
26 printf("\t a) CAC: Set cac Attr & Sync .\n");
27 printf("\t b) CAC: Set cac Attr & Async .\n");
28 printf("\t v) CAC: Version selection. \n");
29 printf("\n");
30 printf("\t h) CAC: help.\n");
31 printf("\t q) CAC: return to main sample screen.\n");
32
33 printf("\n");
34 printf("\t please press the key: ");
35
36 return;
37 }
38
sample_cac_version()39 static void sample_cac_version() {
40 printf("Version list: \n");
41 printf("\t 1) CAC V03\n");
42 printf("\t 2) CAC V10\n");
43 printf("\t 3) CAC V11\n");
44 printf("\t please select a number: ");
45 }
46
sample_print_cac_info(const void * arg)47 void sample_print_cac_info(const void* arg) { printf("enter CAC modult test!\n"); }
48
49 /*
50 ******************************
51 *
52 * Module level API Sample Func
53 *
54 ******************************
55 */
sample_cac_v03_fill_params(rkaiq_cac_v03_api_attr_t * param,rk_aiq_uapi_mode_sync_e sync)56 static void sample_cac_v03_fill_params(rkaiq_cac_v03_api_attr_t* param,
57 rk_aiq_uapi_mode_sync_e sync) {
58 param->sync.sync_mode = sync;
59 param->op_mode = RKAIQ_CAC_API_OPMODE_MANUAL;
60 param->enable = true;
61 param->manual_param.bypass = 1;
62 param->manual_param.AutoHighLightDetect = true;
63 param->manual_param.AutoHighLightOffset = 0;
64 param->manual_param.FixHighLightBase = 0;
65 param->manual_param.YCompensate = 0;
66 param->manual_param.AutoStrengthU = 0;
67 param->manual_param.AutoStrengthV = 0;
68 param->manual_param.GrayStrengthU = 0;
69 param->manual_param.GrayStrengthV = 0;
70 }
71
sample_cac_v10_fill_params(rkaiq_cac_v10_api_attr_t * param,rk_aiq_uapi_mode_sync_e sync)72 static void sample_cac_v10_fill_params(rkaiq_cac_v10_api_attr_t* param,
73 rk_aiq_uapi_mode_sync_e sync) {
74 param->sync.sync_mode = sync;
75 param->op_mode = RKAIQ_CAC_API_OPMODE_MANUAL;
76 param->enable = true;
77 param->manual_param.bypass = 0;
78 param->manual_param.strength_table[0] = 0.33;
79 param->manual_param.strength_table[1] = 0.33;
80 param->manual_param.strength_table[2] = 0.33;
81 param->manual_param.strength_table[3] = 0.33;
82 param->manual_param.strength_table[4] = 0.33;
83 param->manual_param.strength_table[5] = 0.33;
84 param->manual_param.strength_table[6] = 0.33;
85 param->manual_param.strength_table[7] = 0.33;
86 param->manual_param.strength_table[8] = 0.33;
87 param->manual_param.strength_table[9] = 0.33;
88 param->manual_param.strength_table[10] = 0.33;
89 param->manual_param.strength_table[11] = 0.33;
90 param->manual_param.strength_table[12] = 0.33;
91 param->manual_param.strength_table[13] = 0.33;
92 param->manual_param.strength_table[14] = 0.33;
93 param->manual_param.strength_table[15] = 0.33;
94 param->manual_param.strength_table[16] = 0.33;
95 param->manual_param.strength_table[17] = 0.33;
96 param->manual_param.strength_table[18] = 0.33;
97 param->manual_param.strength_table[19] = 0.33;
98 param->manual_param.strength_table[20] = 0.33;
99 param->manual_param.strength_table[21] = 0.33;
100 }
101
sample_cac_v11_fill_params(rkaiq_cac_v11_api_attr_t * param,rk_aiq_uapi_mode_sync_e sync)102 static void sample_cac_v11_fill_params(rkaiq_cac_v11_api_attr_t* param,
103 rk_aiq_uapi_mode_sync_e sync) {
104 param->sync.sync_mode = sync;
105 param->op_mode = RKAIQ_CAC_API_OPMODE_MANUAL;
106 param->enable = true;
107 param->manual_param.bypass = 0;
108 param->manual_param.strength_table[0] = 0.33;
109 param->manual_param.strength_table[1] = 0.33;
110 param->manual_param.strength_table[2] = 0.33;
111 param->manual_param.strength_table[3] = 0.33;
112 param->manual_param.strength_table[4] = 0.33;
113 param->manual_param.strength_table[5] = 0.33;
114 param->manual_param.strength_table[6] = 0.33;
115 param->manual_param.strength_table[7] = 0.33;
116 param->manual_param.strength_table[8] = 0.33;
117 param->manual_param.strength_table[9] = 0.33;
118 param->manual_param.strength_table[10] = 0.33;
119 param->manual_param.strength_table[11] = 0.33;
120 param->manual_param.strength_table[12] = 0.33;
121 param->manual_param.strength_table[13] = 0.33;
122 param->manual_param.strength_table[14] = 0.33;
123 param->manual_param.strength_table[15] = 0.33;
124 param->manual_param.strength_table[16] = 0.33;
125 param->manual_param.strength_table[17] = 0.33;
126 param->manual_param.strength_table[18] = 0.33;
127 param->manual_param.strength_table[19] = 0.33;
128 param->manual_param.strength_table[20] = 0.33;
129 param->manual_param.strength_table[21] = 0.33;
130 param->manual_param.clip_g_mode = RKAIQ_CAC_CLIP_G_MODE_MINIMAL;
131 param->manual_param.neg_clip0_enable = true;
132 param->manual_param.edge_detect_en = true;
133 param->manual_param.flat_thed_b = 1.0;
134 param->manual_param.flat_thed_r = 1.0;
135 param->manual_param.offset_b = 0.0;
136 param->manual_param.offset_r = 0.0;
137 param->manual_param.expo_det_b_en = true;
138 param->manual_param.expo_det_r_en = true;
139 // (hdr ratio * (1 << raw_bits))
140 param->manual_param.expo_thed_b = 1 << 10;
141 param->manual_param.expo_thed_r = 1 << 10;
142 param->manual_param.expo_adj_b = 1 << 10;
143 param->manual_param.expo_adj_r = 1 << 10;
144 }
145
sample_cac_setcacAttr(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)146 static int sample_cac_setcacAttr(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync) {
147 XCamReturn ret = XCAM_RETURN_NO_ERROR;
148 rkaiq_cac_v03_api_attr_t attr_v03;
149 rkaiq_cac_v10_api_attr_t attr_v10;
150 rkaiq_cac_v11_api_attr_t attr_v11;
151
152 if (g_cac_ver == 3) {
153 memset(&attr_v03, 0, sizeof(rkaiq_cac_v03_api_attr_t));
154 ret = rk_aiq_user_api2_acac_v03_GetAttrib(ctx, &attr_v03);
155 RKAIQ_SAMPLE_CHECK_RET(ret, "setcacAttr failed in getting acac attrib!");
156
157 sample_cac_v03_fill_params(&attr_v03, sync);
158
159 ret = rk_aiq_user_api2_acac_v03_SetAttrib(ctx, &attr_v03);
160 RKAIQ_SAMPLE_CHECK_RET(ret, "set CAC Attr failed!");
161 } else if (g_cac_ver == 10) {
162 memset(&attr_v10, 0, sizeof(rkaiq_cac_v10_api_attr_t));
163 ret = rk_aiq_user_api2_acac_v10_GetAttrib(ctx, &attr_v10);
164 RKAIQ_SAMPLE_CHECK_RET(ret, "setcacAttr failed in getting acac attrib!");
165
166 sample_cac_v10_fill_params(&attr_v10, sync);
167
168 ret = rk_aiq_user_api2_acac_v10_SetAttrib(ctx, &attr_v10);
169 RKAIQ_SAMPLE_CHECK_RET(ret, "set CAC Attr failed!");
170 } else if (g_cac_ver == 11) {
171 memset(&attr_v11, 0, sizeof(rkaiq_cac_v11_api_attr_t));
172 ret = rk_aiq_user_api2_acac_v11_GetAttrib(ctx, &attr_v11);
173 RKAIQ_SAMPLE_CHECK_RET(ret, "setcacAttr failed in getting acac attrib!");
174
175 sample_cac_v11_fill_params(&attr_v11, sync);
176
177 ret = rk_aiq_user_api2_acac_v11_SetAttrib(ctx, &attr_v11);
178 RKAIQ_SAMPLE_CHECK_RET(ret, "set CAC Attr failed!");
179 }
180 printf("set CAC Attr\n\n");
181
182 return 0;
183 }
184
sample_cac_v03_dump_attr(const rkaiq_cac_v03_api_attr_t * attr)185 static void sample_cac_v03_dump_attr(const rkaiq_cac_v03_api_attr_t* attr) {
186 printf("Dump CAC V03 attributes:\n");
187 printf("\t sync = %d, done = %d\n", attr->sync.sync_mode, attr->sync.done);
188 printf("\t Mode = %s\n",
189 (attr->op_mode == RKAIQ_CAC_API_OPMODE_AUTO
190 ? "auto"
191 : ((attr->op_mode == RKAIQ_CAC_API_OPMODE_MANUAL) ? "manual" : "invalid")));
192 if (attr->op_mode == RKAIQ_CAC_API_OPMODE_MANUAL) {
193 printf("\t bypass = %d", attr->manual_param.bypass);
194 }
195 }
196
sample_cac_v10_dump_attr(const rkaiq_cac_v10_api_attr_t * attr)197 static void sample_cac_v10_dump_attr(const rkaiq_cac_v10_api_attr_t* attr) {
198 printf("Dump CAC V10 attributes:\n");
199 printf("\t sync = %d, done = %d\n", attr->sync.sync_mode, attr->sync.done);
200 printf("\t Mode = %s\n",
201 (attr->op_mode == RKAIQ_CAC_API_OPMODE_AUTO
202 ? "auto"
203 : ((attr->op_mode == RKAIQ_CAC_API_OPMODE_MANUAL) ? "manual" : "invalid")));
204 printf("\t enable = %d\n", attr->enable);
205 printf("\t default enable : %d\n", attr->persist_params.enable);
206 printf("\t psf path: %s\n", attr->persist_params.psf_path);
207 printf("\t psf shift bits: %d\n", attr->persist_params.psf_shift_bits);
208 printf("\t center en : %d\n", attr->persist_params.center_en);
209 printf("\t center x : %d\n", attr->persist_params.center_x);
210 printf("\t center y : %d\n", attr->persist_params.center_y);
211 const rkaiq_cac_v10_param_selected_t* param = nullptr;
212 if (attr->op_mode == RKAIQ_CAC_API_OPMODE_MANUAL) {
213 param = &attr->manual_param;
214 } else if (attr->op_mode == RKAIQ_CAC_API_OPMODE_MANUAL) {
215 param = &attr->auto_params[0];
216 } else {
217 printf("\t mode invalide\n");
218 return;
219 }
220 printf("\t bypass = %d\n", param->bypass);
221 int strength_cnt = sizeof(param->strength_table) / sizeof(param->strength_table[0]);
222 for (int i = 0; i < strength_cnt; i++) {
223 printf("\t strength %d = %f\n", i, param->strength_table[i]);
224 }
225 }
226
sample_cac_v11_dump_attr(const rkaiq_cac_v11_api_attr_t * attr)227 static void sample_cac_v11_dump_attr(const rkaiq_cac_v11_api_attr_t* attr) {
228 printf("Dump CAC V11 attributes:\n");
229 printf("\t sync = %d, done = %d\n", attr->sync.sync_mode, attr->sync.done);
230 printf("\t Mode = %s\n",
231 (attr->op_mode == RKAIQ_CAC_API_OPMODE_AUTO
232 ? "auto"
233 : ((attr->op_mode == RKAIQ_CAC_API_OPMODE_MANUAL) ? "manual" : "invalid")));
234 printf("\t enable = %d\n", attr->enable);
235 printf("\t default enable : %d\n", attr->persist_params.enable);
236 printf("\t psf path: %s\n", attr->persist_params.psf_path);
237 printf("\t psf shift bits: %d\n", attr->persist_params.psf_shift_bits);
238 printf("\t center en : %d\n", attr->persist_params.center_en);
239 printf("\t center x : %d\n", attr->persist_params.center_x);
240 printf("\t center y : %d\n", attr->persist_params.center_y);
241
242 const rkaiq_cac_v11_param_selected_t* param = nullptr;
243 if (attr->op_mode == RKAIQ_CAC_API_OPMODE_MANUAL) {
244 param = &attr->manual_param;
245 } else if (attr->op_mode == RKAIQ_CAC_API_OPMODE_MANUAL) {
246 param = &attr->auto_params[0];
247 } else {
248 printf("\t mode invalide\n");
249 return;
250 }
251 printf("\t bypass = %d\n", param->bypass);
252 int strength_cnt = sizeof(param->strength_table) / sizeof(param->strength_table[0]);
253 for (int i = 0; i < strength_cnt; i++) {
254 printf("\t strength %d = %f\n", i, param->strength_table[i]);
255 }
256 printf("\t clip_g_mode : %d\n", param->clip_g_mode);
257 printf("\t neg_clip0_enable : %d\n", param->neg_clip0_enable);
258 printf("\t edge_detect_en : %d\n", param->edge_detect_en);
259 printf("\t flat_thed_b : %f\n", param->flat_thed_b);
260 printf("\t flat_thed_r : %f \n", param->flat_thed_r);
261 printf("\t offset_b : %u\n", param->offset_b);
262 printf("\t offset_r : %u\n", param->offset_r);
263 printf("\t expo_det_b_en : %d\n", param->expo_det_b_en);
264 printf("\t expo_det_r_en : %d\n", param->expo_det_r_en);
265 printf("\t expo_thed_b : %u\n", param->expo_thed_b);
266 printf("\t expo_thed_r : %u\n", param->expo_thed_r);
267 printf("\t expo_adj_b : %u\n", param->expo_adj_b);
268 printf("\t expo_adj_r : %u\n", param->expo_adj_r);
269 }
270
sample_cac_getcacAttr(const rk_aiq_sys_ctx_t * ctx)271 static int sample_cac_getcacAttr(const rk_aiq_sys_ctx_t* ctx) {
272 XCamReturn ret = XCAM_RETURN_NO_ERROR;
273 rkaiq_cac_v03_api_attr_t attr_v03;
274 rkaiq_cac_v10_api_attr_t attr_v10;
275 rkaiq_cac_v11_api_attr_t attr_v11;
276
277 if (g_cac_ver == 3) {
278 memset(&attr_v03, 0, sizeof(rkaiq_cac_v03_api_attr_t));
279 ret = rk_aiq_user_api2_acac_v03_GetAttrib(ctx, &attr_v03);
280 RKAIQ_SAMPLE_CHECK_RET(ret, "get cac Attr failed!");
281 printf("get CAC Attr:\n\n");
282 sample_cac_v03_dump_attr(&attr_v03);
283 } else if (g_cac_ver == 10) {
284 memset(&attr_v10, 0, sizeof(rkaiq_cac_v10_api_attr_t));
285 ret = rk_aiq_user_api2_acac_v10_GetAttrib(ctx, &attr_v10);
286 RKAIQ_SAMPLE_CHECK_RET(ret, "get cac Attr failed!");
287 printf("get CAC Attr:\n\n");
288 sample_cac_v10_dump_attr(&attr_v10);
289 } else if (g_cac_ver == 11) {
290 memset(&attr_v11, 0, sizeof(rkaiq_cac_v11_api_attr_t));
291 ret = rk_aiq_user_api2_acac_v11_GetAttrib(ctx, &attr_v11);
292 RKAIQ_SAMPLE_CHECK_RET(ret, "get cac Attr failed!");
293 printf("get CAC Attr:\n\n");
294 sample_cac_v11_dump_attr(&attr_v11);
295 }
296
297 return 0;
298 }
299
sample_cac_module(const void * arg)300 XCamReturn sample_cac_module(const void* arg) {
301 int key = -1;
302 CLEAR();
303
304 const demo_context_t* demo_ctx = (demo_context_t*)arg;
305 const rk_aiq_sys_ctx_t* ctx;
306 if (demo_ctx->camGroup) {
307 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
308 } else {
309 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
310 }
311
312 if (ctx == NULL) {
313 ERR("%s, ctx is nullptr\n", __FUNCTION__);
314 return XCAM_RETURN_ERROR_PARAM;
315 }
316
317 sample_cac_usage();
318
319 do {
320 key = getchar();
321 while (key == '\n' || key == '\r') key = getchar();
322 printf("\n");
323
324 switch (key) {
325 case 'h':
326 sample_cac_usage();
327 CLEAR();
328 break;
329 case 'v':
330 sample_cac_version();
331 break;
332 case '1':
333 g_cac_ver = 3;
334 printf("Using CAC V03\n");
335 sample_cac_usage();
336 break;
337 case '2':
338 g_cac_ver = 10;
339 printf("Using CAC V10\n");
340 sample_cac_usage();
341 break;
342 case '3':
343 g_cac_ver = 11;
344 printf("Using CAC V11\n");
345 sample_cac_usage();
346 break;
347 case 'a':
348 sample_cac_setcacAttr(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
349 sample_cac_getcacAttr(ctx);
350 break;
351 case 'b':
352 sample_cac_setcacAttr(ctx, RK_AIQ_UAPI_MODE_ASYNC);
353 sample_cac_getcacAttr(ctx);
354 usleep(40 * 1000);
355 sample_cac_getcacAttr(ctx);
356 break;
357 default:
358 CLEAR();
359 sample_cac_usage();
360 break;
361 }
362 } while (key != 'q' && key != 'Q');
363
364 return XCAM_RETURN_NO_ERROR;
365 }
366