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
20 #define safe_free(x) if(NULL!=(x))\
21 free(x); x=NULL;
22
sample_print_awb_info(const void * arg)23 void sample_print_awb_info(const void *arg)
24 {
25 printf ("enter AWB modult test!\n");
26 }
27
sample_print_awb32_info(const void * arg)28 void sample_print_awb32_info(const void *arg)
29 {
30 printf ("enter AWBV32 modult test!\n");
31 }
32 /*
33 ******************************
34 *
35 * ImgProc level API Sample Func
36 *
37 ******************************
38 */
39
sample_set_wbmode_manual(const rk_aiq_sys_ctx_t * ctx)40 static int sample_set_wbmode_manual(const rk_aiq_sys_ctx_t* ctx)
41 {
42 rk_aiq_uapi2_setWBMode(ctx, OP_MANUAL);
43 return 0;
44 }
45
sample_set_wbmode_auto(const rk_aiq_sys_ctx_t * ctx)46 static int sample_set_wbmode_auto(const rk_aiq_sys_ctx_t* ctx)
47 {
48 rk_aiq_uapi2_setWBMode(ctx, OP_AUTO);
49 return 0;
50 }
51
sample_get_wbmode(const rk_aiq_sys_ctx_t * ctx)52 static int sample_get_wbmode(const rk_aiq_sys_ctx_t* ctx)
53 {
54 opMode_t mode;
55 rk_aiq_uapi2_getWBMode(ctx, &mode);
56 printf("get WBMode=%d\n\n", mode);
57 return 0;
58 }
59
sample_lock_awb(const rk_aiq_sys_ctx_t * ctx)60 static int sample_lock_awb(const rk_aiq_sys_ctx_t* ctx)
61 {
62 rk_aiq_uapi2_lockAWB(ctx);
63 return 0;
64 }
65
sample_unlock_awb(const rk_aiq_sys_ctx_t * ctx)66 static int sample_unlock_awb(const rk_aiq_sys_ctx_t* ctx)
67 {
68 rk_aiq_uapi2_unlockAWB(ctx);
69 return 0;
70 }
71
sample_set_mwb_scene(const rk_aiq_sys_ctx_t * ctx)72 static int sample_set_mwb_scene(const rk_aiq_sys_ctx_t* ctx)
73 {
74 rk_aiq_uapi2_setMWBScene(ctx, RK_AIQ_WBCT_TWILIGHT);
75 return 0;
76 }
77
sample_get_mwb_scene(const rk_aiq_sys_ctx_t * ctx)78 static int sample_get_mwb_scene(const rk_aiq_sys_ctx_t* ctx)
79 {
80 rk_aiq_wb_scene_t scene;
81 rk_aiq_uapi2_getMWBScene(ctx, &scene);
82 printf("get MWBScene=%d\n\n", scene);
83 return 0;
84 }
85
sample_set_mwb_gain(const rk_aiq_sys_ctx_t * ctx)86 static int sample_set_mwb_gain(const rk_aiq_sys_ctx_t* ctx)
87 {
88 rk_aiq_wb_gain_t gain;
89 gain.rgain = 0.5f;
90 gain.grgain = 0.5f;
91 gain.gbgain = 0.5f;
92 gain.bgain = 0.5f;
93 rk_aiq_uapi2_setMWBGain(ctx, &gain);
94 return 0;
95 }
96
sample_get_mwb_gain(const rk_aiq_sys_ctx_t * ctx)97 static int sample_get_mwb_gain(const rk_aiq_sys_ctx_t* ctx)
98 {
99 rk_aiq_wb_gain_t gain;
100 rk_aiq_uapi2_getWBGain(ctx, &gain);
101 printf("get WBGain=[%f %f %f %f]\n", gain.rgain, gain.grgain, gain.gbgain, gain.bgain);
102 return 0;
103 }
104
sample_set_mwb_ct(const rk_aiq_sys_ctx_t * ctx)105 static int sample_set_mwb_ct(const rk_aiq_sys_ctx_t* ctx)
106 {
107 unsigned int cct;
108 cct = 6000;
109 rk_aiq_uapi2_setMWBCT(ctx, cct);
110 return 0;
111 }
112
sample_get_mwb_ct(const rk_aiq_sys_ctx_t * ctx)113 static int sample_get_mwb_ct(const rk_aiq_sys_ctx_t* ctx)
114 {
115 unsigned int cct;
116 rk_aiq_uapi2_getWBCT(ctx, &cct);
117 printf("get cct=%d\n\n", cct);
118 return 0;
119 }
120
sample_set_awb_gainoffset(const rk_aiq_sys_ctx_t * ctx)121 static int sample_set_awb_gainoffset(const rk_aiq_sys_ctx_t* ctx)
122 {
123 rk_aiq_uapiV2_wb_awb_wbGainOffset_t offset2 = {{RK_AIQ_UAPI_MODE_DEFAULT,false}, {true,{0.5,0,0,0.5}}};
124 rk_aiq_uapi2_setAwbGainOffsetAttrib(ctx,offset2 );
125 return 0;
126 }
127
sample_get_awb_gainoffset(const rk_aiq_sys_ctx_t * ctx)128 static int sample_get_awb_gainoffset(const rk_aiq_sys_ctx_t* ctx)
129 {
130 rk_aiq_uapiV2_wb_awb_wbGainOffset_t offset ;
131 rk_aiq_uapi2_getAwbGainOffsetAttrib(ctx, &offset);
132 printf("get WbGainOffset{%d,[%f,%f,%f,%f]}\n\n",
133 offset.gainOffset.enable,
134 offset.gainOffset.offset[0],
135 offset.gainOffset.offset[1],
136 offset.gainOffset.offset[2],
137 offset.gainOffset.offset[3]);
138 return 0;
139 }
140
sample_set_awb_gain_adjust(const rk_aiq_sys_ctx_t * ctx)141 static int sample_set_awb_gain_adjust(const rk_aiq_sys_ctx_t* ctx)
142 {
143 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t adjust ;
144 memset(&adjust,0,sizeof(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t));
145 //get
146 rk_aiq_uapi2_getAwbGainAdjustAttrib(ctx, &adjust);
147 //modfiy
148 adjust.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
149 adjust.enable = true;
150 //set
151 rk_aiq_uapi2_setAwbGainAdjustAttrib(ctx, adjust);
152 printf("set AwbGainAdjust\n\n");
153 //free
154 for(int i = 0; i < adjust.lutAll_len; i++) {
155 safe_free(adjust.lutAll[i].cri_lut_out);
156 safe_free(adjust.lutAll[i].ct_lut_out);
157 }
158 safe_free(adjust.lutAll);
159 return 0;
160 }
161
sample_get_awb_gain_adjust(const rk_aiq_sys_ctx_t * ctx)162 static int sample_get_awb_gain_adjust(const rk_aiq_sys_ctx_t* ctx)
163 {
164 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t adjust ;
165 memset(&adjust,0,sizeof(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t));
166 //get
167 rk_aiq_uapi2_getAwbGainAdjustAttrib(ctx,&adjust );
168 printf("get AwbGainAdjust {%d}\n\n",adjust.enable);
169 //free
170 for(int i = 0; i < adjust.lutAll_len; i++) {
171 safe_free(adjust.lutAll[i].cri_lut_out);
172 safe_free(adjust.lutAll[i].ct_lut_out);
173 }
174 safe_free(adjust.lutAll);
175 return 0;
176 }
177
sample_set_awbv30_atrr(const rk_aiq_sys_ctx_t * ctx)178 static int sample_set_awbv30_atrr(const rk_aiq_sys_ctx_t* ctx)
179 {
180 rk_aiq_uapiV2_wbV30_attrib_t attr ;
181 memset(&attr,0,sizeof(rk_aiq_uapiV2_wbV30_attrib_t));
182 //get
183 rk_aiq_uapi2_getAwbV30AllAttrib(ctx, &attr);
184 //modify
185 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
186 attr.stAuto.wbGainAdjust.enable = true;
187 //set
188 rk_aiq_uapi2_setAwbV30AllAttrib(ctx, attr);
189 printf("set rk_aiq_uapiV2_wbV30_attrib\n\n");
190 //free
191 for(int i = 0; i < attr.stAuto.wbGainAdjust.lutAll_len; i++) {
192 safe_free(attr.stAuto.wbGainAdjust.lutAll[i].cri_lut_out);
193 safe_free(attr.stAuto.wbGainAdjust.lutAll[i].ct_lut_out);
194 }
195 safe_free(attr.stAuto.wbGainAdjust.lutAll);
196 return 0;
197 }
198
199 /*
200 ******************************
201 *
202 * Module level API Sample Func
203 *
204 ******************************
205 */
206
sample_awb_awbv21_setAllAttr(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)207 static int sample_awb_awbv21_setAllAttr(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
208 {
209 rk_aiq_uapiV2_wbV21_attrib_t attr;
210 memset(&attr,0,sizeof(rk_aiq_uapiV2_wbV21_attrib_t));
211 //get
212 rk_aiq_user_api2_awbV21_GetAllAttrib(ctx, &attr);
213 //modify
214 attr.sync.sync_mode = sync;
215 attr.stAuto.wbGainAdjust.enable = !attr.stAuto.wbGainAdjust.enable;
216 //set
217 rk_aiq_user_api2_awbV21_SetAllAttrib(ctx, attr);
218 printf("set Awbv21 AllAttr\n\n");
219 return 0;
220 }
221
sample_awb_awbv21_getAllAttr(const rk_aiq_sys_ctx_t * ctx)222 static int sample_awb_awbv21_getAllAttr(const rk_aiq_sys_ctx_t* ctx)
223 {
224 rk_aiq_uapiV2_wbV21_attrib_t attr ;
225 memset(&attr,0,sizeof(rk_aiq_uapiV2_wbV21_attrib_t));
226 //get
227 rk_aiq_user_api2_awbV21_GetAllAttrib(ctx, &attr);
228 printf("get Awbv21 AllAttr:\n");
229 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
230 printf("\t bypass = %d\n", attr.byPass);
231 printf("\t mode = %s\n", (attr.mode > 0 ? "auto" : "manual"));
232 if (attr.mode > 0) {
233 printf("\t wbGainAdjustEn = %s\n",
234 (attr.stAuto.wbGainAdjust.enable > 0 ? "true" : "false"));
235 printf("\t wbGainOffset = {%s,[%f,%f,%f,%f]}\n\n",
236 (attr.stAuto.wbGainOffset.enable > 0 ? "true" : "false"),
237 attr.stAuto.wbGainOffset.offset[0],
238 attr.stAuto.wbGainOffset.offset[1],
239 attr.stAuto.wbGainOffset.offset[2],
240 attr.stAuto.wbGainOffset.offset[3]);
241 } else {
242 switch (attr.stManual.mode)
243 {
244 case RK_AIQ_MWB_MODE_CCT:
245 printf("\t manual mode = RK_AIQ_MWB_MODE_CCT\n");
246 printf("\t manual cct = %f, ccri = %f\n",
247 attr.stManual.para.cct.CCT,
248 attr.stManual.para.cct.CCRI);
249 break;
250 case RK_AIQ_MWB_MODE_WBGAIN:
251 printf("\t manual mode = RK_AIQ_MWB_MODE_WBGAIN\n");
252 printf("\t manual wbgain = [%f, %f, %f, %f]\n",
253 attr.stManual.para.gain.rgain,
254 attr.stManual.para.gain.grgain,
255 attr.stManual.para.gain.gbgain,
256 attr.stManual.para.gain.bgain);
257 break;
258 case RK_AIQ_MWB_MODE_SCENE:
259 printf("\t manual mode = RK_AIQ_MWB_MODE_SCENE\n");
260 printf("\t manual scene = %d\n",
261 attr.stManual.para.scene);
262 break;
263 default:
264 printf("\t manual mode is invalid!\n");
265 break;
266 }
267 }
268 return 0;
269 }
270
sample_awb_awbv30_setAllAttr(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)271 static int sample_awb_awbv30_setAllAttr(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
272 {
273 rk_aiq_uapiV2_wbV30_attrib_t attr;
274 memset(&attr,0,sizeof(rk_aiq_uapiV2_wbV30_attrib_t));
275 //get
276 rk_aiq_user_api2_awbV30_GetAllAttrib(ctx, &attr);
277 //modify
278 attr.sync.sync_mode = sync;
279 attr.stAuto.wbGainAdjust.enable = !attr.stAuto.wbGainAdjust.enable;
280 //set
281 rk_aiq_user_api2_awbV30_SetAllAttrib(ctx, attr);
282 printf("set Awbv30 AllAttr\n\n");
283 return 0;
284 }
285
sample_awb_awbv30_getAllAttr(const rk_aiq_sys_ctx_t * ctx)286 static int sample_awb_awbv30_getAllAttr(const rk_aiq_sys_ctx_t* ctx)
287 {
288 rk_aiq_uapiV2_wbV30_attrib_t attr ;
289 memset(&attr,0,sizeof(rk_aiq_uapiV2_wbV30_attrib_t));
290 //get
291 rk_aiq_user_api2_awbV30_GetAllAttrib(ctx, &attr);
292 printf("get Awbv30 AllAttr:\n");
293 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
294 printf("\t bypass = %d\n", attr.byPass);
295 printf("\t mode = %s\n", (attr.mode > 0 ? "auto" : "manual"));
296 if (attr.mode > 0) {
297 printf("\t wbGainAdjustEn = %s\n",
298 (attr.stAuto.wbGainAdjust.enable > 0 ? "true" : "false"));
299 printf("\t wbGainOffset = {%s,[%f,%f,%f,%f]}\n\n",
300 (attr.stAuto.wbGainOffset.enable > 0 ? "true" : "false"),
301 attr.stAuto.wbGainOffset.offset[0],
302 attr.stAuto.wbGainOffset.offset[1],
303 attr.stAuto.wbGainOffset.offset[2],
304 attr.stAuto.wbGainOffset.offset[3]);
305 } else {
306 switch (attr.stManual.mode)
307 {
308 case RK_AIQ_MWB_MODE_CCT:
309 printf("\t manual mode = RK_AIQ_MWB_MODE_CCT\n");
310 printf("\t manual cct = %f, ccri = %f\n",
311 attr.stManual.para.cct.CCT,
312 attr.stManual.para.cct.CCRI);
313 break;
314 case RK_AIQ_MWB_MODE_WBGAIN:
315 printf("\t manual mode = RK_AIQ_MWB_MODE_WBGAIN\n");
316 printf("\t manual wbgain = [%f, %f, %f, %f]\n",
317 attr.stManual.para.gain.rgain,
318 attr.stManual.para.gain.grgain,
319 attr.stManual.para.gain.gbgain,
320 attr.stManual.para.gain.bgain);
321 break;
322 case RK_AIQ_MWB_MODE_SCENE:
323 printf("\t manual mode = RK_AIQ_MWB_MODE_SCENE\n");
324 printf("\t manual scene = %d\n",
325 attr.stManual.para.scene);
326 break;
327 default:
328 printf("\t manual mode is invalid!\n");
329 break;
330 }
331 }
332 return 0;
333 }
334
sample_awb_getCct(const rk_aiq_sys_ctx_t * ctx)335 static int sample_awb_getCct(const rk_aiq_sys_ctx_t* ctx)
336 {
337 rk_aiq_wb_cct_t cct;
338 memset(&cct,0,sizeof(rk_aiq_wb_cct_t));
339 //get
340 rk_aiq_user_api2_awb_GetCCT(ctx, &cct);
341 printf("get rk_aiq_user_api2_awb_CCT:\n");
342 printf("\t CCRI = %f, CCT = %f\n\n", cct.CCRI, cct.CCT);
343
344 return 0;
345 }
346
sample_query_wb_info(const rk_aiq_sys_ctx_t * ctx)347 static int sample_query_wb_info(const rk_aiq_sys_ctx_t* ctx)
348 {
349 rk_aiq_wb_querry_info_t wb_querry_info;
350 rk_aiq_user_api2_awb_QueryWBInfo(ctx, &wb_querry_info);
351 printf("Query AWB Info\n\n");
352 printf("\t AWBGain = [%f %f %f %f]\n", wb_querry_info.gain.rgain,
353 wb_querry_info.gain.grgain,
354 wb_querry_info.gain.gbgain,
355 wb_querry_info.gain.bgain);
356 printf("\t cctGloabl: CCT = %f, CCRI = %f \n", wb_querry_info.cctGloabl.CCT, wb_querry_info.cctGloabl.CCRI);
357 printf("\t awbConverged: %s \n", (wb_querry_info.awbConverged ? "true" : "false"));
358 printf("\t LVValue: %d \n", wb_querry_info.LVValue);
359 return 0;
360 }
361
sample_awb_lock(const rk_aiq_sys_ctx_t * ctx)362 static int sample_awb_lock(const rk_aiq_sys_ctx_t* ctx)
363 {
364 rk_aiq_user_api2_awb_Lock(ctx);
365 printf("AWB Lock\n");
366
367 return 0;
368 }
369
sample_awb_unlock(const rk_aiq_sys_ctx_t * ctx)370 static int sample_awb_unlock(const rk_aiq_sys_ctx_t* ctx)
371 {
372 rk_aiq_user_api2_awb_Unlock(ctx);
373 printf("AWB Unlock\n");
374
375 return 0;
376 }
377
sample_awb_setModeManual(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)378 static int sample_awb_setModeManual(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
379 {
380 rk_aiq_uapiV2_wb_opMode_t attr;
381 memset(&attr,0,sizeof(rk_aiq_uapiV2_wb_opMode_t));
382 //get
383 rk_aiq_user_api2_awb_GetWpModeAttrib(ctx, &attr);
384 //modify
385 attr.sync.sync_mode = sync;
386 attr.mode = RK_AIQ_WB_MODE_MANUAL;
387 //set
388 rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, attr);
389 printf("set Mode Manual\n\n");
390
391 return 0;
392 }
393
sample_awb_setModeAuto(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)394 static int sample_awb_setModeAuto(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
395 {
396 rk_aiq_uapiV2_wb_opMode_t attr;
397 memset(&attr,0,sizeof(rk_aiq_uapiV2_wb_opMode_t));
398 //get
399 rk_aiq_user_api2_awb_GetWpModeAttrib(ctx, &attr);
400 //modify
401 attr.sync.sync_mode = sync;
402 attr.mode = RK_AIQ_WB_MODE_AUTO;
403 //set
404 rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, attr);
405 printf("set Mode Auto\n\n");
406
407 return 0;
408 }
409
sample_awb_getMode(const rk_aiq_sys_ctx_t * ctx)410 static int sample_awb_getMode(const rk_aiq_sys_ctx_t* ctx)
411 {
412 rk_aiq_uapiV2_wb_opMode_t attr;
413 memset(&attr,0,sizeof(rk_aiq_uapiV2_wb_opMode_t));
414 //get
415 rk_aiq_user_api2_awb_GetWpModeAttrib(ctx, &attr);
416 printf("get AWB Mode: %s\n\n", (attr.mode > 0 ? "Auto" : "Manual"));
417 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
418
419 return 0;
420 }
421
sample_awb_setMwb(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)422 static int sample_awb_setMwb(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
423 {
424 rk_aiq_wb_mwb_attrib_t attr;
425 memset(&attr,0,sizeof(rk_aiq_wb_mwb_attrib_t));
426 //set mode MANUAL
427 sample_awb_setModeManual(ctx, sync);
428 //get
429 rk_aiq_user_api2_awb_GetMwbAttrib(ctx, &attr);
430 //modify
431 attr.sync.sync_mode = sync;
432 attr.mode = RK_AIQ_MWB_MODE_WBGAIN;
433 if (attr.para.gain.rgain == 1.0) {
434 attr.para.gain.rgain = 0.5f;
435 attr.para.gain.grgain = 0.5f;
436 attr.para.gain.gbgain = 0.5f;
437 attr.para.gain.bgain = 0.5f;
438 } else {
439 attr.para.gain.rgain = 1.0f;
440 attr.para.gain.grgain = 0.5f;
441 attr.para.gain.gbgain = 0.5f;
442 attr.para.gain.bgain = 1.0f;
443 }
444
445 //set
446 rk_aiq_user_api2_awb_SetMwbAttrib(ctx, attr);
447 printf("set Manual attr\n\n");
448
449 return 0;
450 }
451
sample_awb_setMwb1(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)452 static int sample_awb_setMwb1(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
453 {
454 rk_aiq_wb_mwb_attrib_t attr;
455 memset(&attr,0,sizeof(rk_aiq_wb_mwb_attrib_t));
456 //set mode MANUAL
457 sample_awb_setModeManual(ctx, sync);
458 //get
459 rk_aiq_user_api2_awb_GetMwbAttrib(ctx, &attr);
460 //modify
461 attr.sync.sync_mode = sync;
462 attr.mode = RK_AIQ_MWB_MODE_SCENE;
463
464 //set
465 rk_aiq_user_api2_awb_SetMwbAttrib(ctx, attr);
466 printf("set Manual attr\n\n");
467
468 return 0;
469 }
470
sample_awb_setMwb2(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)471 static int sample_awb_setMwb2(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
472 {
473 rk_aiq_wb_mwb_attrib_t attr;
474 memset(&attr,0,sizeof(rk_aiq_wb_mwb_attrib_t));
475 //get
476 rk_aiq_user_api2_awb_GetMwbAttrib(ctx, &attr);
477 //modify
478 attr.sync.sync_mode = sync;
479 attr.mode = RK_AIQ_MWB_MODE_WBGAIN;
480 if (attr.para.gain.rgain == 1.0) {
481 attr.para.gain.rgain = 0.5f;
482 attr.para.gain.grgain = 0.5f;
483 attr.para.gain.gbgain = 0.5f;
484 attr.para.gain.bgain = 0.5f;
485 } else {
486 attr.para.gain.rgain = 1.0f;
487 attr.para.gain.grgain = 0.5f;
488 attr.para.gain.gbgain = 0.5f;
489 attr.para.gain.bgain = 1.0f;
490 }
491
492 //set
493 rk_aiq_user_api2_awb_SetMwbAttrib(ctx, attr);
494 printf("set Manual attr\n\n");
495
496 return 0;
497 }
498
sample_awb_getMwbAttr(const rk_aiq_sys_ctx_t * ctx)499 static int sample_awb_getMwbAttr(const rk_aiq_sys_ctx_t* ctx)
500 {
501 rk_aiq_wb_mwb_attrib_t attr;
502 memset(&attr,0,sizeof(rk_aiq_wb_mwb_attrib_t));
503 //get
504 rk_aiq_user_api2_awb_GetMwbAttrib(ctx, &attr);
505 printf("get Manual attr:\n\n");
506 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
507 switch (attr.mode)
508 {
509 case RK_AIQ_MWB_MODE_CCT:
510 printf("\t manual mode = RK_AIQ_MWB_MODE_CCT\n");
511 printf("\t manual cct = %f, ccri = %f\n",
512 attr.para.cct.CCT,
513 attr.para.cct.CCRI);
514 break;
515 case RK_AIQ_MWB_MODE_WBGAIN:
516 printf("\t manual mode = RK_AIQ_MWB_MODE_WBGAIN\n");
517 printf("\t manual wbgain = [%f, %f, %f, %f]\n",
518 attr.para.gain.rgain,
519 attr.para.gain.grgain,
520 attr.para.gain.gbgain,
521 attr.para.gain.bgain);
522 break;
523 case RK_AIQ_MWB_MODE_SCENE:
524 printf("\t manual mode = RK_AIQ_MWB_MODE_SCENE\n");
525 printf("\t manual scene = %d\n", attr.para.scene);
526 break;
527 default:
528 printf("\t manual mode is invalid!\n");
529 break;
530 }
531
532 return 0;
533 }
534
sample_awb_setWbGainAdjust(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)535 static int sample_awb_setWbGainAdjust(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
536 {
537 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t attr;
538 memset(&attr,0,sizeof(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t));
539 //set mode AUTO
540 sample_awb_setModeAuto(ctx, sync);
541 //get
542 rk_aiq_user_api2_awb_GetWbGainAdjustAttrib(ctx, &attr);
543 //modify
544 attr.sync.sync_mode = sync;
545 attr.enable = !attr.enable;
546 //set
547 rk_aiq_user_api2_awb_SetWbGainAdjustAttrib(ctx, attr);
548 printf("set AWbGainAdjust\n\n");
549 //free
550 for(int i = 0; i < attr.lutAll_len; i++) {
551 //printf("free attr->lutAll[%d].cri_lut_out= %p\n",i,attr.lutAll[i].cri_lut_out);
552 safe_free(attr.lutAll[i].cri_lut_out);
553 safe_free(attr.lutAll[i].ct_lut_out);
554 }
555 //printf(" free attr->lutAll= %p\n",attr.lutAll);
556 safe_free(attr.lutAll);
557 return 0;
558 }
559
sample_awb_getWbGainAdjust(const rk_aiq_sys_ctx_t * ctx)560 static int sample_awb_getWbGainAdjust(const rk_aiq_sys_ctx_t* ctx)
561 {
562 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t attr;
563 memset(&attr,0,sizeof(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t));
564 //get
565 rk_aiq_user_api2_awb_GetWbGainAdjustAttrib(ctx, &attr);
566 printf("get AWbGainAdjust:\n\n");
567 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
568 printf("\t enable = %s\n", (attr.enable ? "true" : "false"));
569 //free
570 for(int i = 0; i < attr.lutAll_len; i++) {
571 //printf("free attr->lutAll[%d].cri_lut_out= %p\n",i,attr.lutAll[i].cri_lut_out);
572 safe_free(attr.lutAll[i].cri_lut_out);
573 safe_free(attr.lutAll[i].ct_lut_out);
574 }
575 //printf(" free attr->lutAll= %p\n",attr.lutAll);
576 safe_free(attr.lutAll);
577 return 0;
578 }
579
sample_awb_setWbGainOffset(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)580 static int sample_awb_setWbGainOffset(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
581 {
582 rk_aiq_uapiV2_wb_awb_wbGainOffset_t attr;
583 memset(&attr,0,sizeof(rk_aiq_uapiV2_wb_awb_wbGainOffset_t));
584 //set mode AUTO
585 sample_awb_setModeAuto(ctx, sync);
586 //get
587 rk_aiq_user_api2_awb_GetWbGainOffsetAttrib(ctx, &attr);
588 //modify
589 attr.sync.sync_mode = sync;
590 attr.gainOffset.enable = !attr.gainOffset.enable;
591 attr.gainOffset.offset[0] = 1.0f;
592 attr.gainOffset.offset[1] = 0;
593 attr.gainOffset.offset[2] = 0;
594 attr.gainOffset.offset[3] = 0;
595 //set
596 rk_aiq_user_api2_awb_SetWbGainOffsetAttrib(ctx, attr);
597 printf("set WbGainOffset\n\n");
598
599 return 0;
600 }
601
sample_awb_getWbGainOffset(const rk_aiq_sys_ctx_t * ctx)602 static int sample_awb_getWbGainOffset(const rk_aiq_sys_ctx_t* ctx)
603 {
604 rk_aiq_uapiV2_wb_awb_wbGainOffset_t attr;
605 memset(&attr,0,sizeof(rk_aiq_uapiV2_wb_awb_wbGainOffset_t));
606 //get
607 rk_aiq_user_api2_awb_GetWbGainOffsetAttrib(ctx, &attr);
608 printf("get WbGainOffset:\n\n");
609 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
610 printf("WbGainOffset = {%d,[%f,%f,%f,%f]}\n\n",
611 attr.gainOffset.enable,
612 attr.gainOffset.offset[0],
613 attr.gainOffset.offset[1],
614 attr.gainOffset.offset[2],
615 attr.gainOffset.offset[3]);
616 return 0;
617 }
618
sample_awb_setWbAwbMultiWindow(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)619 static int sample_awb_setWbAwbMultiWindow(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
620 {
621 rk_aiq_uapiV2_wb_awb_mulWindow_t attr;
622 memset(&attr,0,sizeof(rk_aiq_uapiV2_wb_awb_mulWindow_t));
623 //get
624 rk_aiq_user_api2_awb_GetMultiWindowAttrib(ctx, &attr);
625 //modify
626 attr.sync.sync_mode = sync;
627 attr.multiWindw.enable = !attr.multiWindw.enable;
628 attr.multiWindw.multiwindowMode = CALIB_AWB_WIN_USELESS;
629 //set
630 rk_aiq_user_api2_awb_SetMultiWindowAttrib(ctx, attr);
631 printf("set Awb MultiWindow\n\n");
632
633 return 0;
634 }
635
sample_awb_getWbAwbMultiWindow(const rk_aiq_sys_ctx_t * ctx)636 static int sample_awb_getWbAwbMultiWindow(const rk_aiq_sys_ctx_t* ctx)
637 {
638 rk_aiq_uapiV2_wb_awb_mulWindow_t attr;
639 memset(&attr,0,sizeof(rk_aiq_uapiV2_wb_awb_mulWindow_t));
640 //get
641 rk_aiq_user_api2_awb_GetMultiWindowAttrib(ctx, &attr);
642 printf("get Awb MultiWindow:\n\n");
643 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
644 printf("\t enable = %s\n\n", (attr.multiWindw.enable ? "true" : "false"));
645 return 0;
646 }
647
648 #if 0
649 static int sample_awb_printflog(const rk_aiq_sys_ctx_t* ctx)
650 {
651 rk_tool_awb_stat_res_full_t awb_measure_result;
652 rk_tool_awb_strategy_result_t strategy_result;
653
654 //for(int i=0;i<100;i++)
655 {
656 memset(&awb_measure_result,0,sizeof(awb_measure_result));
657 rk_aiq_user_api2_awb_getAlgoSta(ctx, &awb_measure_result);
658 memset(&strategy_result,0,sizeof(strategy_result));
659 rk_aiq_user_api2_awb_getStrategyResult(ctx, &strategy_result);
660 printf("------------%d---------------\n",strategy_result.count);
661 printf("Global CCT:%f,CCRI:%f,valid:%d\n",strategy_result.cctGloabl.CCT,strategy_result.cctGloabl.CCRI,
662 strategy_result.cctGloabl.valid);
663 printf("wbgain_s6(after damping)(rggb):(%f,%f,%f,%f), awbConverged(%d) ,LVValue(%d), WPType(%d),df(%1.2f)\n",strategy_result.stat3aAwbGainOut[AWB_CHANNEL_R],
664 strategy_result.stat3aAwbGainOut[AWB_CHANNEL_GR], strategy_result.stat3aAwbGainOut[AWB_CHANNEL_GB],
665 strategy_result.stat3aAwbGainOut[AWB_CHANNEL_B], strategy_result.awbConverged, strategy_result.LVValue,strategy_result.WPType,
666 strategy_result.wbGainDampFactor);
667 printf("WPNo(normal,big):(%d,%d),vaild wp number in standard light(%d), vaild wp number in extra light(%d),xy_area_type %d \n",
668 awb_measure_result.WpNo[0], awb_measure_result.WpNo[1],
669 strategy_result.WPTotalNUM, awb_measure_result.extraLightResult.WpNo,strategy_result.xy_area_type);
670 printf("select white point range type (0-normal xy range,1-big xy range, 3-extra light) : %d, runInterval(%d),tolerance(%f) \n",strategy_result.xy_area_type,
671 strategy_result.runInterval, strategy_result.tolerance);
672 //printf("the effective light source slecetion to 3dyuv is :[%d,%d,%d,%d]\n", para->awb_cfg_effect_v201->threeDyuvIllu[0], para->awb_cfg_effect_v201->threeDyuvIllu[1],
673 // para->awb_cfg_effect_v201->threeDyuvIllu[2], para->awb_cfg_effect_v201->threeDyuvIllu[3]);
674 printf("LVLevel(%d),LVType(%d)\n", strategy_result.LVLevel, strategy_result.LVType);
675 printf("wbGainSgc for WPType1(rggb):(%f,%f,%f,%f) ,wbWeightSgc(%f),sgcGainEqu2Tem(%d)\n", strategy_result.wbGainSgc[0], strategy_result.wbGainSgc[1],
676 strategy_result.wbGainSgc[2], strategy_result.wbGainSgc[3], strategy_result.wbWeightSgc, strategy_result.sgcGainEqu2Tem);
677 printf("wbGainSpa for WPType1 (rggb):(%f,%f,%f,%f) ,wbWeightSpa(%f), spaGainEqu2Tem(%d) \n", strategy_result.wbGainSpa[AWB_CHANNEL_R], strategy_result.wbGainSpa[AWB_CHANNEL_GR],
678 strategy_result.wbGainSpa[AWB_CHANNEL_GB], strategy_result.wbGainSpa[AWB_CHANNEL_B], strategy_result.wbWeightSpa, strategy_result.spaGainEqu2Tem);
679 printf("wbGainTep for WPType1 (rggb):(%f,%f,%f,%f)\n", strategy_result.wbGainTep[AWB_CHANNEL_R], strategy_result.wbGainTep[AWB_CHANNEL_GR],
680 strategy_result.wbGainTep[AWB_CHANNEL_GB], strategy_result.wbGainTep[AWB_CHANNEL_B]);
681 printf("wbGainType1 (rggb):(%f,%f,%f,%f)\n", strategy_result.wbGainType1[AWB_CHANNEL_R], strategy_result.wbGainType1[AWB_CHANNEL_GR],
682 strategy_result.wbGainType1[AWB_CHANNEL_GB], strategy_result.wbGainType1[AWB_CHANNEL_B]);
683 printf("wbGainType3(rggb):(%f,%f,%f,%f)\n", strategy_result.wbGainType3[AWB_CHANNEL_R], strategy_result.wbGainType3[AWB_CHANNEL_GR],
684 strategy_result.wbGainType3[AWB_CHANNEL_GB], strategy_result.wbGainType3[AWB_CHANNEL_B]);
685 printf("wbgain_s1 (mix wbGainType1 and wbGainType3 ) :(%f,%f,%f,%f) is updated (%d), weight of wbGainType3 %f\n", strategy_result.wbGainIntpStrategy[AWB_CHANNEL_R],
686 strategy_result.wbGainIntpStrategy[AWB_CHANNEL_GR], strategy_result.wbGainIntpStrategy[AWB_CHANNEL_GB],
687 strategy_result.wbGainIntpStrategy[AWB_CHANNEL_B], strategy_result.updateFlag, strategy_result.wbWeightType3);
688 printf("wbgain_s2 (caga) :(%f,%f,%f,%f) \n", strategy_result.wbGainCaga[AWB_CHANNEL_R],
689 strategy_result.wbGainCaga[AWB_CHANNEL_GR], strategy_result.wbGainCaga[AWB_CHANNEL_GB],
690 strategy_result.wbGainCaga[AWB_CHANNEL_B]);
691 printf("wbgain_s3 (wbgainclip) :(%f,%f,%f,%f) \n", strategy_result.wbGainClip[AWB_CHANNEL_R],
692 strategy_result.wbGainClip[AWB_CHANNEL_GR], strategy_result.wbGainClip[AWB_CHANNEL_GB],
693 strategy_result.wbGainClip[AWB_CHANNEL_B]);
694 printf("wbgain_s4 (wbgainAdjust) :(%f,%f,%f,%f) \n", strategy_result.wbGainAdjust[AWB_CHANNEL_R],
695 strategy_result.wbGainAdjust[AWB_CHANNEL_GR], strategy_result.wbGainAdjust[AWB_CHANNEL_GB],
696 strategy_result.wbGainAdjust[AWB_CHANNEL_B]);
697 printf("wbgain_s5 (wbgainOffest) :(%f,%f,%f,%f) \n", strategy_result.wbGainOffset[AWB_CHANNEL_R],
698 strategy_result.wbGainOffset[AWB_CHANNEL_GR], strategy_result.wbGainOffset[AWB_CHANNEL_GB],
699 strategy_result.wbGainOffset[AWB_CHANNEL_B]);
700 printf("hdrFrameChoose %d\n",awb_measure_result.effectHwPara.hdrFrameChoose);
701 printf("select algorithm method based on stat_mode 0 (0-wp,1-gw) %d\n",strategy_result.algMethod);
702 char str1[500];
703 sprintf(str1, "%s", "WpNoHist: ");
704 for (int p = 0; p < RK_AIQ_AWBWP_WEIGHT_CURVE_DOT_NUM - 1; p++) {
705 char str2[100];
706 sprintf(str2, "%6d,", awb_measure_result.WpNoHist[p]);
707 strcat(str1,str2);
708 }
709 printf("%s\n",str1);
710 if (fabs(strategy_result.wbWeightSgc - 1) < 0.001 && strategy_result.wbWeightType3 < 0.02)
711 {
712 //printf("current light source : %d (%d,%d,%d)\n", para->sinColorResult.illEst,
713 // para->sinColorResult.voteResult[0], para->sinColorResult.voteResult[1], para->sinColorResult.voteResult[2]);
714 // printf("current color : %d\n", para->sinColorResult.colorEst);
715 for (int i = 0; i < strategy_result.lightNum; i++)
716 {
717 printf(" %s:\n", strategy_result.illInf[i].illName);
718 //printf(" %s:\n", strategy_result.illConf[i].illName);
719 //type0
720 for (int m = 0; m < 2; m++) {
721 printf(" type%d: gain (rg,bg):(%f,%f) WPNo(%d)\n", m, awb_measure_result.light[i].xYType[m].gain[0],
722 awb_measure_result.light[i].xYType[m].gain[3], awb_measure_result.light[i].xYType[m].WpNo);
723 }
724 }
725
726 printf("blockresult[15][15]:");
727 for (int i = 0; i < RK_AIQ_AWB_GRID_NUM_VERHOR * RK_AIQ_AWB_GRID_NUM_VERHOR; i++)
728 {
729 if (i % 15 == 0)
730 {
731 printf(" ");
732 }
733 printf("%d (%.7f,%.7f,%.7f), \n", i, awb_measure_result.blkSgcResult[i].R, awb_measure_result.blkSgcResult[i].G,
734 awb_measure_result.blkSgcResult[i].B);
735 }
736 printf("\n");
737 }
738 else
739 {
740 if (strategy_result.wbWeightSgc > 0.001) {
741 //printf("current light source : %s (%d,%d,%d)\n", strategy_result.illConf[para->sinColorResult.illEst].illName,
742 // para->sinColorResult.voteResult[0], para->sinColorResult.voteResult[1], para->sinColorResult.voteResult[2]);
743 //printf("current color : %d\n", para->sinColorResult.colorEst);
744 }
745
746 for (int i = 0; i < strategy_result.lightNum; i++)
747 {
748 //printf("%s:\n", strategy_result.illConf[i].illName);
749 printf(" %s:\n", strategy_result.illInf[i].illName);
750 printf(" strategy_result.gain (rggb):(%f,%f,%f,%f) \n",
751 strategy_result.illInf[i].gainValue[0], strategy_result.illInf[i].gainValue[1],
752 strategy_result.illInf[i].gainValue[2], strategy_result.illInf[i].gainValue[3]
753 );
754 printf(" prob_total(%f),prob_dis(%f),prob_LV(%f),prob_WPNO(%f)\n", strategy_result.illInf[i].prob_total, strategy_result.illInf[i].prob_dis,
755 strategy_result.illInf[i].prob_LV, strategy_result.illInf[i].prob_WPNO);
756 printf(" spatial gain(rggb):(%f,%f,%f,%f),statistics gain weight(%f)\n", strategy_result.illInf[i].spatialGainValue[0], strategy_result.illInf[i].spatialGainValue[1],
757 strategy_result.illInf[i].spatialGainValue[2], strategy_result.illInf[i].spatialGainValue[3], strategy_result.illInf[i].staWeight);
758
759 for (int m = 0; m < 2; m++) {
760
761 if (m == 2) {
762 printf(" type%d: gain (rg,bg):(%f,%f) WPNo(%d) Weight(%f)\n", m,
763 awb_measure_result.light[i].xYType[m].gain[0],
764 awb_measure_result.light[i].xYType[m].gain[3],
765 awb_measure_result.light[i].xYType[m].WpNo,
766 strategy_result.illInf[i].xyType2Weight);
767
768 }
769 else {
770 printf(" type%d: gain (rg,bg):(%f,%f) WPNo(%d)\n", m,
771 awb_measure_result.light[i].xYType[m].gain[0],
772 awb_measure_result.light[i].xYType[m].gain[3],
773 awb_measure_result.light[i].xYType[m].WpNo);
774
775 }
776 }
777
778 }
779
780 }
781
782 printf("\n");
783 }
784
785
786
787 return 0;
788 }
789 #endif
790
sample_awb_getStrategyResult(const rk_aiq_sys_ctx_t * ctx)791 static int sample_awb_getStrategyResult(const rk_aiq_sys_ctx_t* ctx)
792 {
793 rk_tool_awb_strategy_result_t attr;
794 memset(&attr,0,sizeof(attr));
795 rk_aiq_user_api2_awb_getStrategyResult(ctx, &attr);
796 return 0;
797 }
798
sample_awb_setWbV32AwbMultiWindow(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)799 static int sample_awb_setWbV32AwbMultiWindow(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
800 {
801 rk_aiq_uapiV2_wbV32_awb_mulWindow_t attr;
802 memset(&attr,0,sizeof(rk_aiq_uapiV2_wbV32_awb_mulWindow_t));
803 //get
804 rk_aiq_user_api2_awbV32_GetMultiWindowAttrib(ctx, &attr);
805 //modify
806 attr.sync.sync_mode = sync;
807 attr.enable = !attr.enable;
808 attr.window[0][0]= 0;
809 attr.window[0][1]= 0;
810 attr.window[0][2]= 0.25;
811 attr.window[0][3]= 0;
812 //set
813 rk_aiq_user_api2_awbV32_SetMultiWindowAttrib(ctx, attr);
814 printf("set Awb MultiWindow\n\n");
815
816 return 0;
817 }
818
sample_awb_getWbV32AwbMultiWindow(const rk_aiq_sys_ctx_t * ctx)819 static int sample_awb_getWbV32AwbMultiWindow(const rk_aiq_sys_ctx_t* ctx)
820 {
821 rk_aiq_uapiV2_wbV32_awb_mulWindow_t attr;
822 memset(&attr,0,sizeof(rk_aiq_uapiV2_wbV32_awb_mulWindow_t));
823 //get
824 rk_aiq_user_api2_awbV32_GetMultiWindowAttrib(ctx, &attr);
825 printf("get Awb MultiWindow:\n\n");
826 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
827 printf("\t enable = %s\n\n", (attr.enable ? "true" : "false"));
828 return 0;
829 }
830
831
sample_awb_awbv32_setAllAttr(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)832 static int sample_awb_awbv32_setAllAttr(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
833 {
834 rk_aiq_uapiV2_wbV32_attrib_t attr;
835 memset(&attr,0,sizeof(rk_aiq_uapiV2_wbV32_attrib_t));
836 //get
837 rk_aiq_user_api2_awbV32_GetAllAttrib(ctx, &attr);
838 //modify
839 attr.sync.sync_mode = sync;
840 attr.stAuto.wbGainOffset.enable = !attr.stAuto.wbGainOffset.enable;
841 if(attr.stAuto.algMtdTp == RK_AIQ_AWB_ALG_TYPE_GLOABL){
842 attr.stAuto.algMtdTp = RK_AIQ_AWB_ALG_TYPE_GRAYWORD;
843 }else{
844 attr.stAuto.algMtdTp = RK_AIQ_AWB_ALG_TYPE_GLOABL;
845 }
846
847 if(attr.stAuto.dampFactor.dFMax > 0.5){
848 attr.stAuto.dampFactor.dFMax =0.4;
849 attr.stAuto.dampFactor.dFMin = 0.14;
850 attr.stAuto.dampFactor.dFStep=0.074;
851 }else{
852 attr.stAuto.dampFactor.dFMax =0.6;
853 attr.stAuto.dampFactor.dFMin = 0.16;
854 attr.stAuto.dampFactor.dFStep=0.076;
855 }
856
857 if(attr.stAuto.wbGainDaylightClip.enable ==false){
858 attr.stAuto.wbGainDaylightClip.enable =true;
859 attr.stAuto.wbGainDaylightClip.outdoor_cct_min = 10000;
860 }else{
861 attr.stAuto.wbGainDaylightClip.enable =false;
862 }
863 if(attr.stAuto.wbGainClip.enable ==false){
864 attr.stAuto.wbGainClip.enable =true;
865 attr.stAuto.wbGainClip.cct_len = attr.stAuto.wbGainClip.cct_len+1;
866 attr.stAuto.wbGainClip.cct[0]-=100;
867 attr.stAuto.wbGainClip.cct[attr.stAuto.wbGainClip.cct_len-1]=
868 attr.stAuto.wbGainClip.cct[attr.stAuto.wbGainClip.cct_len-2]+100;
869 for(int i=0;i<attr.stAuto.wbGainClip.cct_len;i++){
870 attr.stAuto.wbGainClip.cri_bound_low[i] =0.01;
871 attr.stAuto.wbGainClip.cri_bound_up[i] =0.02;
872 }
873
874 }else{
875 attr.stAuto.wbGainClip.enable =false;
876 }
877 if(attr.stAuto.wbGainAdjust.enable ==false){
878 attr.stAuto.wbGainAdjust.enable = true;
879 attr.stAuto.wbGainAdjust.lutAll_len +=1;
880 memcpy(&attr.stAuto.wbGainAdjust.lutAll[attr.stAuto.wbGainAdjust.lutAll_len-1],
881 &attr.stAuto.wbGainAdjust.lutAll[attr.stAuto.wbGainAdjust.lutAll_len-2],
882 sizeof(CalibDbV2_Awb_Cct_Lut_Cfg_Lv2_t));
883 attr.stAuto.wbGainAdjust.lutAll[attr.stAuto.wbGainAdjust.lutAll_len-1].ctlData +=1000;
884 for(int i=0;i<attr.stAuto.wbGainAdjust.lutAll_len;i++){
885 attr.stAuto.wbGainAdjust.lutAll[i].rgct_in_ds[0]=0.5;
886 attr.stAuto.wbGainAdjust.lutAll[i].rgct_in_ds[9-1]=3.5;
887 attr.stAuto.wbGainAdjust.lutAll[i].bgcri_in_ds[0]=4.5;
888 attr.stAuto.wbGainAdjust.lutAll[i].bgcri_in_ds[11-1]=1.0;
889 for(int j=0;j<9*11;j++){
890 attr.stAuto.wbGainAdjust.lutAll[i].rgct_lut_out[j] +=0.1;
891 attr.stAuto.wbGainAdjust.lutAll[i].bgcri_lut_out[j] -=0.1;
892 }
893 }
894 }else{
895 attr.stAuto.wbGainAdjust.enable = false;
896 }
897 attr.stAuto.wbGainOffset_valid = false;
898 attr.stAuto.multiWindow_valid = false;
899 //set
900 rk_aiq_user_api2_awbV32_SetAllAttrib(ctx, attr);
901 printf("set Awbv32 AllAttr\n\n");
902 return 0;
903 }
904
sample_awb_awbv32_getAllAttr(const rk_aiq_sys_ctx_t * ctx)905 static int sample_awb_awbv32_getAllAttr(const rk_aiq_sys_ctx_t* ctx)
906 {
907 rk_aiq_uapiV2_wbV32_attrib_t attr ;
908 memset(&attr,0,sizeof(rk_aiq_uapiV2_wbV32_attrib_t));
909 //get
910 rk_aiq_user_api2_awbV32_GetAllAttrib(ctx, &attr);
911 printf("get Awbv32 AllAttr:\n");
912 printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
913 printf("\t bypass = %d\n", attr.byPass);
914 printf("\t mode = %s\n", (attr.mode > 0 ? "auto" : "manual"));
915 if (attr.mode > 0) {
916 printf("\t wbGainOffset = {%s,[%f,%f,%f,%f]}\n\n",
917 (attr.stAuto.wbGainOffset.enable > 0 ? "true" : "false"),
918 attr.stAuto.wbGainOffset.offset[0],
919 attr.stAuto.wbGainOffset.offset[1],
920 attr.stAuto.wbGainOffset.offset[2],
921 attr.stAuto.wbGainOffset.offset[3]);
922 } else {
923 switch (attr.stManual.mode)
924 {
925 case RK_AIQ_MWB_MODE_CCT:
926 printf("\t manual mode = RK_AIQ_MWB_MODE_CCT\n");
927 printf("\t manual cct = %f, ccri = %f\n",
928 attr.stManual.para.cct.CCT,
929 attr.stManual.para.cct.CCRI);
930 break;
931 case RK_AIQ_MWB_MODE_WBGAIN:
932 printf("\t manual mode = RK_AIQ_MWB_MODE_WBGAIN\n");
933 printf("\t manual wbgain = [%f, %f, %f, %f]\n",
934 attr.stManual.para.gain.rgain,
935 attr.stManual.para.gain.grgain,
936 attr.stManual.para.gain.gbgain,
937 attr.stManual.para.gain.bgain);
938 break;
939 case RK_AIQ_MWB_MODE_SCENE:
940 printf("\t manual mode = RK_AIQ_MWB_MODE_SCENE\n");
941 printf("\t manual scene = %d\n",
942 attr.stManual.para.scene);
943 break;
944 default:
945 printf("\t manual mode is invalid!\n");
946 break;
947 }
948 }
949 return 0;
950 }
951
sample_awb_WriteAwbIn(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)952 static int sample_awb_WriteAwbIn(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
953 {
954 static int call_cnt =0;
955 rk_aiq_uapiV2_awb_wrtIn_attr_t attr;
956 memset(&attr,0,sizeof(rk_aiq_uapiV2_awb_wrtIn_attr_t));
957 attr.en = true;
958 attr.mode = 1; // 1 means rgb ,0 means raw
959 attr.call_cnt = call_cnt++;
960 sprintf(attr.path,"/tmp");
961 rk_aiq_user_api2_awb_WriteAwbIn(ctx, attr);
962 printf("Write awb input \n\n");
963
964 return 0;
965 }
sample_awb_setFFWbgain(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync)966 static int sample_awb_setFFWbgain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
967 {
968 rk_aiq_uapiV2_awb_ffwbgain_attr_t attr;
969 memset(&attr,0,sizeof(rk_aiq_uapiV2_awb_ffwbgain_attr_t));
970 attr.wggain={1.0,1.0,1.0,1.0};
971 rk_aiq_user_api2_awb_SetFFWbgainAttrib(ctx, attr);
972 printf("setFFWbgain \n\n");
973
974 return 0;
975 }
976
977 //#if rk356x || rk3588
sample_awb1_usage()978 static void sample_awb1_usage()
979 {
980 printf("Usage : \n");
981 printf(" ImgProc API: \n");
982 printf("\t 0) AWB: setWBMode-OP_MANUAL.\n");
983 printf("\t 1) AWB: setWBMode-OP_AUTO.\n");
984 printf("\t 2) AWB: getWBMode.\n");
985 printf("\t 3) AWB: lockAWB.\n");
986 printf("\t 4) AWB: unlockAWB.\n");
987 printf("\t 5) AWB: setMWBScene.\n");
988 printf("\t 6) AWB: getMWBScene.\n");
989 printf("\t 7) AWB: setMWBGain.\n");
990 printf("\t 8) AWB: getWBGain.\n");
991 printf("\t 9) AWB: setMWBCT.\n");
992 printf("\t a) AWB: getWBCT.\n");
993 printf("\t b) AWB: setWbGainOffset.\n");
994 printf("\t c) AWB: getWbGainOffset.\n");
995 printf("\t d) AWB: setAwbGainAdjust.\n");
996 printf("\t e) AWB: getAwbGainAdjust.\n");
997 printf("\t f) AWB: setAllAttrib.\n");
998 printf("\n");
999 printf(" Module API: \n");
1000 printf("\t A) AWB: set Awbv21 AllAttr & Sync.\n");
1001 printf("\t B) AWB: set Awbv21 AllAttr & Async.\n");
1002 printf("\t C) AWB: set Awbv30 AllAttr & Sync.\n");
1003 printf("\t D) AWB: set Awbv30 AllAttr & Async.\n");
1004 printf("\t E) AWB: get CCT.\n");
1005 printf("\t F) AWB: Query Awb Info.\n");
1006 printf("\t G) AWB: Lock.\n");
1007 printf("\t I) AWB: Unlock.\n");
1008 printf("\t J) AWB: set Mode Manual & Sync.\n");
1009 printf("\t K) AWB: set Mode Manual & Async.\n");
1010 printf("\t L) AWB: set Mode Auto & Sync.\n");
1011 printf("\t M) AWB: set Mode Auto & Async.\n");
1012 printf("\t N) AWB: set Manual attr & Sync.\n");
1013 printf("\t O) AWB: set Manual attr & Async.\n");
1014 printf("\t P) AWB: set AwbGainAdjust & Sync.\n");
1015 printf("\t R) AWB: set AwbGainAdjust & Async.\n");
1016 printf("\t S) AWB: set WbGainOffset & Sync.\n");
1017 printf("\t T) AWB: set WbGainOffset & Async.\n");
1018 printf("\n");
1019 printf("\t h) AWB: help.\n");
1020 printf("\t q) AWB: return to main sample screen.\n");
1021
1022 }
1023
1024 //for rk356x ,rk3588
sample_awb_module(const void * arg)1025 XCamReturn sample_awb_module(const void *arg)
1026 {
1027 int key = -1;
1028 CLEAR();
1029 rk_aiq_wb_scene_t scene;
1030 rk_aiq_wb_gain_t gain;
1031 rk_aiq_wb_cct_t ct;
1032 opMode_t mode;
1033 const demo_context_t *demo_ctx = (demo_context_t *)arg;
1034 const rk_aiq_sys_ctx_t* ctx;
1035 if (demo_ctx->camGroup){
1036 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
1037 } else {
1038 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
1039 }
1040 if (ctx == nullptr) {
1041 ERR ("%s, ctx is nullptr\n", __FUNCTION__);
1042 return XCAM_RETURN_ERROR_PARAM;
1043 }
1044 unsigned int cct;
1045
1046 sample_awb1_usage ();
1047 do {
1048 printf("\t please press the key: ");
1049 key = getchar ();
1050 while (key == '\n' || key == '\r')
1051 key = getchar();
1052 printf ("\n");
1053
1054 switch (key)
1055 {
1056 case 'h':
1057 CLEAR();
1058 sample_awb1_usage ();
1059 break;
1060 case '0':
1061 sample_set_wbmode_manual(ctx);
1062 printf("setWBMode manual\n\n");
1063 break;
1064 case '1':
1065 sample_set_wbmode_auto(ctx);
1066 printf("setWBMode auto\n\n");
1067 break;
1068 case '2':
1069 sample_get_wbmode(ctx);
1070 break;
1071 case '3':
1072 sample_lock_awb(ctx);
1073 printf("lockAWB\n\n");
1074 break;
1075 case '4':
1076 sample_unlock_awb(ctx);
1077 printf("unlockAWB\n\n");
1078 break;
1079 case '5':
1080 sample_set_mwb_scene(ctx);
1081 printf("setMWBScene\n\n");
1082 break;
1083 case '6':
1084 sample_get_mwb_scene(ctx);
1085 break;
1086 case '7':
1087 sample_set_mwb_gain(ctx);
1088 printf("setMWBGain\n\n");
1089 break;
1090 case '8':
1091 sample_get_mwb_gain(ctx);
1092 break;
1093 case '9':
1094 sample_set_mwb_ct(ctx);
1095 break;
1096 case 'a':
1097 sample_get_mwb_ct(ctx);
1098 break;
1099 case 'b':
1100 sample_set_awb_gainoffset(ctx);
1101 printf("setAWBGainOffset\n\n");
1102 break;
1103 case 'c':
1104 sample_get_awb_gainoffset(ctx);
1105 break;
1106 case 'd':
1107 sample_set_awb_gain_adjust(ctx);
1108 break;
1109 case 'e':
1110 sample_get_awb_gain_adjust(ctx);
1111 break;
1112 case 'f':
1113 sample_set_awbv30_atrr(ctx);
1114 break;
1115 case 'A':
1116 sample_awb_awbv21_setAllAttr(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1117 sample_awb_awbv21_getAllAttr(ctx);
1118 break;
1119 case 'B':
1120 sample_awb_awbv21_setAllAttr(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1121 sample_awb_awbv21_getAllAttr(ctx);
1122 usleep(40 * 1000);
1123 sample_awb_awbv21_getAllAttr(ctx);
1124 break;
1125 case 'C':
1126 sample_awb_awbv30_setAllAttr(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1127 sample_awb_awbv30_getAllAttr(ctx);
1128 break;
1129 case 'D':
1130 sample_awb_awbv30_setAllAttr(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1131 sample_awb_awbv30_getAllAttr(ctx);
1132 usleep(40 * 1000);
1133 sample_awb_awbv30_getAllAttr(ctx);
1134 break;
1135 case 'E':
1136 sample_awb_getCct(ctx);
1137 break;
1138 case 'F':
1139 sample_query_wb_info(ctx);
1140 break;
1141 case 'G':
1142 sample_awb_lock(ctx);
1143 break;
1144 case 'I':
1145 sample_awb_unlock(ctx);
1146 break;
1147 case 'J':
1148 sample_awb_setModeManual(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1149 sample_awb_getMode(ctx);
1150 break;
1151 case 'K':
1152 sample_awb_setModeManual(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1153 sample_awb_getMode(ctx);
1154 usleep(40 * 1000);
1155 sample_awb_getMode(ctx);
1156 break;
1157 case 'L':
1158 sample_awb_setModeAuto(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1159 sample_awb_getMode(ctx);
1160 break;
1161 case 'M':
1162 sample_awb_setModeAuto(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1163 sample_awb_getMode(ctx);
1164 usleep(40 * 1000);
1165 sample_awb_getMode(ctx);
1166 break;
1167 case 'N':
1168 sample_awb_setMwb(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1169 sample_awb_getMwbAttr(ctx);
1170 break;
1171 case 'O':
1172 sample_awb_setMwb(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1173 sample_awb_getMwbAttr(ctx);
1174 usleep(40 * 1000);
1175 sample_awb_getMwbAttr(ctx);
1176 break;
1177 case 'P':
1178 sample_awb_setWbGainAdjust(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1179 sample_awb_getWbGainAdjust(ctx);
1180 break;
1181 case 'R':
1182 sample_awb_setWbGainAdjust(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1183 sample_awb_getWbGainAdjust(ctx);
1184 usleep(40 * 1000);
1185 sample_awb_getWbGainAdjust(ctx);
1186 break;
1187 case 'S':
1188 sample_awb_setWbGainOffset(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1189 sample_awb_getWbGainOffset(ctx);
1190 break;
1191 case 'T':
1192 sample_awb_setWbGainOffset(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1193 sample_awb_getWbGainOffset(ctx);
1194 usleep(40 * 1000);
1195 sample_awb_getWbGainOffset(ctx);
1196 break;
1197 // NOT Support MultiWindow
1198 case 'U':
1199 sample_awb_setWbAwbMultiWindow(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1200 sample_awb_getWbAwbMultiWindow(ctx);
1201 break;
1202 case 'V':
1203 sample_awb_setWbAwbMultiWindow(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1204 sample_awb_getWbAwbMultiWindow(ctx);
1205 usleep(40 * 1000);
1206 sample_awb_getWbAwbMultiWindow(ctx);
1207 break;
1208 case 'X':
1209 sample_awb_setMwb1(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1210 sample_awb_getMwbAttr(ctx);
1211 sample_awb_setMwb2(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1212 sample_awb_getMwbAttr(ctx);
1213
1214 usleep(40 * 1000);
1215 sample_awb_getMwbAttr(ctx);
1216 break;
1217 #if 0
1218 case 'Y':
1219 sample_awb_printflog(ctx);
1220 break;
1221 #endif
1222 default:
1223 break;
1224 }
1225 } while (key != 'q' && key != 'Q');
1226 return XCAM_RETURN_NO_ERROR;
1227
1228 }
1229 //#elseif rv1106
sample_awb32_usage()1230 static void sample_awb32_usage()
1231 {
1232 printf("Usage : \n");
1233 printf(" ImgProc API: \n");
1234 printf("\t 0) AWB: setWBMode-OP_MANUAL.\n");
1235 printf("\t 1) AWB: setWBMode-OP_AUTO.\n");
1236 printf("\t 2) AWB: getWBMode.\n");
1237 printf("\t 3) AWB: lockAWB.\n");
1238 printf("\t 4) AWB: unlockAWB.\n");
1239 printf("\t 5) AWB: setMWBScene.\n");
1240 printf("\t 6) AWB: getMWBScene.\n");
1241 printf("\t 7) AWB: setMWBGain.\n");
1242 printf("\t 8) AWB: getWBGain.\n");
1243 printf("\t 9) AWB: setMWBCT.\n");
1244 printf("\t a) AWB: getWBCT.\n");
1245 printf("\t b) AWB: setWbGainOffset.\n");
1246 printf("\t c) AWB: getWbGainOffset.\n");
1247 printf("\t d) AWB: setAwbGainAdjust.\n");
1248 printf("\t e) AWB: getAwbGainAdjust.\n");
1249 printf("\t f) AWB: setAllAttrib.\n");
1250 printf("\n");
1251 printf(" Module API: \n");
1252 printf("\t A) AWB: set Awbv32 AllAttr & Sync.\n");
1253 printf("\t B) AWB: set Awbv32 AllAttr & Async.\n");
1254 printf("\t E) AWB: get CCT.\n");
1255 printf("\t F) AWB: Query Awb Info.\n");
1256 printf("\t G) AWB: Lock.\n");
1257 printf("\t I) AWB: Unlock.\n");
1258 printf("\t J) AWB: set Mode Manual & Sync.\n");
1259 printf("\t K) AWB: set Mode Manual & Async.\n");
1260 printf("\t L) AWB: set Mode Auto & Sync.\n");
1261 printf("\t M) AWB: set Mode Auto & Async.\n");
1262 printf("\t N) AWB: set Manual attr & Sync.\n");
1263 printf("\t O) AWB: set Manual attr & Async.\n");
1264 printf("\t P) AWB: set AwbGainAdjust & Sync.\n");
1265 printf("\t R) AWB: set AwbGainAdjust & Async.\n");
1266 printf("\t S) AWB: set WbGainOffset & Sync.\n");
1267 printf("\t T) AWB: set WbGainOffset & Async.\n");
1268 printf("\t U) AWB: set MultiWindow & Sync.\n");
1269 printf("\t V) AWB: set MultiWindow & Async.\n");
1270 printf("\n");
1271 printf("\t h) AWB: help.\n");
1272 printf("\t q) AWB: return to main sample screen.\n");
1273
1274 }
1275 //for rv1106
sample_awb32_module(const void * arg)1276 XCamReturn sample_awb32_module(const void *arg)
1277 {
1278 int key = -1;
1279 CLEAR();
1280 rk_aiq_wb_scene_t scene;
1281 rk_aiq_wb_gain_t gain;
1282 rk_aiq_wb_cct_t ct;
1283 opMode_t mode;
1284 const demo_context_t *demo_ctx = (demo_context_t *)arg;
1285 const rk_aiq_sys_ctx_t* ctx;
1286 if (demo_ctx->camGroup){
1287 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
1288 } else {
1289 ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
1290 }
1291 if (ctx == nullptr) {
1292 ERR ("%s, ctx is nullptr\n", __FUNCTION__);
1293 return XCAM_RETURN_ERROR_PARAM;
1294 }
1295 unsigned int cct;
1296
1297 sample_awb32_usage ();
1298 do {
1299 printf("\t please press the key: ");
1300 key = getchar ();
1301 while (key == '\n' || key == '\r')
1302 key = getchar();
1303 printf ("\n");
1304
1305 switch (key)
1306 {
1307 case 'h':
1308 CLEAR();
1309 sample_awb32_usage ();
1310 break;
1311 case '0':
1312 sample_set_wbmode_manual(ctx);
1313 printf("setWBMode manual\n\n");
1314 break;
1315 case '1':
1316 sample_set_wbmode_auto(ctx);
1317 printf("setWBMode auto\n\n");
1318 break;
1319 case '2':
1320 sample_get_wbmode(ctx);
1321 break;
1322 case '3':
1323 sample_lock_awb(ctx);
1324 printf("lockAWB\n\n");
1325 break;
1326 case '4':
1327 sample_unlock_awb(ctx);
1328 printf("unlockAWB\n\n");
1329 break;
1330 case '5':
1331 sample_set_mwb_scene(ctx);
1332 printf("setMWBScene\n\n");
1333 break;
1334 case '6':
1335 sample_get_mwb_scene(ctx);
1336 break;
1337 case '7':
1338 sample_set_mwb_gain(ctx);
1339 printf("setMWBGain\n\n");
1340 break;
1341 case '8':
1342 sample_get_mwb_gain(ctx);
1343 break;
1344 case '9':
1345 sample_set_mwb_ct(ctx);
1346 break;
1347 case 'a':
1348 sample_get_mwb_ct(ctx);
1349 break;
1350 case 'b':
1351 sample_set_awb_gainoffset(ctx);
1352 printf("setAWBGainOffset\n\n");
1353 break;
1354 case 'c':
1355 sample_get_awb_gainoffset(ctx);
1356 break;
1357 case 'd':
1358 sample_set_awb_gain_adjust(ctx);
1359 break;
1360 case 'e':
1361 sample_get_awb_gain_adjust(ctx);
1362 break;
1363 case 'A':
1364 sample_awb_awbv32_setAllAttr(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1365 sample_awb_awbv32_getAllAttr(ctx);
1366 break;
1367 case 'B':
1368 sample_awb_awbv32_setAllAttr(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1369 sample_awb_awbv32_getAllAttr(ctx);
1370 usleep(40 * 1000);
1371 sample_awb_awbv32_getAllAttr(ctx);
1372 break;
1373 case 'E':
1374 sample_awb_getCct(ctx);
1375 break;
1376 case 'F':
1377 sample_query_wb_info(ctx);
1378 break;
1379 case 'G':
1380 sample_awb_lock(ctx);
1381 break;
1382 case 'I':
1383 sample_awb_unlock(ctx);
1384 break;
1385 case 'J':
1386 sample_awb_setModeManual(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1387 sample_awb_getMode(ctx);
1388 break;
1389 case 'K':
1390 sample_awb_setModeManual(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1391 sample_awb_getMode(ctx);
1392 usleep(40 * 1000);
1393 sample_awb_getMode(ctx);
1394 break;
1395 case 'L':
1396 sample_awb_setModeAuto(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1397 sample_awb_getMode(ctx);
1398 break;
1399 case 'M':
1400 sample_awb_setModeAuto(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1401 sample_awb_getMode(ctx);
1402 usleep(40 * 1000);
1403 sample_awb_getMode(ctx);
1404 break;
1405 case 'N':
1406 sample_awb_setMwb(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1407 sample_awb_getMwbAttr(ctx);
1408 break;
1409 case 'O':
1410 sample_awb_setMwb(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1411 sample_awb_getMwbAttr(ctx);
1412 usleep(40 * 1000);
1413 sample_awb_getMwbAttr(ctx);
1414 break;
1415 case 'P':
1416 sample_awb_setWbGainAdjust(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1417 sample_awb_getWbGainAdjust(ctx);
1418 break;
1419 case 'R':
1420 sample_awb_setWbGainAdjust(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1421 sample_awb_getWbGainAdjust(ctx);
1422 usleep(40 * 1000);
1423 sample_awb_getWbGainAdjust(ctx);
1424 break;
1425 case 'S':
1426 sample_awb_setWbGainOffset(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1427 sample_awb_getWbGainOffset(ctx);
1428 break;
1429 case 'T':
1430 sample_awb_setWbGainOffset(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1431 sample_awb_getWbGainOffset(ctx);
1432 usleep(40 * 1000);
1433 sample_awb_getWbGainOffset(ctx);
1434 break;
1435 case 'U':
1436 sample_awb_setWbV32AwbMultiWindow(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1437 sample_awb_getWbV32AwbMultiWindow(ctx);
1438 break;
1439 case 'V':
1440 sample_awb_setWbV32AwbMultiWindow(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1441 sample_awb_getWbV32AwbMultiWindow(ctx);
1442 usleep(40 * 1000);
1443 sample_awb_getWbV32AwbMultiWindow(ctx);
1444 break;
1445 case 'X':
1446 sample_awb_setMwb1(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1447 sample_awb_getMwbAttr(ctx);
1448 sample_awb_setMwb2(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1449 sample_awb_getMwbAttr(ctx);
1450 usleep(40 * 1000);
1451 sample_awb_getMwbAttr(ctx);
1452 break;
1453 case 'Y':
1454 sample_awb_WriteAwbIn(ctx, RK_AIQ_UAPI_MODE_ASYNC);
1455 break;
1456 case 'Z':
1457 sample_awb_setFFWbgain(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
1458 break;
1459 default:
1460 break;
1461 }
1462 } while (key != 'q' && key != 'Q');
1463 return XCAM_RETURN_NO_ERROR;
1464 }
1465 //#endif
1466
1467
1468