1 /*
2 * Copyright (c) 2019 Rockchip Corporation
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 */
17
18 #include "sample_comm.h"
19
sample_acp_usage()20 static void sample_acp_usage()
21 {
22 printf("Usage : \n");
23 printf(" Module API: \n");
24 printf("\t 1) ACP: Set brightness & Async .\n");
25 printf("\t 2) ACP: Set brightness & Sync .\n");
26 printf("\t 3) ACP: Set contrast & Async .\n");
27 printf("\t 4) ACP: Set contrast & Sync .\n");
28 printf("\t 5) ACP: Set saturation & Async.\n");
29 printf("\t 6) ACP: Set saturation & Sync.\n");
30 printf("\t 7) ACP: Set hue & Async.\n");
31 printf("\t 8) ACP: Set hue & Sync.\n");
32 printf("\t 9) ACP: Get acp attrib & Async.\n");
33 printf("\t a) ACP: Get acp attrib & Sync.\n");
34 printf(" ImgProc API: \n");
35 printf("\t b) ACP: Set Contrast.\n");
36 printf("\t c) ACP: Set Brightness.\n");
37 printf("\t d) ACP: Set Saturation.\n");
38 printf("\t e) ACP: Set Hue.\n");
39 printf("\n");
40 printf("\t h) ACP: help.\n");
41 printf("\t q) ACP: return to main sample screen.\n");
42
43 printf("\n");
44 printf("\t please press the key: ");
45
46 return;
47 }
48
sample_print_acp_info(const void * arg)49 void sample_print_acp_info(const void *arg)
50 {
51 printf ("enter ACP module test!\n");
52 }
53
54 /*
55 ******************************
56 *
57 * ImgProc level API Sample Func
58 *
59 ******************************
60 */
61
sample_set_acp_contrast(const rk_aiq_sys_ctx_t * ctx,uint8_t level)62 static int sample_set_acp_contrast(const rk_aiq_sys_ctx_t* ctx, uint8_t level)
63 {
64 rk_aiq_uapi2_setContrast(ctx, level);
65 return 0;
66 }
67
sample_get_acp_contrast(const rk_aiq_sys_ctx_t * ctx)68 static int sample_get_acp_contrast(const rk_aiq_sys_ctx_t* ctx)
69 {
70 unsigned int level;
71 rk_aiq_uapi2_getContrast(ctx, &level);
72 printf("Get ACP Contrast : %d \n", level);
73 return 0;
74 }
75
sample_set_acp_brightness(const rk_aiq_sys_ctx_t * ctx,uint8_t level)76 static int sample_set_acp_brightness(const rk_aiq_sys_ctx_t* ctx, uint8_t level)
77 {
78 rk_aiq_uapi2_setBrightness(ctx, level);
79 return 0;
80 }
81
sample_get_acp_brightness(const rk_aiq_sys_ctx_t * ctx)82 static int sample_get_acp_brightness(const rk_aiq_sys_ctx_t* ctx)
83 {
84 unsigned int level;
85 rk_aiq_uapi2_getBrightness(ctx, &level);
86 printf("Get ACP Brightness : %d \n", level);
87 return 0;
88 }
89
sample_set_acp_saturation(const rk_aiq_sys_ctx_t * ctx,uint8_t level)90 static int sample_set_acp_saturation(const rk_aiq_sys_ctx_t* ctx, uint8_t level)
91 {
92 rk_aiq_uapi2_setSaturation(ctx, level);
93 return 0;
94 }
95
sample_get_acp_saturation(const rk_aiq_sys_ctx_t * ctx)96 static int sample_get_acp_saturation(const rk_aiq_sys_ctx_t* ctx)
97 {
98 unsigned int level;
99 rk_aiq_uapi2_getSaturation(ctx, &level);
100 printf("Get ACP Saturation : %d \n", level);
101 return 0;
102 }
103
sample_set_acp_hue(const rk_aiq_sys_ctx_t * ctx,uint8_t level)104 static int sample_set_acp_hue(const rk_aiq_sys_ctx_t* ctx, uint8_t level)
105 {
106 rk_aiq_uapi2_setHue(ctx, level);
107 return 0;
108 }
109
sample_get_acp_hue(const rk_aiq_sys_ctx_t * ctx)110 static int sample_get_acp_hue(const rk_aiq_sys_ctx_t* ctx)
111 {
112 unsigned int level;
113 rk_aiq_uapi2_getHue(ctx, &level);
114 printf("Get ACP Hue : %d \n", level);
115 return 0;
116 }
117
118 /*
119 ******************************
120 *
121 * Module level API Sample Func
122 *
123 ******************************
124 */
125
sample_acp_set_brightness(const rk_aiq_sys_ctx_t * ctx,uint8_t brightness,rk_aiq_uapi_mode_sync_e sync)126 static int sample_acp_set_brightness(const rk_aiq_sys_ctx_t* ctx, uint8_t brightness,
127 rk_aiq_uapi_mode_sync_e sync)
128 {
129 XCamReturn ret = XCAM_RETURN_NO_ERROR;
130 acp_attrib_t attr;
131 memset(&attr, 0, sizeof(acp_attrib_t));
132
133 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attr);
134 RKAIQ_SAMPLE_CHECK_RET(ret, "setAcpAttr failed in getting acp attrib!");
135
136 attr.sync.sync_mode = sync;
137 attr.brightness = brightness;
138
139 //set
140 ret = rk_aiq_user_api2_acp_SetAttrib(ctx, &attr);
141 RKAIQ_SAMPLE_CHECK_RET(ret, "set acp Attr failed!");
142 printf("set acp brightness: %d, done: %d\n\n", brightness, attr.sync.done);
143
144 return 0;
145 }
146
sample_acp_set_contrast(const rk_aiq_sys_ctx_t * ctx,uint8_t contrast,rk_aiq_uapi_mode_sync_e sync)147 static int sample_acp_set_contrast(const rk_aiq_sys_ctx_t* ctx, uint8_t contrast,
148 rk_aiq_uapi_mode_sync_e sync)
149 {
150 XCamReturn ret = XCAM_RETURN_NO_ERROR;
151 acp_attrib_t attr;
152 memset(&attr, 0, sizeof(acp_attrib_t));
153
154 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attr);
155 RKAIQ_SAMPLE_CHECK_RET(ret, "setAcpAttr failed in getting acp attrib!");
156
157 attr.sync.sync_mode = sync;
158 attr.contrast = contrast;
159
160 //set
161 ret = rk_aiq_user_api2_acp_SetAttrib(ctx, &attr);
162 RKAIQ_SAMPLE_CHECK_RET(ret, "set acp Attr failed!");
163 printf("set acp contrast: %d, done: %d\n\n", contrast, attr.sync.done);
164
165 return 0;
166 }
167
sample_acp_set_saturation(const rk_aiq_sys_ctx_t * ctx,uint8_t saturation,rk_aiq_uapi_mode_sync_e sync)168 static int sample_acp_set_saturation(const rk_aiq_sys_ctx_t* ctx, uint8_t saturation,
169 rk_aiq_uapi_mode_sync_e sync)
170 {
171 XCamReturn ret = XCAM_RETURN_NO_ERROR;
172 acp_attrib_t attr;
173 memset(&attr, 0, sizeof(acp_attrib_t));
174
175 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attr);
176 RKAIQ_SAMPLE_CHECK_RET(ret, "setAcpAttr failed in getting acp attrib!");
177
178 attr.sync.sync_mode = sync;
179 attr.saturation = saturation;
180
181 //set
182 ret = rk_aiq_user_api2_acp_SetAttrib(ctx, &attr);
183 RKAIQ_SAMPLE_CHECK_RET(ret, "set acp Attr failed!");
184 printf("set acp saturation: %d, done: %d\n\n", saturation, attr.sync.done);
185
186 return 0;
187 }
188
sample_acp_set_hue(const rk_aiq_sys_ctx_t * ctx,uint8_t hue,rk_aiq_uapi_mode_sync_e sync)189 static int sample_acp_set_hue(const rk_aiq_sys_ctx_t* ctx, uint8_t hue,
190 rk_aiq_uapi_mode_sync_e sync)
191 {
192 XCamReturn ret = XCAM_RETURN_NO_ERROR;
193 acp_attrib_t attr;
194 memset(&attr, 0, sizeof(acp_attrib_t));
195
196 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attr);
197 RKAIQ_SAMPLE_CHECK_RET(ret, "setAcpAttr failed in getting acp attrib!");
198
199 attr.sync.sync_mode = sync;
200 attr.hue = hue;
201
202 //set
203 ret = rk_aiq_user_api2_acp_SetAttrib(ctx, &attr);
204 RKAIQ_SAMPLE_CHECK_RET(ret, "set acp Attr failed!");
205 printf("set acp hue: %d, done: %d\n\n", hue, attr.sync.done);
206
207 return 0;
208 }
209
sample_acp_get_attrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)210 static int sample_acp_get_attrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
211 {
212 XCamReturn ret = XCAM_RETURN_NO_ERROR;
213 acp_attrib_t attr;
214 memset(&attr,0,sizeof(acp_attrib_t));
215 //get
216 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attr);
217 RKAIQ_SAMPLE_CHECK_RET(ret, "get acp Attr failed!");
218 printf("get acp Attrib:\n\n");
219 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
220 printf("\t brightness = %d, contrast = %d, saturation: %d, hue: %d, done: %d\n",
221 attr.brightness, attr.contrast, attr.saturation, attr.hue, attr.sync.done);
222
223 return 0;
224 }
225
226
sample_acp_module(const void * arg)227 XCamReturn sample_acp_module(const void *arg)
228 {
229 int key = -1;
230 CLEAR();
231 const demo_context_t *demo_ctx = (demo_context_t *)arg;
232 const rk_aiq_sys_ctx_t* ctx;
233 if (demo_ctx->camGroup){
234 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
235 } else {
236 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
237 }
238
239 /*TODO: when rkaiq_3A_server & rkisp_demo run in two different shell, rk_aiq_sys_ctx_t would be null?*/
240 if (ctx == NULL) {
241 ERR ("%s, ctx is nullptr\n", __FUNCTION__);
242 return XCAM_RETURN_ERROR_PARAM;
243 }
244
245 acp_attrib_t default_attr;
246 memset(&default_attr, 0, sizeof(acp_attrib_t));
247 rk_aiq_user_api2_acp_GetAttrib(ctx, &default_attr);
248
249 sample_acp_usage ();
250
251 do {
252
253 key = getchar ();
254 while (key == '\n' || key == '\r')
255 key = getchar();
256 printf ("\n");
257
258 switch (key)
259 {
260 case 'h':
261 CLEAR();
262 sample_acp_usage ();
263 break;
264 case '1':
265 printf("test acp brightness iteratively in async mode...\n");
266 for (int i = 0; i < 255; i++) {
267 sample_acp_set_brightness(ctx, i, RK_AIQ_UAPI_MODE_ASYNC);
268 usleep(10 * 1000);
269 }
270 printf("end of the test\n\n");
271
272 sample_acp_set_brightness(ctx, default_attr.brightness, RK_AIQ_UAPI_MODE_ASYNC);
273 break;
274 case '2':
275 printf("test acp brightness iteratively in sync mode...\n");
276 for (int i = 0; i < 255; i++) {
277 sample_acp_set_brightness(ctx, i, RK_AIQ_UAPI_MODE_SYNC);
278 usleep(10 * 1000);
279 }
280 printf("end of the test\n\n");
281
282 sample_acp_set_brightness(ctx, default_attr.brightness, RK_AIQ_UAPI_MODE_SYNC);
283 break;
284 case '3':
285 printf("test cp contrast iteratively in async mode...\n");
286 for (int i = 0; i < 255; i++) {
287 sample_acp_set_contrast(ctx, i, RK_AIQ_UAPI_MODE_ASYNC);
288 usleep(10 * 1000);
289 }
290 printf("end of the test\n\n");
291
292 sample_acp_set_contrast(ctx, default_attr.contrast, RK_AIQ_UAPI_MODE_ASYNC);
293 break;
294 case '4':
295 printf("test cp contrast iteratively in sync mode...\n");
296 for (int i = 0; i < 255; i++) {
297 sample_acp_set_contrast(ctx, i, RK_AIQ_UAPI_MODE_SYNC);
298 usleep(10 * 1000);
299 }
300 printf("end of the test\n\n");
301
302 sample_acp_set_contrast(ctx, default_attr.contrast, RK_AIQ_UAPI_MODE_SYNC);
303 break;
304 case '5':
305 printf("test cp saturation iteratively in async mode...\n");
306 for (int i = 0; i < 255; i++) {
307 sample_acp_set_saturation(ctx, i, RK_AIQ_UAPI_MODE_ASYNC);
308 usleep(10 * 1000);
309 }
310 printf("end of the test\n\n");
311
312 sample_acp_set_saturation(ctx, default_attr.saturation, RK_AIQ_UAPI_MODE_ASYNC);
313 break;
314 case '6':
315 printf("test cp saturation iteratively in sync mode...\n");
316 for (int i = 0; i < 255; i++) {
317 sample_acp_set_saturation(ctx, i, RK_AIQ_UAPI_MODE_SYNC);
318 usleep(10 * 1000);
319 }
320 printf("end of the test\n\n");
321
322 sample_acp_set_saturation(ctx, default_attr.saturation, RK_AIQ_UAPI_MODE_SYNC);
323 break;
324 case '7':
325 printf("test cp saturation iteratively in async mode...\n");
326 for (int i = 0; i < 255; i++) {
327 sample_acp_set_hue(ctx, i, RK_AIQ_UAPI_MODE_ASYNC);
328 usleep(10 * 1000);
329 }
330 printf("end of the test\n\n");
331
332 sample_acp_set_hue(ctx, default_attr.hue, RK_AIQ_UAPI_MODE_ASYNC);
333 break;
334 case '8':
335 printf("test cp saturation iteratively in sync mode...\n");
336 for (int i = 0; i < 255; i++) {
337 sample_acp_set_hue(ctx, i, RK_AIQ_UAPI_MODE_SYNC);
338 usleep(10 * 1000);
339 }
340 printf("end of the test\n\n");
341
342 sample_acp_set_hue(ctx, default_attr.hue, RK_AIQ_UAPI_MODE_SYNC);
343 break;
344 case '9':
345 sample_acp_get_attrib(ctx, RK_AIQ_UAPI_MODE_ASYNC);
346 break;
347 case 'a':
348 sample_acp_get_attrib(ctx, RK_AIQ_UAPI_MODE_SYNC);
349 break;
350 case 'b':
351 printf("test acp contrast iteratively ...\n");
352 for (int i = 0; i < 255; i++) {
353 sample_set_acp_contrast(ctx, i);
354 usleep(10 * 1000);
355 }
356 printf("end of the test\n\n");
357
358 sample_set_acp_contrast(ctx, default_attr.contrast);
359 break;
360 case 'c':
361 printf("test acp brightness iteratively ...\n");
362 for (int i = 0; i < 255; i++) {
363 sample_set_acp_brightness(ctx, i);
364 usleep(10 * 1000);
365 }
366 printf("end of the test\n\n");
367
368 sample_set_acp_brightness(ctx, default_attr.brightness);
369 break;
370 case 'd':
371 printf("test acp saturation iteratively ...\n");
372 for (int i = 0; i < 255; i++) {
373 sample_set_acp_saturation(ctx, i);
374 usleep(10 * 1000);
375 }
376 printf("end of the test\n\n");
377
378 sample_set_acp_saturation(ctx, default_attr.saturation);
379 break;
380 case 'e':
381 printf("test acp hue iteratively ...\n");
382 for (int i = 0; i < 255; i++) {
383 sample_set_acp_hue(ctx, i);
384 usleep(10 * 1000);
385 }
386 printf("end of the test\n\n");
387
388 sample_set_acp_hue(ctx, default_attr.hue);
389 break;
390 default:
391 break;
392 }
393 } while (key != 'q' && key != 'Q');
394
395 return XCAM_RETURN_NO_ERROR;
396 }
397