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_a3dlut_usage()20 static void sample_a3dlut_usage()
21 {
22 printf("Usage : \n");
23 printf(" ImgProc API: \n");
24 printf("\t 0) 3DLUT: Set 3DLUT MANUAL Mode.\n");
25 printf("\t 1) 3DLUT: Set 3DLUT AUTO Mode.\n");
26 printf("\t 2) 3DLUT: Get 3DLUT Mode.\n");
27 printf("\t 3) 3DLUT: Set 3DLUT Manual Lut.\n");
28 printf("\t 4) 3DLUT: Get 3DLUT Lut.\n");
29 printf("\t 5) 3DLUT: Get A3DLUT Strength.\n");
30 printf("\t 6) 3DLUT: Get A3DLUT LutName.\n");
31 printf(" Module API: \n");
32 printf("\t a) 3DLUT: Set 3dlut Attr & Sync .\n");
33 printf("\t b) 3DLUT: Set 3dlut Attr & Async .\n");
34 printf("\t c) 3DLUT: Set Mode Manual & Sync.\n");
35 printf("\t d) 3DLUT: Set Mode Manual & Async.\n");
36 printf("\t e) 3DLUT: Set Mode Auto & Sync.\n");
37 printf("\t f) 3DLUT: Set Mode Auto & Async.\n");
38 printf("\t g) 3DLUT: Set Manual attr & Sync.\n");
39 printf("\t i) 3DLUT: Set Manual attr & Async.\n");
40 printf("\t j) 3DLUT: Query A3DLUT Info.\n");
41 printf("\n");
42 printf("\t h) 3DLUT: help.\n");
43 printf("\t q) 3DLUT: return to main sample screen.\n");
44
45 printf("\n");
46 printf("\t please press the key: ");
47
48 return;
49 }
50
sample_print_a3dlut_info(const void * arg)51 void sample_print_a3dlut_info(const void *arg)
52 {
53 printf ("enter 3DLUT modult test!\n");
54 }
55
56 /*
57 ******************************
58 *
59 * ImgProc level API Sample Func
60 *
61 ******************************
62 */
63
sample_set_a3dlut_manual(const rk_aiq_sys_ctx_t * ctx)64 static int sample_set_a3dlut_manual(const rk_aiq_sys_ctx_t* ctx)
65 {
66 opMode_t mode = OP_MANUAL;
67 rk_aiq_uapi2_setLut3dMode(ctx, mode);
68 return 0;
69 }
70
sample_set_a3dlut_auto(const rk_aiq_sys_ctx_t * ctx)71 static int sample_set_a3dlut_auto(const rk_aiq_sys_ctx_t* ctx)
72 {
73 opMode_t mode = OP_AUTO;
74 rk_aiq_uapi2_setLut3dMode(ctx, mode);
75 return 0;
76 }
77
sample_get_a3dlut_mode(const rk_aiq_sys_ctx_t * ctx)78 static int sample_get_a3dlut_mode(const rk_aiq_sys_ctx_t* ctx)
79 {
80 opMode_t mode;
81 rk_aiq_uapi2_getLut3dMode(ctx, &mode);
82 if (mode == OP_MANUAL)
83 printf("Get 3DLUT Mode is: Manual \n");
84 else if (mode == OP_AUTO)
85 printf("Get 3DLUT Mode is: AUTO\n");
86 else
87 printf("Get 3DLUT Mode is: INVALID\n");
88 return 0;
89 }
90
sample_set_a3dlut_manual_lut(const rk_aiq_sys_ctx_t * ctx)91 static int sample_set_a3dlut_manual_lut(const rk_aiq_sys_ctx_t* ctx)
92 {
93 rk_aiq_lut3d_table_t mlut;
94 memset(&mlut, 0, sizeof(mlut));
95 // create mlut
96 rk_aiq_uapi2_getM3dLut(ctx, &mlut);
97 memcpy(mlut.look_up_table_b, mlut.look_up_table_r, sizeof(unsigned short) * 729);
98 for(int i = 0; i < 729; i++)
99 mlut.look_up_table_g[i] = mlut.look_up_table_r[i]<<2;
100 // set mlut
101 rk_aiq_uapi2_setM3dLut(ctx, &mlut);
102 printf("Set 3DLUT Manual Lut\n\n");
103 return 0;
104 }
105
sample_get_a3dlut_lut(const rk_aiq_sys_ctx_t * ctx)106 static int sample_get_a3dlut_lut(const rk_aiq_sys_ctx_t* ctx)
107 {
108 rk_aiq_lut3d_table_t mlut;
109 rk_aiq_uapi2_getM3dLut(ctx, &mlut);
110 printf("Get 3DLUT Lut: ");
111 printf("\t r: %d, %d, %d \n", mlut.look_up_table_r[0],
112 mlut.look_up_table_r[1],
113 mlut.look_up_table_r[2]);
114 printf("\t g: %d, %d, %d \n", mlut.look_up_table_g[0],
115 mlut.look_up_table_g[1],
116 mlut.look_up_table_g[2]);
117 printf("\t b: %d, %d, %d \n", mlut.look_up_table_b[0],
118 mlut.look_up_table_b[1],
119 mlut.look_up_table_b[2]);
120 return 0;
121 }
122
sample_get_a3dlut_strength(const rk_aiq_sys_ctx_t * ctx)123 static int sample_get_a3dlut_strength(const rk_aiq_sys_ctx_t* ctx)
124 {
125 float alpha;
126 rk_aiq_uapi2_getA3dLutStrth(ctx, &alpha);
127 printf("Get A3DLUT Strength: %f\n\n", alpha);
128 return 0;
129 }
130
sample_get_a3dlut_lutname(const rk_aiq_sys_ctx_t * ctx)131 static int sample_get_a3dlut_lutname(const rk_aiq_sys_ctx_t* ctx)
132 {
133 char lutname[25];
134 rk_aiq_uapi2_getA3dLutName(ctx, lutname);
135 printf("Get A3DLUT LutName: %s\n\n", lutname);
136 return 0;
137 }
138
139 /*
140 ******************************
141 *
142 * Module level API Sample Func
143 *
144 ******************************
145 */
146
sample_3dlut_set3dlutAttr(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)147 static int sample_3dlut_set3dlutAttr(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
148 {
149 XCamReturn ret = XCAM_RETURN_NO_ERROR;
150 rk_aiq_lut3d_attrib_t attr;
151 memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
152 //get
153 ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
154 RKAIQ_SAMPLE_CHECK_RET(ret, "set3dlutAttr failed in getting a3dlut attrib!");
155 //modify
156 attr.sync.sync_mode = sync;
157 if (attr.mode > 1 ) {
158 attr.mode = RK_AIQ_LUT3D_MODE_MANUAL;
159 memset(attr.stManual.look_up_table_g, 0, 729*sizeof(unsigned short));
160 } else {
161 attr.mode = RK_AIQ_LUT3D_MODE_AUTO;
162 }
163 //set
164 ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, &attr);
165 RKAIQ_SAMPLE_CHECK_RET(ret, "set 3DLUT Attr failed!");
166 printf("set 3DLUT Attr\n\n");
167
168 return 0;
169 }
170
sample_3dlut_get3dlutAttr(const rk_aiq_sys_ctx_t * ctx)171 static int sample_3dlut_get3dlutAttr(const rk_aiq_sys_ctx_t* ctx)
172 {
173 XCamReturn ret = XCAM_RETURN_NO_ERROR;
174 rk_aiq_lut3d_attrib_t attr;
175 memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
176 //get
177 ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
178 RKAIQ_SAMPLE_CHECK_RET(ret, "get 3dlut Attr failed!");
179 printf("get 3DLUT Attr:\n\n");
180 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
181 printf("\t enable = %s\n", (attr.byPass ? "false" : "true"));
182 if (attr.mode == RK_AIQ_LUT3D_MODE_MANUAL){
183 printf("\t mode = Manual\n");
184 printf("\t manual lut");
185 printf("\t\t r: %d, %d, %d \n", attr.stManual.look_up_table_r[0],
186 attr.stManual.look_up_table_r[1],
187 attr.stManual.look_up_table_r[2]);
188 printf("\t\t g: %d, %d, %d \n", attr.stManual.look_up_table_g[0],
189 attr.stManual.look_up_table_g[1],
190 attr.stManual.look_up_table_g[2]);
191 printf("\t\t b: %d, %d, %d \n", attr.stManual.look_up_table_b[0],
192 attr.stManual.look_up_table_b[1],
193 attr.stManual.look_up_table_b[2]);
194 } else if (attr.mode == RK_AIQ_LUT3D_MODE_AUTO){
195 printf("\t mode = Auto\n");
196 } else {
197 printf("\t mode is invalid!");
198 }
199 return 0;
200 }
201
sample_3dlut_setModeManual(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)202 static int sample_3dlut_setModeManual(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
203 {
204 XCamReturn ret = XCAM_RETURN_NO_ERROR;
205 rk_aiq_lut3d_attrib_t attr;
206 memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
207 //get
208 ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
209 RKAIQ_SAMPLE_CHECK_RET(ret, "setModeManual failed in getting a3dlut attrib!");
210 //modify
211 attr.sync.sync_mode = sync;
212 attr.mode = RK_AIQ_LUT3D_MODE_MANUAL;
213 //set
214 ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, &attr);
215 RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Manual failed!");
216 printf("set 3DLUT Mode Manual\n\n");
217
218 return 0;
219 }
220
sample_3dlut_setModeAuto(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)221 static int sample_3dlut_setModeAuto(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
222 {
223 XCamReturn ret = XCAM_RETURN_NO_ERROR;
224 rk_aiq_lut3d_attrib_t attr;
225 memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
226 //get
227 ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
228 RKAIQ_SAMPLE_CHECK_RET(ret, "setModeAuto failed in getting a3dlut attrib!");
229 //modify
230 attr.sync.sync_mode = sync;
231 attr.mode = RK_AIQ_LUT3D_MODE_AUTO;
232 //set
233 ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, &attr);
234 RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Auto failed!");
235 printf("set 3DLUT Mode Auto\n\n");
236
237 return 0;
238 }
239
sample_3dlut_getMode(const rk_aiq_sys_ctx_t * ctx)240 static int sample_3dlut_getMode(const rk_aiq_sys_ctx_t* ctx)
241 {
242 XCamReturn ret = XCAM_RETURN_NO_ERROR;
243 rk_aiq_lut3d_attrib_t attr;
244 memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
245 //get
246 ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
247 RKAIQ_SAMPLE_CHECK_RET(ret, "get 3dlut Mode failed!");
248 printf("get 3DLUT Mode:\n\n");
249 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
250 if (attr.mode == RK_AIQ_LUT3D_MODE_MANUAL){
251 printf("\t mode = Manual\n");
252 } else if (attr.mode == RK_AIQ_LUT3D_MODE_AUTO){
253 printf("\t mode = Auto\n");
254 } else {
255 printf("\t mode is invalid!");
256 }
257 return 0;
258 }
259
sample_3dlut_setM3dlut(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)260 static int sample_3dlut_setM3dlut(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
261 {
262 XCamReturn ret = XCAM_RETURN_NO_ERROR;
263 rk_aiq_lut3d_attrib_t attr;
264 memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
265 //get
266 ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
267 RKAIQ_SAMPLE_CHECK_RET(ret, "setM3dlut failed in getting a3dlut attrib!");
268 //modify
269 attr.sync.sync_mode = sync;
270 attr.mode = RK_AIQ_LUT3D_MODE_MANUAL;
271 if (attr.stManual.look_up_table_g[2] > 0) {
272 memset(attr.stManual.look_up_table_g, 0, 729*sizeof(unsigned short));
273 } else {
274 memcpy(attr.stManual.look_up_table_g, attr.stManual.look_up_table_r, \
275 sizeof(attr.stManual.look_up_table_r));
276 }
277
278 //set
279 ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, &attr);
280 RKAIQ_SAMPLE_CHECK_RET(ret, "set Manual attr failed!");
281 printf("set Manual attr\n\n");
282
283 return 0;
284 }
285
286
sample_query_a3dlut_info(const rk_aiq_sys_ctx_t * ctx)287 static int sample_query_a3dlut_info(const rk_aiq_sys_ctx_t* ctx)
288 {
289 rk_aiq_lut3d_querry_info_t info;
290 rk_aiq_user_api2_a3dlut_Query3dlutInfo(ctx, &info);
291 printf("Query 3DLUT Info:\n\n");
292 printf("\t enable: %s, \n", (info.lut3d_en ? "true" : "false"));
293 printf("\t lut: ");
294 printf("\t\t r: %d, %d, %d \n", info.look_up_table_r[0],
295 info.look_up_table_r[1],
296 info.look_up_table_r[2]);
297 printf("\t\t g: %d, %d, %d \n", info.look_up_table_g[0],
298 info.look_up_table_g[1],
299 info.look_up_table_g[2]);
300 printf("\t\t b: %d, %d, %d \n", info.look_up_table_b[0],
301 info.look_up_table_b[1],
302 info.look_up_table_b[2]);
303 printf("\t alpha: %f \n", info.alpha);
304 printf("\t lutname: %s \n", info.name);
305 return 0;
306 }
307
sample_a3dlut_module(const void * arg)308 XCamReturn sample_a3dlut_module(const void *arg)
309 {
310 int key = -1;
311 CLEAR();
312
313 const demo_context_t *demo_ctx = (demo_context_t *)arg;
314 const rk_aiq_sys_ctx_t* ctx;
315 if (demo_ctx->camGroup){
316 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
317 } else {
318 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
319 }
320
321 /*TODO: when rkaiq_3A_server & rkisp_demo run in two different shell, rk_aiq_sys_ctx_t would be null?*/
322 if (ctx == NULL) {
323 ERR ("%s, ctx is nullptr\n", __FUNCTION__);
324 return XCAM_RETURN_ERROR_PARAM;
325 }
326
327 sample_a3dlut_usage ();
328
329 do {
330
331 key = getchar ();
332 while (key == '\n' || key == '\r')
333 key = getchar();
334 printf ("\n");
335
336 switch (key)
337 {
338 case 'h':
339 CLEAR();
340 sample_a3dlut_usage ();
341 break;
342 case '0':
343 sample_set_a3dlut_manual(ctx);
344 printf("Set 3DLUT MANUAL Mode\n\n");
345 break;
346 case '1':
347 sample_set_a3dlut_auto(ctx);
348 printf("Set 3DLUT AUTO Mode\n\n");
349 break;
350 case '2':
351 sample_get_a3dlut_mode(ctx);
352 break;
353 case '3':
354 sample_set_a3dlut_manual_lut(ctx);
355 break;
356 case '4':
357 sample_get_a3dlut_lut(ctx);
358 break;
359 case '5':
360 sample_get_a3dlut_strength(ctx);
361 break;
362 case '6':
363 sample_get_a3dlut_lutname(ctx);
364 break;
365 case 'a':
366 sample_3dlut_set3dlutAttr(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
367 sample_3dlut_get3dlutAttr(ctx);
368 break;
369 case 'b':
370 sample_3dlut_set3dlutAttr(ctx, RK_AIQ_UAPI_MODE_ASYNC);
371 sample_3dlut_get3dlutAttr(ctx);
372 usleep(40*1000);
373 sample_3dlut_get3dlutAttr(ctx);
374 break;
375 case 'c':
376 sample_3dlut_setModeManual(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
377 sample_3dlut_getMode(ctx);
378 break;
379 case 'd':
380 sample_3dlut_setModeManual(ctx, RK_AIQ_UAPI_MODE_ASYNC);
381 sample_3dlut_getMode(ctx);
382 usleep(40*1000);
383 sample_3dlut_getMode(ctx);
384 break;
385 case 'e':
386 sample_3dlut_setModeAuto(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
387 sample_3dlut_getMode(ctx);
388 break;
389 case 'f':
390 sample_3dlut_setModeAuto(ctx, RK_AIQ_UAPI_MODE_ASYNC);
391 sample_3dlut_getMode(ctx);
392 usleep(40*1000);
393 sample_3dlut_getMode(ctx);
394 break;
395 case 'g':
396 sample_3dlut_setM3dlut(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
397 sample_3dlut_get3dlutAttr(ctx);
398 break;
399 break;
400 case 'i':
401 sample_3dlut_setM3dlut(ctx, RK_AIQ_UAPI_MODE_ASYNC);
402 sample_3dlut_get3dlutAttr(ctx);
403 usleep(40*1000);
404 sample_3dlut_get3dlutAttr(ctx);
405 break;
406 case 'j':
407 sample_query_a3dlut_info(ctx);
408 break;
409 default:
410 break;
411 }
412 } while (key != 'q' && key != 'Q');
413
414 return XCAM_RETURN_NO_ERROR;
415 }
416