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_ablc_usage()20 static void sample_ablc_usage()
21 {
22 printf("Usage : \n");
23 printf("\t 0) ABLC: get ablc attri on sync mode.\n");
24 printf("\t 1) ABLC: set ablc attri auto on sync mode.\n");
25 printf("\t 2) ABLC: set ablc attri manual on sync mode.\n");
26 printf("\t 3) ABLC: set ablc attri to default value on sync mode.\n");
27 printf("\t 4) ABLC: get ablc attri on async mode.\n");
28 printf("\t 5) ABLC: set ablc attri auto on async mode.\n");
29 printf("\t 6) ABLC: set ablc attri manual on async mode.\n");
30 printf("\t 7) ABLC: set ablc attri to default value on async mode.\n");
31 printf("\t q) ABLC: press key q or Q to quit.\n");
32 }
33
sample_print_ablc_info(const void * arg)34 void sample_print_ablc_info(const void *arg)
35 {
36 printf ("enter ABLC modult test!\n");
37 }
38
39
sample_ablc_getAttr(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync_mode)40 XCamReturn sample_ablc_getAttr(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync_mode)
41 {
42 XCamReturn ret = XCAM_RETURN_NO_ERROR;
43
44 rk_aiq_blc_attrib_t blc_attr;
45 blc_attr.sync.sync_mode = sync_mode;
46 memset(&blc_attr, 0x00, sizeof(blc_attr));//important, need init first
47 ret = rk_aiq_user_api2_ablc_GetAttrib(ctx, &blc_attr);
48 printf("get ablc attri ret:%d done:%d \n\n", ret, blc_attr.sync.done);
49
50 return ret;
51 }
52
sample_ablc_getAttr_v32(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync_mode)53 XCamReturn sample_ablc_getAttr_v32(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync_mode)
54 {
55 XCamReturn ret = XCAM_RETURN_NO_ERROR;
56
57 rk_aiq_blc_attrib_V32_t blc_attr;
58 blc_attr.sync.sync_mode = sync_mode;
59 memset(&blc_attr, 0x00, sizeof(blc_attr));//important, need init first
60 ret = rk_aiq_user_api2_ablcV32_GetAttrib(ctx, &blc_attr);
61 printf("get ablc attri ret:%d done:%d \n\n", ret, blc_attr.sync.done);
62
63 return ret;
64 }
65
sample_ablc_setAuto(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync_mode)66 XCamReturn sample_ablc_setAuto(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync_mode)
67 {
68 XCamReturn ret = XCAM_RETURN_NO_ERROR;
69
70 rk_aiq_blc_attrib_t blc_attr;
71 blc_attr.sync.sync_mode = sync_mode;
72 memset(&blc_attr, 0x00, sizeof(blc_attr));//important, need init first
73 ret = rk_aiq_user_api2_ablc_GetAttrib(ctx, &blc_attr);
74 blc_attr.sync.sync_mode = sync_mode;
75 blc_attr.eMode = ABLC_OP_MODE_AUTO;
76 blc_attr.stBlc0Auto.enable = 1;
77 for(int i = 0; i < ABLC_MAX_ISO_LEVEL; i++) {
78 blc_attr.stBlc0Auto.iso[i] = 50 * pow(2, i);
79 blc_attr.stBlc0Auto.blc_r[i] = 255;
80 blc_attr.stBlc0Auto.blc_gr[i] = 255;
81 blc_attr.stBlc0Auto.blc_gb[i] = 255;
82 blc_attr.stBlc0Auto.blc_b[i] = 255;
83 }
84
85 blc_attr.stBlc1Auto.enable = 1;
86 for(int i = 0; i < ABLC_MAX_ISO_LEVEL; i++) {
87 blc_attr.stBlc1Auto.iso[i] = 50 * pow(2, i);
88 blc_attr.stBlc1Auto.blc_r[i] = 254;
89 blc_attr.stBlc1Auto.blc_gr[i] = 254;
90 blc_attr.stBlc1Auto.blc_gb[i] = 254;
91 blc_attr.stBlc1Auto.blc_b[i] = 254;
92 }
93
94 ret = rk_aiq_user_api2_ablc_SetAttrib(ctx, &blc_attr);
95 printf("set ablc attri auto ret:%d \n\n", ret);
96
97 rk_aiq_blc_attrib_t get_blc_attr;
98 get_blc_attr.sync.sync_mode = sync_mode;
99 memset(&get_blc_attr, 0x00, sizeof(get_blc_attr));//important, need init first
100 ret = rk_aiq_user_api2_ablc_GetAttrib(ctx, &get_blc_attr);
101 printf("get ablc attri ret:%d done:%d \n\n", ret, get_blc_attr.sync.done);
102
103
104 return ret;
105
106 }
107
sample_ablc_setAuto_v32(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync_mode)108 XCamReturn sample_ablc_setAuto_v32(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync_mode)
109 {
110 XCamReturn ret = XCAM_RETURN_NO_ERROR;
111
112 rk_aiq_blc_attrib_V32_t blc_attr;
113 blc_attr.sync.sync_mode = sync_mode;
114 memset(&blc_attr, 0x00, sizeof(blc_attr));//important, need init first
115 ret = rk_aiq_user_api2_ablcV32_GetAttrib(ctx, &blc_attr);
116 blc_attr.sync.sync_mode = sync_mode;
117 blc_attr.eMode = ABLC_V32_OP_MODE_AUTO;
118 blc_attr.stBlc0Auto.enable = 1;
119 for(int i = 0; i < ABLCV32_MAX_ISO_LEVEL; i++) {
120 blc_attr.stBlc0Auto.iso[i] = 50 * pow(2, i);
121 blc_attr.stBlc0Auto.blc_r[i] = 255;
122 blc_attr.stBlc0Auto.blc_gr[i] = 255;
123 blc_attr.stBlc0Auto.blc_gb[i] = 255;
124 blc_attr.stBlc0Auto.blc_b[i] = 255;
125 }
126
127 blc_attr.stBlc1Auto.enable = 0;
128 for(int i = 0; i < ABLCV32_MAX_ISO_LEVEL; i++) {
129 blc_attr.stBlc1Auto.iso[i] = 50 * pow(2, i);
130 blc_attr.stBlc1Auto.blc_r[i] = 254;
131 blc_attr.stBlc1Auto.blc_gr[i] = 254;
132 blc_attr.stBlc1Auto.blc_gb[i] = 254;
133 blc_attr.stBlc1Auto.blc_b[i] = 254;
134 }
135
136 blc_attr.stBlcOBAuto.enable = 1;
137 for(int i = 0; i < ABLCV32_MAX_ISO_LEVEL; i++) {
138 blc_attr.stBlcOBAuto.iso[i] = 50 * pow(2, i);
139 blc_attr.stBlcOBAuto.ob_offset[i] = 0;
140 blc_attr.stBlcOBAuto.ob_predgain[i] = 1;
141 }
142
143 ret = rk_aiq_user_api2_ablcV32_SetAttrib(ctx, &blc_attr);
144 printf("set ablc attri auto ret:%d \n\n", ret);
145
146 rk_aiq_blc_attrib_V32_t get_blc_attr;
147 get_blc_attr.sync.sync_mode = sync_mode;
148 memset(&get_blc_attr, 0x00, sizeof(get_blc_attr));//important, need init first
149 ret = rk_aiq_user_api2_ablcV32_GetAttrib(ctx, &get_blc_attr);
150 printf("get ablc attri ret:%d done:%d \n\n", ret, get_blc_attr.sync.done);
151
152 return ret;
153
154 }
155
156
sample_ablc_setManual(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync_mode)157 XCamReturn sample_ablc_setManual(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync_mode)
158 {
159 XCamReturn ret = XCAM_RETURN_NO_ERROR;
160
161 rk_aiq_blc_attrib_t blc_attr;
162 memset(&blc_attr, 0x00, sizeof(blc_attr));//important, need init first
163 blc_attr.sync.sync_mode = sync_mode;
164 ret = rk_aiq_user_api2_ablc_GetAttrib(ctx, &blc_attr);
165 blc_attr.sync.sync_mode = sync_mode;
166 blc_attr.eMode = ABLC_OP_MODE_MANUAL;
167 blc_attr.stBlc0Manual.enable = 1;
168 blc_attr.stBlc0Manual.blc_r = 253;
169 blc_attr.stBlc0Manual.blc_gr = 253;
170 blc_attr.stBlc0Manual.blc_gb = 253;
171 blc_attr.stBlc0Manual.blc_b = 253;
172
173 blc_attr.stBlc1Manual.enable = 1;
174 blc_attr.stBlc1Manual.blc_r = 253;
175 blc_attr.stBlc1Manual.blc_gr = 253;
176 blc_attr.stBlc1Manual.blc_gb = 253;
177 blc_attr.stBlc1Manual.blc_b = 253;
178
179
180 ret = rk_aiq_user_api2_ablc_SetAttrib(ctx, &blc_attr);
181 printf("set blc attri manual ret:%d \n\n", ret);
182
183
184 rk_aiq_blc_attrib_t get_blc_attr;
185 get_blc_attr.sync.sync_mode = sync_mode;
186 memset(&get_blc_attr, 0x00, sizeof(get_blc_attr));//important, need init first
187 ret = rk_aiq_user_api2_ablc_GetAttrib(ctx, &get_blc_attr);
188 printf("get ablc attri ret:%d done:%d \n\n", ret, get_blc_attr.sync.done);
189
190 sleep(1);
191
192 return ret;
193
194 }
195
196
sample_ablc_setManual_v32(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync_mode)197 XCamReturn sample_ablc_setManual_v32(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync_mode)
198 {
199 XCamReturn ret = XCAM_RETURN_NO_ERROR;
200
201 rk_aiq_blc_attrib_V32_t blc_attr;
202 memset(&blc_attr, 0x00, sizeof(blc_attr));//important, need init first
203 blc_attr.sync.sync_mode = sync_mode;
204 ret = rk_aiq_user_api2_ablcV32_GetAttrib(ctx, &blc_attr);
205 blc_attr.sync.sync_mode = sync_mode;
206 blc_attr.eMode = ABLC_V32_OP_MODE_MANUAL;
207 blc_attr.stBlc0Manual.enable = 1;
208 blc_attr.stBlc0Manual.blc_r = 253;
209 blc_attr.stBlc0Manual.blc_gr = 253;
210 blc_attr.stBlc0Manual.blc_gb = 253;
211 blc_attr.stBlc0Manual.blc_b = 253;
212
213 blc_attr.stBlc1Manual.enable = 1;
214 blc_attr.stBlc1Manual.blc_r = 253;
215 blc_attr.stBlc1Manual.blc_gr = 253;
216 blc_attr.stBlc1Manual.blc_gb = 253;
217 blc_attr.stBlc1Manual.blc_b = 253;
218
219 blc_attr.stBlcOBManual.enable = 1;
220 blc_attr.stBlcOBManual.ob_offset = 0;
221 blc_attr.stBlcOBManual.ob_predgain = 1;
222
223 ret = rk_aiq_user_api2_ablcV32_SetAttrib(ctx, &blc_attr);
224 printf("set blc attri manual ret:%d \n\n", ret);
225
226
227 rk_aiq_blc_attrib_V32_t get_blc_attr;
228 get_blc_attr.sync.sync_mode = sync_mode;
229 memset(&get_blc_attr, 0x00, sizeof(get_blc_attr));//important, need init first
230 ret = rk_aiq_user_api2_ablcV32_GetAttrib(ctx, &get_blc_attr);
231 printf("get ablc attri ret:%d done:%d \n\n", ret, get_blc_attr.sync.done);
232
233 sleep(1);
234 return ret;
235
236 }
237
238
sample_ablc_setDefault(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync_mode,rk_aiq_blc_attrib_t & default_blc_attr)239 XCamReturn sample_ablc_setDefault(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync_mode, rk_aiq_blc_attrib_t &default_blc_attr)
240 {
241 XCamReturn ret = XCAM_RETURN_NO_ERROR;
242
243 default_blc_attr.sync.sync_mode = sync_mode;
244 ret = rk_aiq_user_api2_ablc_SetAttrib(ctx, &default_blc_attr);
245 printf("set blc attri auto default value ret:%d \n\n", ret);
246
247
248 rk_aiq_blc_attrib_t get_blc_attr;
249 get_blc_attr.sync.sync_mode = sync_mode;
250 memset(&get_blc_attr, 0x00, sizeof(get_blc_attr));//important, need init first
251 ret = rk_aiq_user_api2_ablc_GetAttrib(ctx, &get_blc_attr);
252 printf("get ablc attri ret:%d done:%d \n\n", ret, get_blc_attr.sync.done);
253
254 sleep(1);
255
256 return ret;
257
258 }
259
sample_ablc_setDefault_v32(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapi_mode_sync_e sync_mode,rk_aiq_blc_attrib_V32_t & default_blc_attr)260 XCamReturn sample_ablc_setDefault_v32(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync_mode, rk_aiq_blc_attrib_V32_t &default_blc_attr)
261 {
262 XCamReturn ret = XCAM_RETURN_NO_ERROR;
263
264 default_blc_attr.sync.sync_mode = sync_mode;
265 ret = rk_aiq_user_api2_ablcV32_SetAttrib(ctx, &default_blc_attr);
266 printf("set blc attri auto default value ret:%d \n\n", ret);
267
268
269 rk_aiq_blc_attrib_V32_t get_blc_attr;
270 get_blc_attr.sync.sync_mode = sync_mode;
271 memset(&get_blc_attr, 0x00, sizeof(get_blc_attr));//important, need init first
272 ret = rk_aiq_user_api2_ablcV32_GetAttrib(ctx, &get_blc_attr);
273 printf("get ablc attri ret:%d done:%d \n\n", ret, get_blc_attr.sync.done);
274
275 sleep(1);
276 return ret;
277
278 }
279
280
sample_ablc_module(const void * arg)281 XCamReturn sample_ablc_module (const void *arg)
282 {
283 int key = -1;
284 CLEAR();
285 XCamReturn ret = XCAM_RETURN_NO_ERROR;
286 const demo_context_t *demo_ctx = (demo_context_t *)arg;
287 const rk_aiq_sys_ctx_t* ctx ;
288
289 if (demo_ctx->camGroup) {
290 ctx = (const rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
291 printf("##################group !!!!########################\n");
292 } else {
293 ctx = (const rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
294 printf("##################sigle !!!!########################\n");
295 }
296 if (ctx == nullptr) {
297 ERR ("%s, ctx is nullptr\n", __FUNCTION__);
298 return XCAM_RETURN_ERROR_PARAM;
299 }
300
301 rk_aiq_blc_attrib_t default_blc_attr;
302 if (CHECK_ISP_HW_V30()) {
303 memset(&default_blc_attr, 0x00, sizeof(default_blc_attr));//important, need init first
304 rk_aiq_user_api2_ablc_GetAttrib(ctx, &default_blc_attr);
305 }
306
307 rk_aiq_blc_attrib_V32_t default_blc_attr_v32;
308 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
309 memset(&default_blc_attr_v32, 0x00, sizeof(default_blc_attr_v32));//important, need init first
310 rk_aiq_user_api2_ablcV32_GetAttrib(ctx, &default_blc_attr_v32);
311 }
312
313 do {
314 sample_ablc_usage ();
315
316 key = getchar ();
317 while (key == '\n' || key == '\r')
318 key = getchar ();
319 printf ("\n");
320
321 switch (key) {
322 case '0':
323 if (CHECK_ISP_HW_V30()) {
324 sample_ablc_getAttr(ctx, RK_AIQ_UAPI_MODE_SYNC);
325 }
326 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
327 sample_ablc_getAttr_v32(ctx, RK_AIQ_UAPI_MODE_SYNC);
328 }
329 break;
330 case '1':
331 if (CHECK_ISP_HW_V30()) {
332 sample_ablc_setAuto(ctx, RK_AIQ_UAPI_MODE_SYNC);
333 }
334 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
335 sample_ablc_setAuto_v32(ctx, RK_AIQ_UAPI_MODE_SYNC);
336 }
337 break;
338 case '2':
339 if (CHECK_ISP_HW_V30()) {
340 sample_ablc_setManual(ctx, RK_AIQ_UAPI_MODE_SYNC);
341 }
342 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
343 sample_ablc_setManual_v32(ctx, RK_AIQ_UAPI_MODE_SYNC);
344 }
345 break;
346 case '3':
347 if (CHECK_ISP_HW_V30()) {
348 sample_ablc_setDefault(ctx, RK_AIQ_UAPI_MODE_SYNC, default_blc_attr);
349 }
350 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
351 sample_ablc_setDefault_v32(ctx, RK_AIQ_UAPI_MODE_SYNC, default_blc_attr_v32);
352 }
353 break;
354 case '4':
355 if (CHECK_ISP_HW_V30()) {
356 sample_ablc_getAttr(ctx, RK_AIQ_UAPI_MODE_ASYNC);
357 }
358 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
359 sample_ablc_getAttr_v32(ctx, RK_AIQ_UAPI_MODE_ASYNC);
360 }
361 break;
362 case '5':
363 if (CHECK_ISP_HW_V30()) {
364 sample_ablc_setAuto(ctx, RK_AIQ_UAPI_MODE_ASYNC);
365 }
366 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
367 sample_ablc_setAuto_v32(ctx, RK_AIQ_UAPI_MODE_ASYNC);
368 }
369 break;
370 case '6':
371 if (CHECK_ISP_HW_V30()) {
372 sample_ablc_setManual(ctx, RK_AIQ_UAPI_MODE_ASYNC);
373 }
374 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
375 sample_ablc_setManual_v32(ctx, RK_AIQ_UAPI_MODE_ASYNC);
376 }
377 break;
378 case '7':
379 if (CHECK_ISP_HW_V30()) {
380 sample_ablc_setDefault(ctx, RK_AIQ_UAPI_MODE_ASYNC, default_blc_attr);
381 }
382 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
383 sample_ablc_setDefault_v32(ctx, RK_AIQ_UAPI_MODE_ASYNC, default_blc_attr_v32);
384 }
385 break;
386 default:
387 printf("not support test\n\n");
388 break;
389 }
390
391 } while (key != 'q' && key != 'Q');
392
393 return ret;
394 }
395
396