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_accm_usage()20 static void sample_accm_usage()
21 {
22 printf("Usage : \n");
23 printf(" ImgProc API: \n");
24 printf("\t 0) CCM: Set CCM MANUAL Mode.\n");
25 printf("\t 1) CCM: Set CCM AUTO Mode.\n");
26 printf("\t 2) CCM: Get CCM Mode.\n");
27 printf("\t 3) CCM: Set CCM Manual Matrix.\n");
28 printf("\t 4) CCM: Get CCM Matrix.\n");
29 printf("\t 5) CCM: Get ACCM Sat-level.\n");
30 printf("\t 6) CCM: Get ACCM Matrix Name.\n");
31 printf(" Module API: \n");
32 printf("\t a) CCM: Set Ccm Attr & Sync .\n");
33 printf("\t b) CCM: Set Ccm Attr & Async .\n");
34 printf("\t c) CCM: Set Mode Manual & Sync.\n");
35 printf("\t d) CCM: Set Mode Manual & Async.\n");
36 printf("\t e) CCM: Set Mode Auto & Sync.\n");
37 printf("\t f) CCM: Set Mode Auto & Async.\n");
38 printf("\t g) CCM: Set Manual attr & Sync.\n");
39 printf("\t i) CCM: Set Manual attr & Async.\n");
40 printf("\t j) CCM: Set Auto attr & Sync.\n");
41 printf("\t k) CCM: Set Auto attr & Async.\n");
42 printf("\t l) CCM: Query CCM Info.\n");
43 printf("\n");
44 printf("\t h) CCM: help.\n");
45 printf("\t q) CCM: return to main sample screen.\n");
46
47 printf("\n");
48 printf("\t please press the key: ");
49
50 return;
51 }
52
sample_print_accm_info(const void * arg)53 void sample_print_accm_info(const void *arg)
54 {
55 printf ("enter CCM module test!\n");
56 }
57
sample_print_accm_v2_info(const void * arg)58 void sample_print_accm_v2_info(const void *arg)
59 {
60 printf ("enter CCM V2 module test!\n");
61 }
62
63 /*
64 ******************************
65 *
66 * ImgProc level API Sample Func
67 *
68 ******************************
69 */
70
sample_set_ccm_manual(const rk_aiq_sys_ctx_t * ctx)71 static int sample_set_ccm_manual(const rk_aiq_sys_ctx_t* ctx)
72 {
73 opMode_t mode = OP_MANUAL;
74 rk_aiq_uapi2_setCCMMode(ctx, mode);
75 return 0;
76 }
77
sample_set_ccm_auto(const rk_aiq_sys_ctx_t * ctx)78 static int sample_set_ccm_auto(const rk_aiq_sys_ctx_t* ctx)
79 {
80 opMode_t mode = OP_AUTO;
81 rk_aiq_uapi2_setCCMMode(ctx, mode);
82 return 0;
83 }
84
sample_get_ccm_mode(const rk_aiq_sys_ctx_t * ctx)85 static int sample_get_ccm_mode(const rk_aiq_sys_ctx_t* ctx)
86 {
87 opMode_t mode;
88 rk_aiq_uapi2_getCCMMode(ctx, &mode);
89 if (mode == OP_MANUAL)
90 printf("CCM Mode is: Manual \n");
91 else if (mode == OP_AUTO)
92 printf("CCM Mode is: AUTO\n");
93 else
94 printf("CCM Mode is: INVALID\n");
95 return 0;
96 }
97
sample_set_ccm_manual_matrix(const rk_aiq_sys_ctx_t * ctx)98 static int sample_set_ccm_manual_matrix(const rk_aiq_sys_ctx_t* ctx)
99 {
100 rk_aiq_ccm_matrix_t mccm;
101 memset(&mccm, 0, sizeof(rk_aiq_ccm_matrix_t));
102 mccm.ccMatrix[0] = 1.5;
103 mccm.ccMatrix[1] = 0;
104 mccm.ccMatrix[2] = -0.5;
105 mccm.ccMatrix[3] = 0;
106 mccm.ccMatrix[4] = 1;
107 mccm.ccMatrix[5] = 0;
108 mccm.ccMatrix[6] = 0;
109 mccm.ccMatrix[7] = 0;
110 mccm.ccMatrix[8] = 1;
111 mccm.ccOffsets[0] = 1000;
112 mccm.ccOffsets[1] = 0;
113 mccm.ccOffsets[2] = 0;
114 rk_aiq_uapi2_setMCcCoef(ctx, &mccm);
115 return 0;
116 }
117
sample_get_ccm_matrix(const rk_aiq_sys_ctx_t * ctx)118 static int sample_get_ccm_matrix(const rk_aiq_sys_ctx_t* ctx)
119 {
120 rk_aiq_ccm_matrix_t mccm;
121 memset(&mccm, 0, sizeof(rk_aiq_ccm_matrix_t));
122 rk_aiq_uapi2_getMCcCoef(ctx, &mccm);
123 printf("Get CCM Matrix: ");
124 for (int j = 0; j < 9; j++)
125 printf("%f ", mccm.ccMatrix[j]);
126 printf("\n");
127 printf("offs: %f, %f, %f \n", mccm.ccOffsets[0], mccm.ccOffsets[1], mccm.ccOffsets[2]);
128 return 0;
129 }
130
sample_get_accm_sat(const rk_aiq_sys_ctx_t * ctx)131 static int sample_get_accm_sat(const rk_aiq_sys_ctx_t* ctx)
132 {
133 float finalsat;
134 rk_aiq_uapi2_getACcmSat(ctx, &finalsat);
135 printf("Get ACCM Sat-level: %f\n", finalsat);
136 return 0;
137 }
138
sample_get_accm_matrix_name(const rk_aiq_sys_ctx_t * ctx)139 static int sample_get_accm_matrix_name(const rk_aiq_sys_ctx_t* ctx)
140 {
141 char* ccmname[2];
142 ccmname[0] = (char*)malloc(sizeof(char)*25);
143 ccmname[1] = (char*)malloc(sizeof(char)*25);
144 rk_aiq_uapi2_getACcmMatrixName(ctx, ccmname);
145 printf("Get ACCM Matrix Name: %s %s \n\n", ccmname[0], ccmname[1]);
146 return 0;
147 }
148
149 /*
150 ******************************
151 *
152 * Module level API Sample Func
153 *
154 ******************************
155 */
156
sample_ccm_setCcmAttr(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)157 static int sample_ccm_setCcmAttr(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
158 {
159 XCamReturn ret = XCAM_RETURN_NO_ERROR;
160 rk_aiq_ccm_attrib_t attr;
161 memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
162 //get
163 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
164 RKAIQ_SAMPLE_CHECK_RET(ret, "setCcmAttr failed in getting accm attrib!");
165 //modify
166 attr.sync.sync_mode = sync;
167 attr.mode = RK_AIQ_CCM_MODE_AUTO;
168 if (attr.stAuto.color_saturation.level[0] == 100) {
169 for (int i = 0; i < 4; i++)
170 attr.stAuto.color_saturation.level[i] = 50;
171 } else {
172 for (int i = 0; i < 4; i++)
173 attr.stAuto.color_saturation.level[i] = 100;
174 }
175
176 //set
177 ret = rk_aiq_user_api2_accm_SetAttrib(ctx, &attr);
178 RKAIQ_SAMPLE_CHECK_RET(ret, "set CCM Attr failed!");
179 printf("set CCM Attr\n\n");
180
181 return 0;
182 }
183
sample_ccm_getCcmAttr(const rk_aiq_sys_ctx_t * ctx)184 static int sample_ccm_getCcmAttr(const rk_aiq_sys_ctx_t* ctx)
185 {
186 XCamReturn ret = XCAM_RETURN_NO_ERROR;
187 rk_aiq_ccm_attrib_t attr;
188 memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
189 //get
190 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
191 RKAIQ_SAMPLE_CHECK_RET(ret, "get Ccm Attr failed!");
192 printf("get CCM Attr:\n\n");
193 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
194 printf("\t enable = %s\n", (attr.byPass ? "false" : "true"));
195 if (attr.mode == RK_AIQ_CCM_MODE_MANUAL){
196 printf("\t mode = Manual\n");
197 printf("\t matrix = [");
198 for (int i = 0; i < 9; i++)
199 printf("%f ", attr.stManual.ccMatrix[i]);
200 printf("\n\t offset = [%f %f %f]\n", attr.stManual.ccOffsets[0],
201 attr.stManual.ccOffsets[1],
202 attr.stManual.ccOffsets[2]);
203 } else if (attr.mode == RK_AIQ_CCM_MODE_AUTO){
204 printf("\t mode = Auto\n");
205 printf("\t color_saturation level = {%f %f %f %f}\n",
206 attr.stAuto.color_saturation.level[0],
207 attr.stAuto.color_saturation.level[1],
208 attr.stAuto.color_saturation.level[2],
209 attr.stAuto.color_saturation.level[3]);
210 } else {
211 printf("\t mode is invalid!");
212 }
213 return 0;
214 }
215
sample_ccm_setModeManual(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)216 static int sample_ccm_setModeManual(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
217 {
218 XCamReturn ret = XCAM_RETURN_NO_ERROR;
219 rk_aiq_ccm_attrib_t attr;
220 memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
221 //get
222 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
223 RKAIQ_SAMPLE_CHECK_RET(ret, "setModeManual failed in getting accm attrib!");
224 //modify
225 attr.sync.sync_mode = sync;
226 attr.mode = RK_AIQ_CCM_MODE_MANUAL;
227 //set
228 ret = rk_aiq_user_api2_accm_SetAttrib(ctx, &attr);
229 RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Manual failed!");
230 printf("set CCM Mode Manual\n\n");
231
232 return 0;
233 }
234
sample_ccm_setModeAuto(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)235 static int sample_ccm_setModeAuto(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
236 {
237 XCamReturn ret = XCAM_RETURN_NO_ERROR;
238 rk_aiq_ccm_attrib_t attr;
239 memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
240 //get
241 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
242 RKAIQ_SAMPLE_CHECK_RET(ret, "setModeAuto failed in getting accm attrib!");
243 //modify
244 attr.sync.sync_mode = sync;
245 attr.mode = RK_AIQ_CCM_MODE_AUTO;
246 //set
247 ret = rk_aiq_user_api2_accm_SetAttrib(ctx, &attr);
248 RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Auto failed!");
249 printf("set CCM Mode Auto\n\n");
250
251 return 0;
252 }
253
sample_ccm_getMode(const rk_aiq_sys_ctx_t * ctx)254 static int sample_ccm_getMode(const rk_aiq_sys_ctx_t* ctx)
255 {
256 XCamReturn ret = XCAM_RETURN_NO_ERROR;
257 rk_aiq_ccm_attrib_t attr;
258 memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
259 //get
260 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
261 RKAIQ_SAMPLE_CHECK_RET(ret, "get Ccm Mode failed!");
262 printf("get CCM Mode:\n\n");
263 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
264 if (attr.mode == RK_AIQ_CCM_MODE_MANUAL){
265 printf("\t mode = Manual\n");
266 } else if (attr.mode == RK_AIQ_CCM_MODE_AUTO){
267 printf("\t mode = Auto\n");
268 } else {
269 printf("\t mode is invalid!");
270 }
271 return 0;
272 }
273
sample_ccm_setMCcm(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)274 static int sample_ccm_setMCcm(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
275 {
276 XCamReturn ret = XCAM_RETURN_NO_ERROR;
277 rk_aiq_ccm_attrib_t attr;
278 memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
279 //get
280 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
281 RKAIQ_SAMPLE_CHECK_RET(ret, "setMCcm failed in getting accm attrib!");
282 //modify
283 attr.sync.sync_mode = sync;
284 attr.mode = RK_AIQ_CCM_MODE_MANUAL;
285 if (attr.stManual.ccOffsets[0] < 1000) {
286 attr.stManual.ccOffsets[0] = 1000;
287 attr.stManual.ccOffsets[1] = 0;
288 attr.stManual.ccOffsets[2] = 0;
289 } else {
290 attr.stManual.ccOffsets[0] = 0;
291 attr.stManual.ccOffsets[1] = 0;
292 attr.stManual.ccOffsets[2] = 1000;
293 }
294
295 //set
296 ret = rk_aiq_user_api2_accm_SetAttrib(ctx, &attr);
297 RKAIQ_SAMPLE_CHECK_RET(ret, "set Manual attr failed!");
298 printf("set Manual attr\n\n");
299
300 return 0;
301 }
302
sample_ccm_setACcm(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)303 static int sample_ccm_setACcm(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
304 {
305 XCamReturn ret = XCAM_RETURN_NO_ERROR;
306 rk_aiq_ccm_attrib_t attr;
307 memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
308 //get
309 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
310 RKAIQ_SAMPLE_CHECK_RET(ret, "setACcm failed in getting accm attrib!");
311 //modify
312 attr.sync.sync_mode = sync;
313 attr.mode = RK_AIQ_CCM_MODE_AUTO;
314 if (attr.stAuto.color_saturation.level[0] == 100) {
315 for (int i = 0; i < 4; i++)
316 attr.stAuto.color_saturation.level[i] = 50;
317 } else {
318 for (int i = 0; i < 4; i++)
319 attr.stAuto.color_saturation.level[i] = 100;
320 }
321 //set
322 ret = rk_aiq_user_api2_accm_SetAttrib(ctx, &attr);
323 RKAIQ_SAMPLE_CHECK_RET(ret, "set Auto attr failed!");
324 printf("set Auto attr\n\n");
325
326 return 0;
327 }
328
sample_query_ccm_info(const rk_aiq_sys_ctx_t * ctx)329 static int sample_query_ccm_info(const rk_aiq_sys_ctx_t* ctx)
330 {
331 rk_aiq_ccm_querry_info_t info;
332 rk_aiq_user_api2_accm_QueryCcmInfo(ctx, &info);
333 printf("Query CCM Info:\n\n");
334 printf("\t enable: %s, \n", (info.ccm_en ? "true" : "false"));
335 printf("\t matrix: ");
336 for (int j = 0; j < 9; j++)
337 printf("%f ", info.ccMatrix[j]);
338 printf("\n");
339 printf("\t offs: %f, %f, %f \n", info.ccOffsets[0], info.ccOffsets[1], info.ccOffsets[2]);
340 printf("\t alp_y: ");
341 for (int j = 0; j < 17; j++)
342 printf("%f ", info.y_alpha_curve[j]);
343 printf("\n");
344 printf("\t low bound bit: %f \n", info.low_bound_pos_bit);
345 printf("\t color inhibition level: %f, color saturation level: %f \n",
346 info.color_inhibition_level, info.color_saturation_level);
347 printf("\t finalSat: %f \n", info.finalSat);
348 printf("\t ccmname1: %s, ccmname2: %s \n", info.ccmname1, info.ccmname2);
349 return 0;
350 }
351
352 // CCM V2
sample_ccm_setCcmAttr_V2(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)353 static int sample_ccm_setCcmAttr_V2(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
354 {
355 XCamReturn ret = XCAM_RETURN_NO_ERROR;
356 rk_aiq_ccm_v2_attrib_t attr;
357 memset(&attr,0,sizeof(rk_aiq_ccm_v2_attrib_t));
358 //get
359 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
360 RKAIQ_SAMPLE_CHECK_RET(ret, "setCcmAttr failed in getting accm attrib!");
361 //modify
362 attr.sync.sync_mode = sync;
363 attr.mode = RK_AIQ_CCM_MODE_AUTO;
364 if (attr.stAuto.color_saturation.level[0] == 100) {
365 for (int i = 0; i < 4; i++)
366 attr.stAuto.color_saturation.level[i] = 50;
367 } else {
368 for (int i = 0; i < 4; i++)
369 attr.stAuto.color_saturation.level[i] = 100;
370 }
371
372 //set
373 ret = rk_aiq_user_api2_accm_v2_SetAttrib(ctx, &attr);
374 RKAIQ_SAMPLE_CHECK_RET(ret, "set CCM Attr failed!");
375 printf("set CCM Attr\n\n");
376
377 return 0;
378 }
379
sample_ccm_getCcmAttr_V2(const rk_aiq_sys_ctx_t * ctx)380 static int sample_ccm_getCcmAttr_V2(const rk_aiq_sys_ctx_t* ctx)
381 {
382 XCamReturn ret = XCAM_RETURN_NO_ERROR;
383 rk_aiq_ccm_v2_attrib_t attr;
384 memset(&attr,0,sizeof(rk_aiq_ccm_v2_attrib_t));
385 //get
386 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
387 RKAIQ_SAMPLE_CHECK_RET(ret, "get Ccm Attr failed!");
388 printf("get CCM Attr:\n\n");
389 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
390 printf("\t enable = %s\n", (attr.byPass ? "false" : "true"));
391 if (attr.mode == RK_AIQ_CCM_MODE_MANUAL){
392 printf("\t mode = Manual\n");
393 printf("\t matrix = [");
394 for (int i = 0; i < 9; i++)
395 printf("%f ", attr.stManual.ccMatrix[i]);
396 printf("\n\t offset = [%f %f %f]\n", attr.stManual.ccOffsets[0],
397 attr.stManual.ccOffsets[1],
398 attr.stManual.ccOffsets[2]);
399 } else if (attr.mode == RK_AIQ_CCM_MODE_AUTO){
400 printf("\t mode = Auto\n");
401 printf("\t color_saturation level = {%f %f %f %f}\n",
402 attr.stAuto.color_saturation.level[0],
403 attr.stAuto.color_saturation.level[1],
404 attr.stAuto.color_saturation.level[2],
405 attr.stAuto.color_saturation.level[3]);
406 } else {
407 printf("\t mode is invalid!");
408 }
409 return 0;
410 }
411
sample_ccm_setModeManual_V2(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)412 static int sample_ccm_setModeManual_V2(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
413 {
414 XCamReturn ret = XCAM_RETURN_NO_ERROR;
415 rk_aiq_ccm_v2_attrib_t attr;
416 memset(&attr,0,sizeof(rk_aiq_ccm_v2_attrib_t));
417 //get
418 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
419 RKAIQ_SAMPLE_CHECK_RET(ret, "setModeManual failed in getting accm attrib!");
420 //modify
421 attr.sync.sync_mode = sync;
422 attr.mode = RK_AIQ_CCM_MODE_MANUAL;
423 //set
424 ret = rk_aiq_user_api2_accm_v2_SetAttrib(ctx, &attr);
425 RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Manual failed!");
426 printf("set CCM Mode Manual\n\n");
427
428 return 0;
429 }
430
sample_ccm_setModeAuto_V2(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)431 static int sample_ccm_setModeAuto_V2(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
432 {
433 XCamReturn ret = XCAM_RETURN_NO_ERROR;
434 rk_aiq_ccm_v2_attrib_t attr;
435 memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
436 //get
437 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
438 RKAIQ_SAMPLE_CHECK_RET(ret, "setModeAuto failed in getting accm attrib!");
439 //modify
440 attr.sync.sync_mode = sync;
441 attr.mode = RK_AIQ_CCM_MODE_AUTO;
442 //set
443 ret = rk_aiq_user_api2_accm_v2_SetAttrib(ctx, &attr);
444 RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Auto failed!");
445 printf("set CCM Mode Auto\n\n");
446
447 return 0;
448 }
449
sample_ccm_getMode_V2(const rk_aiq_sys_ctx_t * ctx)450 static int sample_ccm_getMode_V2(const rk_aiq_sys_ctx_t* ctx)
451 {
452 XCamReturn ret = XCAM_RETURN_NO_ERROR;
453 rk_aiq_ccm_v2_attrib_t attr;
454 memset(&attr,0,sizeof(rk_aiq_ccm_v2_attrib_t));
455 //get
456 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
457 RKAIQ_SAMPLE_CHECK_RET(ret, "get Ccm Mode failed!");
458 printf("get CCM Mode:\n\n");
459 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
460 if (attr.mode == RK_AIQ_CCM_MODE_MANUAL){
461 printf("\t mode = Manual\n");
462 } else if (attr.mode == RK_AIQ_CCM_MODE_AUTO){
463 printf("\t mode = Auto\n");
464 } else {
465 printf("\t mode is invalid!");
466 }
467 return 0;
468 }
469
sample_ccm_setMCcm_V2(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)470 static int sample_ccm_setMCcm_V2(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
471 {
472 XCamReturn ret = XCAM_RETURN_NO_ERROR;
473 rk_aiq_ccm_v2_attrib_t attr;
474 memset(&attr,0,sizeof(rk_aiq_ccm_v2_attrib_t));
475 //get
476 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
477 RKAIQ_SAMPLE_CHECK_RET(ret, "setMCcm failed in getting accm attrib!");
478 //modify
479 attr.sync.sync_mode = sync;
480 attr.mode = RK_AIQ_CCM_MODE_MANUAL;
481 if (attr.stManual.ccOffsets[0] < 1000) {
482 attr.stManual.ccOffsets[0] = 1000;
483 attr.stManual.ccOffsets[1] = 0;
484 attr.stManual.ccOffsets[2] = 0;
485 } else {
486 attr.stManual.ccOffsets[0] = 0;
487 attr.stManual.ccOffsets[1] = 0;
488 attr.stManual.ccOffsets[2] = 1000;
489 }
490
491 //set
492 ret = rk_aiq_user_api2_accm_v2_SetAttrib(ctx, &attr);
493 RKAIQ_SAMPLE_CHECK_RET(ret, "set Manual attr failed!");
494 printf("set Manual attr\n\n");
495
496 return 0;
497 }
498
sample_ccm_setACcm_V2(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)499 static int sample_ccm_setACcm_V2(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
500 {
501 XCamReturn ret = XCAM_RETURN_NO_ERROR;
502 rk_aiq_ccm_v2_attrib_t attr;
503 memset(&attr,0,sizeof(rk_aiq_ccm_v2_attrib_t));
504 //get
505 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
506 RKAIQ_SAMPLE_CHECK_RET(ret, "setACcm failed in getting accm attrib!");
507 //modify
508 attr.sync.sync_mode = sync;
509 attr.mode = RK_AIQ_CCM_MODE_AUTO;
510 if (attr.stAuto.color_saturation.level[0] == 100) {
511 for (int i = 0; i < 4; i++)
512 attr.stAuto.color_saturation.level[i] = 50;
513 } else {
514 for (int i = 0; i < 4; i++)
515 attr.stAuto.color_saturation.level[i] = 100;
516 }
517 //set
518 ret = rk_aiq_user_api2_accm_v2_SetAttrib(ctx, &attr);
519 RKAIQ_SAMPLE_CHECK_RET(ret, "set Auto attr failed!");
520 printf("set Auto attr\n\n");
521
522 return 0;
523 }
524
sample_query_ccm_info_V2(const rk_aiq_sys_ctx_t * ctx)525 static int sample_query_ccm_info_V2(const rk_aiq_sys_ctx_t* ctx)
526 {
527 rk_aiq_ccm_querry_info_t info;
528 rk_aiq_user_api2_accm_QueryCcmInfo(ctx, &info);
529 printf("Query CCM Info:\n\n");
530 printf("\t enable: %s, \n", (info.ccm_en ? "true" : "false"));
531 printf("\t matrix: ");
532 for (int j = 0; j < 9; j++) printf("%f ", info.ccMatrix[j]);
533 printf("\n");
534 printf("\t offs: %f, %f, %f \n", info.ccOffsets[0], info.ccOffsets[1], info.ccOffsets[2]);
535 printf("\t highy adjust enable: %s \n", (info.highy_adj_en ? "true" : "false"));
536 printf("\t asym enable: %s \n", (info.asym_enable ? "true" : "false"));
537 printf("\t alp_y: ");
538 for (int j = 0; j < 17; j++) printf("%f ", info.y_alpha_curve[j]);
539 if (info.asym_enable)
540 printf("%f\n", info.y_alpha_curve[17]);
541 else
542 printf("\n");
543 printf("\t low bound bit: %f \n", info.low_bound_pos_bit);
544 printf("\t color inhibition level: %f, color saturation level: %f \n",
545 info.color_inhibition_level, info.color_saturation_level);
546 printf("\t finalSat: %f \n", info.finalSat);
547 printf("\t ccmname1: %s, ccmname2: %s \n", info.ccmname1, info.ccmname2);
548 return 0;
549 }
550
sample_accm_module(const void * arg)551 XCamReturn sample_accm_module(const void *arg)
552 {
553 int key = -1;
554 CLEAR();
555 const demo_context_t *demo_ctx = (demo_context_t *)arg;
556 const rk_aiq_sys_ctx_t* ctx;
557 if (demo_ctx->camGroup){
558 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
559 } else {
560 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
561 }
562
563 /*TODO: when rkaiq_3A_server & rkisp_demo run in two different shell, rk_aiq_sys_ctx_t would be null?*/
564 if (ctx == NULL) {
565 ERR ("%s, ctx is nullptr\n", __FUNCTION__);
566 return XCAM_RETURN_ERROR_PARAM;
567 }
568
569 sample_accm_usage ();
570
571 do {
572
573 key = getchar ();
574 while (key == '\n' || key == '\r')
575 key = getchar();
576 printf ("\n");
577
578 switch (key)
579 {
580 case 'h':
581 CLEAR();
582 sample_accm_usage ();
583 break;
584 case '0':
585 sample_set_ccm_manual(ctx);
586 printf("Set CCM MANUAL Mode\n\n");
587 break;
588 case '1':
589 sample_set_ccm_auto(ctx);
590 printf("Set CCM AUTO Mode\n\n");
591 break;
592 case '2':
593 sample_get_ccm_mode(ctx);
594 break;
595 case '3':
596 sample_set_ccm_manual_matrix(ctx);
597 printf("Set CCM Manual Matrix\n\n");
598 break;
599 case '4':
600 sample_get_ccm_matrix(ctx);
601 break;
602 case '5':
603 sample_get_accm_sat(ctx);
604 break;
605 case '6':
606 sample_get_accm_matrix_name(ctx);
607 break;
608 case 'a':
609 sample_ccm_setCcmAttr(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
610 sample_ccm_getCcmAttr(ctx);
611 break;
612 case 'b':
613 sample_ccm_setCcmAttr(ctx, RK_AIQ_UAPI_MODE_ASYNC);
614 sample_ccm_getCcmAttr(ctx);
615 usleep(40*1000);
616 sample_ccm_getCcmAttr(ctx);
617 break;
618 case 'c':
619 sample_ccm_setModeManual(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
620 sample_ccm_getMode(ctx);
621 break;
622 case 'd':
623 sample_ccm_setModeManual(ctx, RK_AIQ_UAPI_MODE_ASYNC);
624 sample_ccm_getMode(ctx);
625 usleep(40*1000);
626 sample_ccm_getMode(ctx);
627 break;
628 case 'e':
629 sample_ccm_setModeAuto(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
630 sample_ccm_getMode(ctx);
631 break;
632 case 'f':
633 sample_ccm_setModeAuto(ctx, RK_AIQ_UAPI_MODE_ASYNC);
634 sample_ccm_getMode(ctx);
635 usleep(40*1000);
636 sample_ccm_getMode(ctx);
637 break;
638 case 'g':
639 sample_ccm_setMCcm(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
640 sample_ccm_getCcmAttr(ctx);
641 break;
642 case 'i':
643 sample_ccm_setMCcm(ctx, RK_AIQ_UAPI_MODE_ASYNC);
644 sample_ccm_getCcmAttr(ctx);
645 usleep(40*1000);
646 sample_ccm_getCcmAttr(ctx);
647 break;
648 case 'j':
649 sample_ccm_setACcm(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
650 sample_ccm_getCcmAttr(ctx);
651 break;
652 case 'k':
653 sample_ccm_setACcm(ctx, RK_AIQ_UAPI_MODE_ASYNC);
654 sample_ccm_getCcmAttr(ctx);
655 usleep(40*1000);
656 sample_ccm_getCcmAttr(ctx);
657 break;
658 case 'l':
659 sample_query_ccm_info(ctx);
660 break;
661 default:
662 break;
663 }
664 } while (key != 'q' && key != 'Q');
665
666 return XCAM_RETURN_NO_ERROR;
667 }
668
sample_accm_v2_module(const void * arg)669 XCamReturn sample_accm_v2_module(const void *arg)
670 {
671 int key = -1;
672 CLEAR();
673 const demo_context_t *demo_ctx = (demo_context_t *)arg;
674 const rk_aiq_sys_ctx_t* ctx;
675 if (demo_ctx->camGroup){
676 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
677 } else {
678 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
679 }
680
681 /*TODO: when rkaiq_3A_server & rkisp_demo run in two different shell, rk_aiq_sys_ctx_t would be null?*/
682 if (ctx == NULL) {
683 ERR ("%s, ctx is nullptr\n", __FUNCTION__);
684 return XCAM_RETURN_ERROR_PARAM;
685 }
686
687 sample_accm_usage ();
688
689 do {
690
691 key = getchar ();
692 while (key == '\n' || key == '\r')
693 key = getchar();
694 printf ("\n");
695
696 switch (key)
697 {
698 case 'h':
699 CLEAR();
700 sample_accm_usage ();
701 break;
702 case '0':
703 sample_set_ccm_manual(ctx);
704 printf("Set CCM MANUAL Mode\n\n");
705 break;
706 case '1':
707 sample_set_ccm_auto(ctx);
708 printf("Set CCM AUTO Mode\n\n");
709 break;
710 case '2':
711 sample_get_ccm_mode(ctx);
712 break;
713 case '3':
714 sample_set_ccm_manual_matrix(ctx);
715 printf("Set CCM Manual Matrix\n\n");
716 break;
717 case '4':
718 sample_get_ccm_matrix(ctx);
719 break;
720 case '5':
721 sample_get_accm_sat(ctx);
722 break;
723 case '6':
724 sample_get_accm_matrix_name(ctx);
725 break;
726 case 'a':
727 sample_ccm_setCcmAttr_V2(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
728 sample_ccm_getCcmAttr_V2(ctx);
729 break;
730 case 'b':
731 sample_ccm_setCcmAttr_V2(ctx, RK_AIQ_UAPI_MODE_ASYNC);
732 sample_ccm_getCcmAttr_V2(ctx);
733 usleep(40*1000);
734 sample_ccm_getCcmAttr_V2(ctx);
735 break;
736 case 'c':
737 sample_ccm_setModeManual_V2(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
738 sample_ccm_getMode_V2(ctx);
739 break;
740 case 'd':
741 sample_ccm_setModeManual_V2(ctx, RK_AIQ_UAPI_MODE_ASYNC);
742 sample_ccm_getMode_V2(ctx);
743 usleep(40*1000);
744 sample_ccm_getMode_V2(ctx);
745 break;
746 case 'e':
747 sample_ccm_setModeAuto_V2(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
748 sample_ccm_getMode_V2(ctx);
749 break;
750 case 'f':
751 sample_ccm_setModeAuto_V2(ctx, RK_AIQ_UAPI_MODE_ASYNC);
752 sample_ccm_getMode_V2(ctx);
753 usleep(40*1000);
754 sample_ccm_getMode_V2(ctx);
755 break;
756 case 'g':
757 sample_ccm_setMCcm_V2(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
758 sample_ccm_getCcmAttr_V2(ctx);
759 break;
760 case 'i':
761 sample_ccm_setMCcm_V2(ctx, RK_AIQ_UAPI_MODE_ASYNC);
762 sample_ccm_getCcmAttr_V2(ctx);
763 usleep(40*1000);
764 sample_ccm_getCcmAttr_V2(ctx);
765 break;
766 case 'j':
767 sample_ccm_setACcm_V2(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
768 sample_ccm_getCcmAttr_V2(ctx);
769 break;
770 case 'k':
771 sample_ccm_setACcm_V2(ctx, RK_AIQ_UAPI_MODE_ASYNC);
772 sample_ccm_getCcmAttr_V2(ctx);
773 usleep(40*1000);
774 sample_ccm_getCcmAttr_V2(ctx);
775 break;
776 case 'l':
777 sample_query_ccm_info_V2(ctx);
778 break;
779 default:
780 break;
781 }
782 } while (key != 'q' && key != 'Q');
783
784 return XCAM_RETURN_NO_ERROR;
785 }
786