1 /* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above
9 * copyright notice, this list of conditions and the following
10 * disclaimer in the documentation and/or other materials provided
11 * with the distribution.
12 * * Neither the name of The Linux Foundation nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30 #include <stdio.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include <stdlib.h>
34 #include <ctype.h>
35 #include <inttypes.h>
36
37 #include "mm_qcamera_main_menu.h"
38 #include "mm_qcamera_app.h"
39 #include "mm_qcamera_dbg.h"
40 #include "mm_qcamera_socket.h"
41
42 /*===========================================================================
43 * Macro
44 *===========================================================================*/
45 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
46 #define VIDEO_BUFFER_SIZE (PREVIEW_WIDTH * PREVIEW_HEIGHT * 3/2)
47 #define THUMBNAIL_BUFFER_SIZE (THUMBNAIL_WIDTH * THUMBNAIL_HEIGHT * 3/2)
48 #define SNAPSHOT_BUFFER_SIZE (PICTURE_WIDTH * PICTURE_HEIGHT * 3/2)
49 //TODO:check this Macros with current app.
50
51 /*===========================================================================
52 * Defines
53 *===========================================================================*/
54 //#define VIDEO_FRAMES_NUM 4
55 #define THUMBNAIL_FRAMES_NUM 1
56 #define SNAPSHOT_FRAMES_NUM 1
57 #define MAX_NUM_FORMAT 32
58 #define ZOOM_STEP 2
59 #define ZOOM_MIN_VALUE 0
60 #define EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR 12
61 #define EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR -12
62 #define EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR 0
63 #define EXPOSURE_COMPENSATION_DENOMINATOR 6
64
65 //TODO: find correct values of Contrast defines.
66 #define CAMERA_MIN_CONTRAST 0
67 #define CAMERA_DEF_CONTRAST 5
68 #define CAMERA_MAX_CONTRAST 10
69 #define CAMERA_CONTRAST_STEP 1
70
71 //TODO: find correct values of Brightness defines.
72 #define CAMERA_MIN_BRIGHTNESS 0
73 #define CAMERA_DEF_BRIGHTNESS 3
74 #define CAMERA_MAX_BRIGHTNESS 6
75 #define CAMERA_BRIGHTNESS_STEP 1
76
77 //TODO: find correct values of Saturation defines.
78 #define CAMERA_MIN_SATURATION 0
79 #define CAMERA_DEF_SATURATION 5
80 #define CAMERA_MAX_SATURATION 10
81 #define CAMERA_SATURATION_STEP 1
82
83 #define CAMERA_MIN_SHARPNESS 0
84 #define CAMERA_MAX_SHARPNESS 10
85 #define CAMERA_DEF_SHARPNESS 5
86 #define CAMERA_SHARPNESS_STEP 1
87
88 const CAMERA_MAIN_MENU_TBL_T camera_main_menu_tbl[] = {
89 {START_PREVIEW, "Start preview"},
90 {STOP_PREVIEW, "Stop preview/video"},
91 {SET_WHITE_BALANCE, "Set white balance mode"},
92 {SET_TINTLESS_ENABLE, "Set Tintless Enable"},
93 {SET_TINTLESS_DISABLE, "Set Tintless Disable"},
94 {SET_EXP_METERING, "Set exposure metering mode"},
95 {GET_CTRL_VALUE, "Get control value menu"},
96 {TOGGLE_AFR, "Toggle auto frame rate. Default fixed frame rate"},
97 {SET_ISO, "ISO changes."},
98 {BRIGHTNESS_GOTO_SUBMENU, "Brightness changes."},
99 {CONTRAST_GOTO_SUBMENU, "Contrast changes."},
100 {EV_GOTO_SUBMENU, "EV changes."},
101 {SATURATION_GOTO_SUBMENU, "Saturation changes."},
102 {SET_ZOOM, "Set Digital Zoom."},
103 {SET_SHARPNESS, "Set Sharpness."},
104 {TAKE_JPEG_SNAPSHOT, "Take a snapshot"},
105 {START_RECORDING, "Start RECORDING"},
106 {STOP_RECORDING, "Stop RECORDING"},
107 {BEST_SHOT, "Set best-shot mode"},
108 {LIVE_SHOT, "Take a live snapshot"},
109 {FLASH_MODES, "Set Flash modes"},
110 {TOGGLE_ZSL, "Toggle ZSL On/Off"},
111 {TAKE_RAW_SNAPSHOT, "Take RAW snapshot"},
112 {SWITCH_SNAP_RESOLUTION, "Select Jpeg resolution"},
113 {TOGGLE_WNR, "Toggle Wavelet Denoise"},
114 {EXIT, "Exit"}
115 };
116
117 CAMERA_SENSOR_MENU_TLB_T sensor_tbl[] = {
118 {"Primary Camera", 0},
119 {"Secondary Camera", 0},
120 {"Camera Sensor 3", 0},
121 {"Camera Sensor 4", 0}
122 };
123
124 const CAMERA_BRIGHTNESS_TBL_T brightness_change_tbl[] = {
125 {INC_BRIGHTNESS, "Increase Brightness by one step."},
126 {DEC_BRIGHTNESS, "Decrease Brightness by one step."},
127 };
128
129 const CAMERA_CONTRST_TBL_T contrast_change_tbl[] = {
130 {INC_CONTRAST, "Increase Contrast by one step."},
131 {DEC_CONTRAST, "Decrease Contrast by one step."},
132 };
133
134 const CAMERA_EV_TBL_T camera_EV_tbl[] = {
135 {INCREASE_EV, "Increase EV by one step."},
136 {DECREASE_EV, "Decrease EV by one step."},
137 };
138
139 const CAMERA_SATURATION_TBL_T camera_saturation_tbl[] = {
140 {INC_SATURATION, "Increase Satuation by one step."},
141 {DEC_SATURATION, "Decrease Satuation by one step."},
142 };
143
144 const CAMERA_SHARPNESS_TBL_T camera_sharpness_tbl[] = {
145 {INC_SHARPNESS, "Increase Sharpness."},
146 {DEC_SHARPNESS, "Decrease Sharpness."},
147 };
148
149 const WHITE_BALANCE_TBL_T white_balance_tbl[] = {
150 { WB_AUTO, "White Balance - Auto"},
151 { WB_INCANDESCENT, "White Balance - Incandescent"},
152 { WB_FLUORESCENT, "White Balance - Fluorescent"},
153 { WB_WARM_FLUORESCENT, "White Balance - Warm Fluorescent"},
154 { WB_DAYLIGHT, "White Balance - Daylight"},
155 { WB_CLOUDY_DAYLIGHT, "White Balance - Cloudy Daylight"},
156 { WB_TWILIGHT, "White Balance - Twilight"},
157 { WB_SHADE, "White Balance - Shade"},
158 };
159
160 const GET_CTRL_TBL_T get_ctrl_tbl[] = {
161 { WHITE_BALANCE_STATE, "Get white balance state (auto/off)"},
162 { WHITE_BALANCE_TEMPERATURE, "Get white balance temperature"},
163 { BRIGHTNESS_CTRL, "Get brightness value"},
164 { EV, "Get exposure value"},
165 { CONTRAST_CTRL, "Get contrast value"},
166 { SATURATION_CTRL, "Get saturation value"},
167 { SHARPNESS_CTRL, "Get sharpness value"},
168 };
169
170 const EXP_METERING_TBL_T exp_metering_tbl[] = {
171 { AUTO_EXP_FRAME_AVG, "Exposure Metering - Frame Average"},
172 { AUTO_EXP_CENTER_WEIGHTED, "Exposure Metering - Center Weighted"},
173 { AUTO_EXP_SPOT_METERING, "Exposure Metering - Spot Metering"},
174 { AUTO_EXP_SMART_METERING, "Exposure Metering - Smart Metering"},
175 { AUTO_EXP_USER_METERING, "Exposure Metering - User Metering"},
176 { AUTO_EXP_SPOT_METERING_ADV, "Exposure Metering - Spot Metering Adv"},
177 { AUTO_EXP_CENTER_WEIGHTED_ADV,"Exposure Metering - Center Weighted Adv"},
178 };
179
180 const ISO_TBL_T iso_tbl[] = {
181 { ISO_AUTO, "ISO: Auto"},
182 { ISO_DEBLUR, "ISO: Deblur"},
183 { ISO_100, "ISO: 100"},
184 { ISO_200, "ISO: 200"},
185 { ISO_400, "ISO: 400"},
186 { ISO_800, "ISO: 800"},
187 { ISO_1600, "ISO: 1600"},
188 };
189
190 const ZOOM_TBL_T zoom_tbl[] = {
191 { ZOOM_IN, "Zoom In one step"},
192 { ZOOM_OUT, "Zoom Out one step"},
193 };
194
195 const BESTSHOT_MODE_TBT_T bestshot_mode_tbl[] = {
196 {BESTSHOT_AUTO, "Bestshot Mode: Auto"},
197 {BESTSHOT_ACTION, "Bestshot Mode: Action"},
198 {BESTSHOT_PORTRAIT, "Bestshot Mode: Portrait"},
199 {BESTSHOT_LANDSCAPE, "Bestshot Mode: Landscape"},
200 {BESTSHOT_NIGHT, "Bestshot Mode: Night"},
201 {BESTSHOT_NIGHT_PORTRAIT, "Bestshot Mode: Night Portrait"},
202 {BESTSHOT_THEATRE, "Bestshot Mode: Theatre"},
203 {BESTSHOT_BEACH, "Bestshot Mode: Beach"},
204 {BESTSHOT_SNOW, "Bestshot Mode: Snow"},
205 {BESTSHOT_SUNSET, "Bestshot Mode: Sunset"},
206 {BESTSHOT_ANTISHAKE, "Bestshot Mode: Antishake"},
207 {BESTSHOT_FIREWORKS, "Bestshot Mode: Fireworks"},
208 {BESTSHOT_SPORTS, "Bestshot Mode: Sports"},
209 {BESTSHOT_PARTY, "Bestshot Mode: Party"},
210 {BESTSHOT_CANDLELIGHT, "Bestshot Mode: Candlelight"},
211 {BESTSHOT_ASD, "Bestshot Mode: ASD"},
212 {BESTSHOT_BACKLIGHT, "Bestshot Mode: Backlight"},
213 {BESTSHOT_FLOWERS, "Bestshot Mode: Flowers"},
214 {BESTSHOT_AR, "Bestshot Mode: Augmented Reality"},
215 {BESTSHOT_HDR, "Bestshot Mode: HDR"},
216 };
217
218 const FLASH_MODE_TBL_T flashmodes_tbl[] = {
219 { FLASH_MODE_OFF, "Flash Mode Off"},
220 { FLASH_MODE_AUTO, "Flash Mode Auto"},
221 { FLASH_MODE_ON, "Flash Mode On"},
222 { FLASH_MODE_TORCH, "Flash Mode Torch"},
223 };
224
225 DIMENSION_TBL_T dimension_tbl[] = {
226 {VGA_WIDTH, VGA_HEIGHT, "VGA", "Size: VGA <640x480>" , 0},
227 {MP1_WIDTH, MP1_HEIGHT, "1MP", "Size: 1MP <1280x960>" , 0},
228 {MP5_WIDTH, MP5_HEIGHT, "5MP", "Size: 5MP <2592x1944>", 0},
229 {MP8_WIDTH, MP8_HEIGHT, "8MP", "Size: 8MP <3264x2448>", 0},
230 {MP12_WIDTH, MP12_HEIGHT, "12MP", "Size: 12MP <4000x3000>", 0},
231 };
232
233 /*===========================================================================
234 * Forward declarations
235 *===========================================================================*/
236 //static void system_dimension_set(mm_camera_test_obj_t *test_obj);
237 /*===========================================================================
238 * Static global variables
239 *===========================================================================*/
240 USER_INPUT_DISPLAY_T input_display;
241 int preview_video_resolution_flag = 0;
242
243 //TODO: default values.
244 #if 1
245 int brightness = CAMERA_DEF_BRIGHTNESS;
246 int contrast = CAMERA_DEF_CONTRAST;
247 int saturation = CAMERA_DEF_SATURATION;
248 int sharpness = CAMERA_DEF_SHARPNESS;
249 #else
250 int brightness = 0;
251 int contrast = 0;
252 int saturation = 0;
253 int sharpness = 0;
254 #endif
255 //TODO: find new method to calculate ev.
256 //int32_t ev_numerator = EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR;
257
258 //TODO:
259 //fps_mode_t fps_mode = FPS_MODE_FIXED;
260 int zoom_level;
261 int zoom_max_value;
262 int cam_id;
263 int is_rec = 0;
264
265
266 static int submain();
267
268 /*===========================================================================
269 * FUNCTION - keypress_to_event -
270 *
271 * DESCRIPTION:
272 *==========================================================================*/
keypress_to_event(char keypress)273 int keypress_to_event(char keypress)
274 {
275 int out_buf = INVALID_KEY_PRESS;
276 if ((keypress >= 'A' && keypress <= 'Z') ||
277 (keypress >= 'a' && keypress <= 'z')) {
278 out_buf = tolower(keypress);
279 out_buf = out_buf - 'a';
280 } else if (keypress >= '0' && keypress <= '9') {
281 out_buf = keypress - '0';
282 }
283 return out_buf;
284 }
285
next_menu(menu_id_change_t current_menu_id,char keypress,camera_action_t * action_id_ptr,int * action_param)286 int next_menu(menu_id_change_t current_menu_id, char keypress, camera_action_t * action_id_ptr, int * action_param)
287 {
288 int output_to_event;
289 menu_id_change_t next_menu_id = MENU_ID_INVALID;
290 * action_id_ptr = ACTION_NO_ACTION;
291
292 output_to_event = keypress_to_event(keypress);
293 CDBG("current_menu_id=%d\n",current_menu_id);
294 printf("output_to_event=%d\n",output_to_event);
295 switch(current_menu_id) {
296 case MENU_ID_MAIN:
297 switch(output_to_event) {
298 case START_PREVIEW:
299 * action_id_ptr = ACTION_START_PREVIEW;
300 CDBG("START_PREVIEW\n");
301 break;
302 case STOP_PREVIEW:
303 * action_id_ptr = ACTION_STOP_PREVIEW;
304 CDBG("STOP_PREVIEW\n");
305 break;
306
307 case SET_WHITE_BALANCE:
308 next_menu_id = MENU_ID_WHITEBALANCECHANGE;
309 CDBG("next_menu_id = MENU_ID_WHITEBALANCECHANGE = %d\n", next_menu_id);
310 break;
311
312 case SET_TINTLESS_ENABLE:
313 * action_id_ptr = ACTION_SET_TINTLESS_ENABLE;
314 next_menu_id = MENU_ID_MAIN;
315 CDBG("next_menu_id = MENU_ID_TINTLESSENABLE = %d\n", next_menu_id);
316 break;
317
318 case SET_TINTLESS_DISABLE:
319 * action_id_ptr = ACTION_SET_TINTLESS_DISABLE;
320 next_menu_id = MENU_ID_MAIN;
321 CDBG("next_menu_id = MENU_ID_TINTLESSDISABLE = %d\n", next_menu_id);
322 break;
323
324 case SET_EXP_METERING:
325 next_menu_id = MENU_ID_EXPMETERINGCHANGE;
326 CDBG("next_menu_id = MENU_ID_EXPMETERINGCHANGE = %d\n", next_menu_id);
327 break;
328
329 case GET_CTRL_VALUE:
330 next_menu_id = MENU_ID_GET_CTRL_VALUE;
331 CDBG("next_menu_id = MENU_ID_GET_CTRL_VALUE = %d\n", next_menu_id);
332 break;
333
334 case BRIGHTNESS_GOTO_SUBMENU:
335 next_menu_id = MENU_ID_BRIGHTNESSCHANGE;
336 CDBG("next_menu_id = MENU_ID_BRIGHTNESSCHANGE = %d\n", next_menu_id);
337 break;
338
339 case CONTRAST_GOTO_SUBMENU:
340 next_menu_id = MENU_ID_CONTRASTCHANGE;
341 break;
342
343 case EV_GOTO_SUBMENU:
344 next_menu_id = MENU_ID_EVCHANGE;
345 break;
346
347 case SATURATION_GOTO_SUBMENU:
348 next_menu_id = MENU_ID_SATURATIONCHANGE;
349 break;
350
351 case TOGGLE_AFR:
352 * action_id_ptr = ACTION_TOGGLE_AFR;
353 CDBG("next_menu_id = MENU_ID_TOGGLEAFR = %d\n", next_menu_id);
354 break;
355
356 case SET_ISO:
357 next_menu_id = MENU_ID_ISOCHANGE;
358 CDBG("next_menu_id = MENU_ID_ISOCHANGE = %d\n", next_menu_id);
359 break;
360
361 case SET_ZOOM:
362 next_menu_id = MENU_ID_ZOOMCHANGE;
363 CDBG("next_menu_id = MENU_ID_ZOOMCHANGE = %d\n", next_menu_id);
364 break;
365
366 case BEST_SHOT:
367 next_menu_id = MENU_ID_BESTSHOT;
368 CDBG("next_menu_id = MENU_ID_BESTSHOT = %d\n", next_menu_id);
369 break;
370
371 case LIVE_SHOT:
372 * action_id_ptr = ACTION_TAKE_LIVE_SNAPSHOT;
373 CDBG("\nTaking Live snapshot\n");
374 break;
375
376 case FLASH_MODES:
377 next_menu_id = MENU_ID_FLASHMODE;
378 CDBG("next_menu_id = MENU_ID_FLASHMODE = %d\n", next_menu_id);
379 break;
380
381 case SET_SHARPNESS:
382 next_menu_id = MENU_ID_SHARPNESSCHANGE;
383 CDBG("next_menu_id = MENU_ID_SHARPNESSCHANGE = %d\n", next_menu_id);
384 break;
385
386 case SWITCH_SNAP_RESOLUTION:
387 next_menu_id = MENU_ID_SWITCH_RES;
388 CDBG("next_menu_id = MENU_ID_SWITCH_RES = %d\n", next_menu_id);
389 break;
390
391 case TAKE_JPEG_SNAPSHOT:
392 * action_id_ptr = ACTION_TAKE_JPEG_SNAPSHOT;
393 printf("\n Taking JPEG snapshot\n");
394 break;
395
396 case START_RECORDING:
397 * action_id_ptr = ACTION_START_RECORDING;
398 CDBG("Start recording\n");
399 break;
400 case STOP_RECORDING:
401 * action_id_ptr = ACTION_STOP_RECORDING;
402 CDBG("Stop recording\n");
403 break;
404 case TOGGLE_ZSL:
405 * action_id_ptr = ACTION_TOGGLE_ZSL;
406 CDBG("Toggle ZSL\n");
407 break;
408 case TAKE_RAW_SNAPSHOT:
409 * action_id_ptr = ACTION_TAKE_RAW_SNAPSHOT;
410 next_menu_id = MENU_ID_MAIN;
411 CDBG("Capture RAW\n");
412 break;
413 case TOGGLE_WNR:
414 * action_id_ptr = ACTION_TOGGLE_WNR;
415 next_menu_id = MENU_ID_MAIN;
416 CDBG("Toggle WNR");
417 break;
418 case EXIT:
419 * action_id_ptr = ACTION_EXIT;
420 CDBG("Exit \n");
421 break;
422 default:
423 next_menu_id = MENU_ID_MAIN;
424 CDBG("next_menu_id = MENU_ID_MAIN = %d\n", next_menu_id);
425 break;
426 }
427 break;
428
429 case MENU_ID_SWITCH_RES:
430 printf("MENU_ID_SWITCH_RES\n");
431 *action_id_ptr = ACTION_SWITCH_RESOLUTION;
432 *action_param = output_to_event;
433 int available_sizes = sizeof(dimension_tbl)/sizeof(dimension_tbl[0]);
434 if ( ( *action_param >= 0 ) &&
435 ( *action_param < available_sizes ) &&
436 ( dimension_tbl[*action_param].supported )) {
437 next_menu_id = MENU_ID_MAIN;
438 }
439 else {
440 next_menu_id = current_menu_id;
441 }
442 break;
443
444 case MENU_ID_SENSORS:
445 next_menu_id = MENU_ID_MAIN;
446 *action_id_ptr = ACTION_SWITCH_CAMERA;
447 *action_param = output_to_event;
448 break;
449
450 case MENU_ID_WHITEBALANCECHANGE:
451 printf("MENU_ID_WHITEBALANCECHANGE\n");
452 if (output_to_event >= WB_MAX) {
453 next_menu_id = current_menu_id;
454 * action_id_ptr = ACTION_NO_ACTION;
455 } else {
456 next_menu_id = MENU_ID_MAIN;
457 * action_id_ptr = ACTION_SET_WHITE_BALANCE;
458 * action_param = output_to_event;
459 }
460 break;
461
462 case MENU_ID_EXPMETERINGCHANGE:
463 printf("MENU_ID_EXPMETERINGCHANGE\n");
464 if (output_to_event >= AUTO_EXP_MAX) {
465 next_menu_id = current_menu_id;
466 * action_id_ptr = ACTION_NO_ACTION;
467 } else {
468 next_menu_id = MENU_ID_MAIN;
469 * action_id_ptr = ACTION_SET_EXP_METERING;
470 * action_param = output_to_event;
471 }
472 break;
473
474 case MENU_ID_GET_CTRL_VALUE:
475 printf("MENU_ID_GET_CTRL_VALUE\n");
476 * action_id_ptr = ACTION_GET_CTRL_VALUE;
477 if (output_to_event > 0 &&
478 output_to_event <= (int)(sizeof(get_ctrl_tbl)/sizeof(get_ctrl_tbl[0]))) {
479 next_menu_id = MENU_ID_MAIN;
480 * action_param = output_to_event;
481 }
482 else {
483 next_menu_id = current_menu_id;
484 }
485 break;
486
487 case MENU_ID_BRIGHTNESSCHANGE:
488 switch (output_to_event) {
489 case INC_BRIGHTNESS:
490 * action_id_ptr = ACTION_BRIGHTNESS_INCREASE;
491 next_menu_id = MENU_ID_MAIN;
492 break;
493
494 case DEC_BRIGHTNESS:
495 * action_id_ptr = ACTION_BRIGHTNESS_DECREASE;
496 next_menu_id = MENU_ID_MAIN;
497 break;
498
499 default:
500 next_menu_id = MENU_ID_BRIGHTNESSCHANGE;
501 break;
502 }
503 break;
504
505 case MENU_ID_CONTRASTCHANGE:
506 switch (output_to_event) {
507 case INC_CONTRAST:
508 * action_id_ptr = ACTION_CONTRAST_INCREASE;
509 next_menu_id = MENU_ID_MAIN;
510 break;
511
512 case DEC_CONTRAST:
513 * action_id_ptr = ACTION_CONTRAST_DECREASE;
514 next_menu_id = MENU_ID_MAIN;
515 break;
516
517 default:
518 next_menu_id = MENU_ID_CONTRASTCHANGE;
519 break;
520 }
521 break;
522
523 case MENU_ID_EVCHANGE:
524 switch (output_to_event) {
525 case INCREASE_EV:
526 * action_id_ptr = ACTION_EV_INCREASE;
527 next_menu_id = MENU_ID_MAIN;
528 break;
529
530 case DECREASE_EV:
531 * action_id_ptr = ACTION_EV_DECREASE;
532 next_menu_id = MENU_ID_MAIN;
533 break;
534
535 default:
536 next_menu_id = MENU_ID_EVCHANGE;
537 break;
538 }
539 break;
540
541 case MENU_ID_SATURATIONCHANGE:
542 switch (output_to_event) {
543 case INC_SATURATION:
544 * action_id_ptr = ACTION_SATURATION_INCREASE;
545 next_menu_id = MENU_ID_MAIN;
546 break;
547
548 case DEC_SATURATION:
549 * action_id_ptr = ACTION_SATURATION_DECREASE;
550 next_menu_id = MENU_ID_MAIN;
551 break;
552
553 default:
554 next_menu_id = MENU_ID_EVCHANGE;
555 break;
556 }
557 break;
558
559 case MENU_ID_ISOCHANGE:
560 printf("MENU_ID_ISOCHANGE\n");
561 if (output_to_event >= ISO_MAX) {
562 next_menu_id = current_menu_id;
563 * action_id_ptr = ACTION_NO_ACTION;
564 } else {
565 next_menu_id = MENU_ID_MAIN;
566 * action_id_ptr = ACTION_SET_ISO;
567 * action_param = output_to_event;
568 }
569 break;
570
571 case MENU_ID_ZOOMCHANGE:
572 * action_id_ptr = ACTION_SET_ZOOM;
573 if (output_to_event > 0 &&
574 output_to_event <= (int)(sizeof(zoom_tbl)/sizeof(zoom_tbl[0]))) {
575 next_menu_id = MENU_ID_MAIN;
576 * action_param = output_to_event;
577 } else {
578 next_menu_id = current_menu_id;
579 }
580 break;
581
582 case MENU_ID_SHARPNESSCHANGE:
583 switch (output_to_event) {
584 case INC_SHARPNESS:
585 * action_id_ptr = ACTION_SHARPNESS_INCREASE;
586 next_menu_id = MENU_ID_MAIN;
587 break;
588 case DEC_SHARPNESS:
589 * action_id_ptr = ACTION_SHARPNESS_DECREASE;
590 next_menu_id = MENU_ID_MAIN;
591 break;
592 default:
593 next_menu_id = MENU_ID_SHARPNESSCHANGE;
594 break;
595 }
596 break;
597
598 case MENU_ID_BESTSHOT:
599 if (output_to_event >= BESTSHOT_MAX) {
600 next_menu_id = current_menu_id;
601 * action_id_ptr = ACTION_NO_ACTION;
602 } else {
603 next_menu_id = MENU_ID_MAIN;
604 * action_id_ptr = ACTION_SET_BESTSHOT_MODE;
605 * action_param = output_to_event;
606 }
607 break;
608
609 case MENU_ID_FLASHMODE:
610 if (output_to_event >= FLASH_MODE_MAX) {
611 next_menu_id = current_menu_id;
612 * action_id_ptr = ACTION_NO_ACTION;
613 } else {
614 next_menu_id = MENU_ID_MAIN;
615 * action_id_ptr = ACTION_SET_FLASH_MODE;
616 * action_param = output_to_event;
617 }
618 break;
619
620 default:
621 CDBG("menu id is wrong: %d\n", current_menu_id);
622 break;
623 }
624
625 return next_menu_id;
626 }
627
628 /*===========================================================================
629 * FUNCTION - print_menu_preview_video -
630 *
631 * DESCRIPTION:
632 * ===========================================================================*/
print_menu_preview_video(void)633 static void print_menu_preview_video(void) {
634 unsigned int i;
635 if (!is_rec) {
636 printf("\n");
637 printf("===========================================\n");
638 printf(" Camera is in preview/video mode now \n");
639 printf("===========================================\n\n");
640 } else {
641 printf("\n");
642 printf("===========================================\n");
643 printf(" Camera is in RECORDING mode now \n");
644 printf(" Press 'Q' To Stop Recording \n");
645 printf(" Press 'S' To Take Live Snapshot \n");
646 printf("===========================================\n\n");
647 }
648 char menuNum = 'A';
649 for (i = 0; i < sizeof(camera_main_menu_tbl)/sizeof(camera_main_menu_tbl[0]); i++) {
650 if (i == BASE_OFFSET) {
651 menuNum = '1';
652 }
653
654 printf("%c. %s\n", menuNum, camera_main_menu_tbl[i].menu_name);
655 menuNum++;
656 }
657
658 printf("\nPlease enter your choice: ");
659
660 return;
661 }
662
camera_preview_video_wb_change_tbl(void)663 static void camera_preview_video_wb_change_tbl(void) {
664 unsigned int i;
665 printf("\n");
666 printf("==========================================================\n");
667 printf(" Camera is in white balance change mode \n");
668 printf("==========================================================\n\n");
669
670 char submenuNum = 'A';
671 for (i = 0 ; i < sizeof(white_balance_tbl) /
672 sizeof(white_balance_tbl[0]); i++) {
673 printf("%c. %s\n", submenuNum, white_balance_tbl[i].wb_name);
674 submenuNum++;
675 }
676 printf("\nPlease enter your choice for White Balance modes: ");
677 return;
678 }
679
camera_preview_video_get_ctrl_value_tbl(void)680 static void camera_preview_video_get_ctrl_value_tbl(void) {
681 unsigned int i;
682 printf("\n");
683 printf("==========================================================\n");
684 printf(" Camera is in get control value mode \n");
685 printf("==========================================================\n\n");
686
687 char submenuNum = 'A';
688 for (i = 0 ; i < sizeof(get_ctrl_tbl) /
689 sizeof(get_ctrl_tbl[0]); i++) {
690 printf("%c. %s\n", submenuNum, get_ctrl_tbl[i].get_ctrl_name);
691 submenuNum++;
692 }
693 printf("\nPlease enter your choice for control value you want to get: ");
694 return;
695 }
696
camera_preview_video_exp_metering_change_tbl(void)697 static void camera_preview_video_exp_metering_change_tbl(void) {
698 unsigned int i;
699 printf("\n");
700 printf("==========================================================\n");
701 printf(" Camera is in exposure metering change mode \n");
702 printf("==========================================================\n\n");
703
704 char submenuNum = 'A';
705 for (i = 0 ; i < sizeof(exp_metering_tbl) /
706 sizeof(exp_metering_tbl[0]); i++) {
707 printf("%c. %s\n", submenuNum, exp_metering_tbl[i].exp_metering_name);
708 submenuNum++;
709 }
710 printf("\nPlease enter your choice for exposure metering modes: ");
711 return;
712 }
713
camera_contrast_change_tbl(void)714 static void camera_contrast_change_tbl(void) {
715 unsigned int i;
716
717 printf("\n");
718 printf("==========================================================\n");
719 printf(" Camera is in change contrast resolution mode \n");
720 printf("==========================================================\n\n");
721
722 char contrastmenuNum = 'A';
723 for (i = 0; i < sizeof(contrast_change_tbl) /
724 sizeof(contrast_change_tbl[0]); i++) {
725 printf("%c. %s\n", contrastmenuNum,
726 contrast_change_tbl[i].contrast_name);
727 contrastmenuNum++;
728 }
729
730 printf("\nPlease enter your choice for contrast Change: ");
731 return;
732 }
733
camera_EV_change_tbl(void)734 static void camera_EV_change_tbl(void) {
735 unsigned int i;
736
737 printf("\n");
738 printf("===========================================\n");
739 printf(" Camera is in EV change mode now \n");
740 printf("===========================================\n\n");
741
742 char submenuNum = 'A';
743 for (i = 0; i < sizeof(camera_EV_tbl)/sizeof(camera_EV_tbl[0]); i++) {
744 printf("%c. %s\n", submenuNum, camera_EV_tbl[i].EV_name);
745 submenuNum++;
746 }
747
748 printf("\nPlease enter your choice for EV changes: ");
749 return;
750 }
751
camera_resolution_change_tbl(void)752 static void camera_resolution_change_tbl(void) {
753 unsigned int i;
754
755 printf("\n");
756 printf("==========================================================\n");
757 printf(" Camera is in snapshot resolution mode \n");
758 printf("==========================================================\n\n");
759
760 for (i = 0; i < sizeof(dimension_tbl) /
761 sizeof(dimension_tbl[0]); i++) {
762 if ( dimension_tbl[i].supported ) {
763 printf("%d. %s\n", i,
764 dimension_tbl[i].str_name);
765 }
766 }
767
768 printf("\nPlease enter your choice for Resolution: ");
769 return;
770 }
771
camera_preview_video_zoom_change_tbl(void)772 static void camera_preview_video_zoom_change_tbl(void) {
773 unsigned int i;
774 zoom_max_value = MAX_ZOOMS_CNT;
775 printf("\nCurrent Zoom Value = %d ,Max Zoom Value = %d\n",zoom_level,zoom_max_value);
776 char submenuNum = 'A';
777 for (i = 0 ; i < sizeof(zoom_tbl) /
778 sizeof(zoom_tbl[0]); i++) {
779 printf("%c. %s\n", submenuNum, zoom_tbl[i].zoom_direction_name);
780 submenuNum++;
781 }
782 printf("\nPlease enter your choice for zoom change direction: ");
783 return;
784 }
785
camera_brightness_change_tbl(void)786 static void camera_brightness_change_tbl(void) {
787 unsigned int i;
788
789 printf("\n");
790 printf("==========================================================\n");
791 printf(" Camera is in change brightness mode \n");
792 printf("==========================================================\n\n");
793
794 char brightnessmenuNum = 'A';
795 for (i = 0; i < sizeof(brightness_change_tbl) /
796 sizeof(brightness_change_tbl[0]); i++) {
797 printf("%c. %s\n", brightnessmenuNum,
798 brightness_change_tbl[i].brightness_name);
799 brightnessmenuNum++;
800 }
801
802 printf("\nPlease enter your choice for Brightness Change: ");
803 return;
804 }
805
camera_saturation_change_tbl(void)806 static void camera_saturation_change_tbl(void) {
807 unsigned int i;
808
809 printf("\n");
810 printf("==========================================================\n");
811 printf(" Camera is in change saturation mode \n");
812 printf("==========================================================\n\n");
813
814 char saturationmenuNum = 'A';
815 for (i = 0; i < sizeof(camera_saturation_tbl) /
816 sizeof(camera_saturation_tbl[0]); i++) {
817 printf("%c. %s\n", saturationmenuNum,
818 camera_saturation_tbl[i].saturation_name);
819 saturationmenuNum++;
820 }
821
822 printf("\nPlease enter your choice for Saturation Change: ");
823 return;
824 }
825
camera_preview_video_iso_change_tbl(void)826 static void camera_preview_video_iso_change_tbl(void) {
827 unsigned int i;
828 printf("\n");
829 printf("==========================================================\n");
830 printf(" Camera is in ISO change mode \n");
831 printf("==========================================================\n\n");
832
833 char submenuNum = 'A';
834 for (i = 0 ; i < sizeof(iso_tbl) /
835 sizeof(iso_tbl[0]); i++) {
836 printf("%c. %s\n", submenuNum, iso_tbl[i].iso_modes_name);
837 submenuNum++;
838 }
839 printf("\nPlease enter your choice for iso modes: ");
840 return;
841 }
842
camera_preview_video_sharpness_change_tbl(void)843 static void camera_preview_video_sharpness_change_tbl(void) {
844 unsigned int i;
845 printf("\n");
846 printf("==========================================================\n");
847 printf(" Camera is in sharpness change mode \n");
848 printf("==========================================================\n\n");
849
850 char submenuNum = 'A';
851 for (i = 0 ; i < sizeof(camera_sharpness_tbl) /
852 sizeof(camera_sharpness_tbl[0]); i++) {
853 printf("%c. %s\n", submenuNum, camera_sharpness_tbl[i].sharpness_name);
854 submenuNum++;
855 }
856 printf("\nPlease enter your choice for sharpness modes: ");
857 return;
858 }
859
camera_set_bestshot_tbl(void)860 static void camera_set_bestshot_tbl(void)
861 {
862 unsigned int i;
863
864 printf("\n");
865 printf("===========================================\n");
866 printf(" Camera is in set besthot mode now \n");
867 printf("===========================================\n\n");
868
869
870 char bsmenuNum = 'A';
871 for (i = 0; i < sizeof(bestshot_mode_tbl)/sizeof(bestshot_mode_tbl[0]); i++) {
872 printf("%c. %s\n", bsmenuNum,
873 bestshot_mode_tbl[i].name);
874 bsmenuNum++;
875 }
876
877 printf("\nPlease enter your choice of Bestshot Mode: ");
878 return;
879 }
880
camera_set_flashmode_tbl(void)881 static void camera_set_flashmode_tbl(void)
882 {
883 unsigned int i;
884
885 printf("\n");
886 printf("===========================================\n");
887 printf(" Camera is in set flash mode now \n");
888 printf("===========================================\n\n");
889
890
891 char bsmenuNum = 'A';
892 for (i = 0; i < sizeof(flashmodes_tbl)/sizeof(flashmodes_tbl[0]); i++) {
893 printf("%c. %s\n", bsmenuNum,
894 flashmodes_tbl[i].name);
895 bsmenuNum++;
896 }
897
898 printf("\nPlease enter your choice of Bestshot Mode: ");
899 return;
900 }
901
camera_sensors_tbl(void)902 static void camera_sensors_tbl(void)
903 {
904 unsigned int i;
905 size_t available_sensors = sizeof(sensor_tbl)/sizeof(sensor_tbl[0]);
906
907 printf("\n");
908 printf("===========================================\n");
909 printf(" Camera Sensor to be used: \n");
910 printf("===========================================\n\n");
911
912
913 char bsmenuNum = 'A';
914 for (i = 0; ( i < available_sensors ) && ( sensor_tbl[i].present ) ; i++) {
915 printf("%c. %s\n", bsmenuNum,
916 sensor_tbl[i].menu_name);
917 bsmenuNum++;
918 }
919
920 printf("\nPlease enter your choice for sensor: ");
921 return;
922 }
923
924 /*===========================================================================
925 * FUNCTION - increase_contrast -
926 *
927 * DESCRIPTION:
928 * ===========================================================================*/
increase_contrast(mm_camera_lib_handle * lib_handle)929 int increase_contrast (mm_camera_lib_handle *lib_handle) {
930 contrast += CAMERA_CONTRAST_STEP;
931 if (contrast > CAMERA_MAX_CONTRAST) {
932 contrast = CAMERA_MAX_CONTRAST;
933 printf("Reached max CONTRAST. \n");
934 }
935 printf("Increase Contrast to %d\n", contrast);
936 return mm_camera_lib_send_command(lib_handle,
937 MM_CAMERA_LIB_CONTRAST,
938 &contrast,
939 NULL);
940 }
941
942 /*===========================================================================
943 * FUNCTION - decrease_contrast -
944 *
945 * DESCRIPTION:
946 * ===========================================================================*/
decrease_contrast(mm_camera_lib_handle * lib_handle)947 int decrease_contrast (mm_camera_lib_handle *lib_handle) {
948 contrast -= CAMERA_CONTRAST_STEP;
949 if (contrast < CAMERA_MIN_CONTRAST) {
950 contrast = CAMERA_MIN_CONTRAST;
951 printf("Reached min CONTRAST. \n");
952 }
953 printf("Decrease Contrast to %d\n", contrast);
954 return mm_camera_lib_send_command(lib_handle,
955 MM_CAMERA_LIB_CONTRAST,
956 &contrast,
957 NULL);
958 }
959
960 /*===========================================================================
961 * FUNCTION - decrease_brightness -
962 *
963 * DESCRIPTION:
964 * ===========================================================================*/
decrease_brightness(mm_camera_lib_handle * lib_handle)965 int decrease_brightness (mm_camera_lib_handle *lib_handle) {
966 brightness -= CAMERA_BRIGHTNESS_STEP;
967 if (brightness < CAMERA_MIN_BRIGHTNESS) {
968 brightness = CAMERA_MIN_BRIGHTNESS;
969 printf("Reached min BRIGHTNESS. \n");
970 }
971 printf("Decrease Brightness to %d\n", brightness);
972 return mm_camera_lib_send_command(lib_handle,
973 MM_CAMERA_LIB_BRIGHTNESS,
974 &brightness,
975 NULL);
976 }
977
978 /*===========================================================================
979 * FUNCTION - increase_brightness -
980 *
981 * DESCRIPTION:
982 * ===========================================================================*/
increase_brightness(mm_camera_lib_handle * lib_handle)983 int increase_brightness (mm_camera_lib_handle *lib_handle) {
984 brightness += CAMERA_BRIGHTNESS_STEP;
985 if (brightness > CAMERA_MAX_BRIGHTNESS) {
986 brightness = CAMERA_MAX_BRIGHTNESS;
987 printf("Reached max BRIGHTNESS. \n");
988 }
989 printf("Increase Brightness to %d\n", brightness);
990 return mm_camera_lib_send_command(lib_handle,
991 MM_CAMERA_LIB_BRIGHTNESS,
992 &brightness,
993 NULL);
994 }
995
996 /*===========================================================================
997 * FUNCTION - increase_EV -
998 *
999 * DESCRIPTION:
1000 * ===========================================================================*/
1001
increase_EV(void)1002 int increase_EV (void) {
1003 #if 0
1004 int rc = 0;
1005 int32_t value = 0;
1006 rc = cam_config_is_parm_supported(cam_id, MM_CAMERA_PARM_EXPOSURE_COMPENSATION);
1007 if(!rc) {
1008 printf("MM_CAMERA_PARM_EXPOSURE_COMPENSATION mode is not supported for this sensor");
1009 return -1;
1010 }
1011 ev_numerator += 1;
1012 if(ev_numerator >= EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR &&
1013 ev_numerator <= EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR){
1014 int16_t numerator16 = (int16_t)(ev_numerator & 0x0000ffff);
1015 uint16_t denominator16 = EXPOSURE_COMPENSATION_DENOMINATOR;
1016 value = numerator16 << 16 | denominator16;
1017 } else {
1018 printf("Reached max EV.\n");
1019 }
1020 return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_EXPOSURE_COMPENSATION, value);
1021 #endif
1022 return 0;
1023 }
1024
1025 /*===========================================================================
1026 * FUNCTION - decrease_EV -
1027 *
1028 * DESCRIPTION:
1029 * ===========================================================================*/
decrease_EV(void)1030 int decrease_EV (void) {
1031 #if 0
1032 int rc = 0;
1033 int32_t value = 0;
1034 rc = cam_config_is_parm_supported(cam_id, MM_CAMERA_PARM_EXPOSURE_COMPENSATION);
1035 if(!rc) {
1036 printf("MM_CAMERA_PARM_EXPOSURE_COMPENSATION mode is not supported for this sensor");
1037 return -1;
1038 }
1039 ev_numerator -= 1;
1040 if(ev_numerator >= EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR &&
1041 ev_numerator <= EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR){
1042 int16_t numerator16 = (int16_t)(ev_numerator & 0x0000ffff);
1043 uint16_t denominator16 = EXPOSURE_COMPENSATION_DENOMINATOR;
1044 value = numerator16 << 16 | denominator16;
1045 } else {
1046 printf("Reached min EV.\n");
1047 }
1048 return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_EXPOSURE_COMPENSATION, value);
1049 #endif
1050 return 0;
1051 }
1052
1053 /*===========================================================================
1054 * FUNCTION - increase_saturation -
1055 *
1056 * DESCRIPTION:
1057 * ===========================================================================*/
increase_saturation(mm_camera_lib_handle * lib_handle)1058 int increase_saturation (mm_camera_lib_handle *lib_handle) {
1059 #if 0
1060 saturation += CAMERA_SATURATION_STEP;
1061 if (saturation > CAMERA_MAX_SATURATION) {
1062 saturation = CAMERA_MAX_SATURATION;
1063 printf("Reached max saturation. \n");
1064 }
1065 printf("Increase Saturation to %d\n", saturation);
1066 return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_SATURATION, saturation);
1067 #endif
1068 saturation += CAMERA_SATURATION_STEP;
1069 if (saturation > CAMERA_MAX_SATURATION) {
1070 saturation = CAMERA_MAX_SATURATION;
1071 printf("Reached max saturation. \n");
1072 }
1073 printf("Increase saturation to %d\n", contrast);
1074 return mm_camera_lib_send_command(lib_handle,
1075 MM_CAMERA_LIB_SATURATION,
1076 &saturation,
1077 NULL);
1078 }
1079
1080 /*===========================================================================
1081 * FUNCTION - decrease_saturation -
1082 *
1083 * DESCRIPTION:
1084 * ===========================================================================*/
decrease_saturation(mm_camera_lib_handle * lib_handle)1085 int decrease_saturation (mm_camera_lib_handle *lib_handle) {
1086 #if 0
1087 saturation -= CAMERA_SATURATION_STEP;
1088 if (saturation < CAMERA_MIN_SATURATION) {
1089 saturation = CAMERA_MIN_SATURATION;
1090 printf("Reached min saturation. \n");
1091 }
1092 printf("Dcrease Saturation to %d\n", saturation);
1093 return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_SATURATION, saturation);
1094 #endif
1095 saturation -= CAMERA_SATURATION_STEP;
1096 if (saturation < CAMERA_MIN_SATURATION) {
1097 saturation = CAMERA_MIN_SATURATION;
1098 printf("Reached min saturation. \n");
1099 }
1100 printf("decrease saturation to %d\n", contrast);
1101 return mm_camera_lib_send_command(lib_handle,
1102 MM_CAMERA_LIB_SATURATION,
1103 &saturation,
1104 NULL);
1105 }
1106
1107
take_jpeg_snapshot(mm_camera_test_obj_t * test_obj,int is_burst_mode)1108 int take_jpeg_snapshot(mm_camera_test_obj_t *test_obj, int is_burst_mode)
1109 {
1110 CDBG_HIGH("\nEnter take_jpeg_snapshot!!\n");
1111 int rc = mm_app_take_picture (test_obj, (uint8_t)is_burst_mode);
1112 if (MM_CAMERA_OK != rc) {
1113 CDBG_ERROR("%s: mm_app_take_picture() err=%d\n", __func__, rc);
1114 }
1115 return rc;
1116 }
1117
1118 /*===========================================================================
1119 * FUNCTION - main -
1120 *
1121 * DESCRIPTION:
1122 *==========================================================================*/
main()1123 int main()
1124 {
1125 char tc_buf[3];
1126 int mode = 0;
1127 int rc = 0;
1128
1129 printf("Please Select Execution Mode:\n");
1130 printf("0: Menu Based 1: Regression\n");
1131 fgets(tc_buf, 3, stdin);
1132 mode = tc_buf[0] - '0';
1133 if(mode == 0) {
1134 printf("\nStarting Menu based!!\n");
1135 } else if(mode == 1) {
1136 printf("Starting Regression testing!!\n");
1137 if(!mm_app_start_regression_test(1)) {
1138 printf("\nRegressiion test passed!!\n");
1139 return 0;
1140 } else {
1141 printf("\nRegression test failed!!\n");
1142 exit(-1);
1143 }
1144 } else {
1145 printf("\nPlease Enter 0 or 1\n");
1146 printf("\nExisting the App!!\n");
1147 exit(-1);
1148 }
1149
1150
1151 rc = submain();
1152
1153 printf("Exiting application\n");
1154
1155 return rc;
1156 }
1157
1158 /*===========================================================================
1159 * FUNCTION - set_whitebalance -
1160 *
1161 * DESCRIPTION:
1162 * ===========================================================================*/
set_whitebalance(mm_camera_lib_handle * lib_handle,int wb_action_param)1163 int set_whitebalance (mm_camera_lib_handle *lib_handle, int wb_action_param) {
1164 cam_wb_mode_type type = 0;
1165 switch (wb_action_param) {
1166 case WB_AUTO:
1167 printf("\n WB_AUTO\n");
1168 type = CAM_WB_MODE_AUTO;
1169 break;
1170 case WB_INCANDESCENT:
1171 printf("\n WB_INCANDESCENT\n");
1172 type = CAM_WB_MODE_INCANDESCENT;
1173 break;
1174 case WB_FLUORESCENT:
1175 printf("\n WB_FLUORESCENT\n");
1176 type = CAM_WB_MODE_FLUORESCENT;
1177 break;
1178 case WB_WARM_FLUORESCENT:
1179 printf("\n WB_WARM_FLUORESCENT\n");
1180 type = CAM_WB_MODE_WARM_FLUORESCENT;
1181 break;
1182 case WB_DAYLIGHT:
1183 printf("\n WB_DAYLIGHT\n");
1184 type = CAM_WB_MODE_DAYLIGHT;
1185 break;
1186 case WB_CLOUDY_DAYLIGHT:
1187 printf("\n WB_CLOUDY_DAYLIGHT\n");
1188 type = CAM_WB_MODE_CLOUDY_DAYLIGHT;
1189 break;
1190 case WB_TWILIGHT:
1191 printf("\n WB_TWILIGHT\n");
1192 type = CAM_WB_MODE_TWILIGHT;
1193 break;
1194 case WB_SHADE:
1195 printf("\n WB_SHADE\n");
1196 type = CAM_WB_MODE_SHADE;
1197 break;
1198 default:
1199 break;
1200 }
1201 return mm_camera_lib_send_command(lib_handle,
1202 MM_CAMERA_LIB_WB,
1203 &type,
1204 NULL);
1205 }
1206
1207
1208 /*===========================================================================
1209 * FUNCTION - set_exp_metering -
1210 *
1211 * DESCRIPTION:
1212 * ===========================================================================*/
set_exp_metering(mm_camera_lib_handle * lib_handle,int exp_metering_action_param)1213 int set_exp_metering (mm_camera_lib_handle *lib_handle, int exp_metering_action_param) {
1214 cam_auto_exposure_mode_type type = 0;
1215 switch (exp_metering_action_param) {
1216 case AUTO_EXP_FRAME_AVG:
1217 printf("\nAUTO_EXP_FRAME_AVG\n");
1218 type = CAM_AEC_MODE_FRAME_AVERAGE;
1219 break;
1220 case AUTO_EXP_CENTER_WEIGHTED:
1221 printf("\n AUTO_EXP_CENTER_WEIGHTED\n");
1222 type = CAM_AEC_MODE_CENTER_WEIGHTED;
1223 break;
1224 case AUTO_EXP_SPOT_METERING:
1225 printf("\n AUTO_EXP_SPOT_METERING\n");
1226 type = CAM_AEC_MODE_SPOT_METERING;
1227 break;
1228 case AUTO_EXP_SMART_METERING:
1229 printf("\n AUTO_EXP_SMART_METERING\n");
1230 type = CAM_AEC_MODE_SMART_METERING;
1231 break;
1232 case AUTO_EXP_USER_METERING:
1233 printf("\n AUTO_EXP_USER_METERING\n");
1234 type = CAM_AEC_MODE_USER_METERING;
1235 break;
1236 case AUTO_EXP_SPOT_METERING_ADV:
1237 printf("\n AUTO_EXP_SPOT_METERING_ADV\n");
1238 type = CAM_AEC_MODE_SPOT_METERING_ADV;
1239 break;
1240 case AUTO_EXP_CENTER_WEIGHTED_ADV:
1241 printf("\n AUTO_EXP_CENTER_WEIGHTED_ADV\n");
1242 type = CAM_AEC_MODE_CENTER_WEIGHTED_ADV;
1243 break;
1244 default:
1245 break;
1246 }
1247 return mm_camera_lib_send_command(lib_handle,
1248 MM_CAMERA_LIB_EXPOSURE_METERING,
1249 &type,
1250 NULL);
1251 }
1252
get_ctrl_value(int ctrl_value_mode_param)1253 int get_ctrl_value (int ctrl_value_mode_param){
1254 #if 0
1255 int rc = 0;
1256 struct v4l2_control ctrl;
1257
1258 if (ctrl_value_mode_param == WHITE_BALANCE_STATE) {
1259 printf("You chose WHITE_BALANCE_STATE\n");
1260 ctrl.id = V4L2_CID_AUTO_WHITE_BALANCE;
1261 }
1262 else if (ctrl_value_mode_param == WHITE_BALANCE_TEMPERATURE) {
1263 printf("You chose WHITE_BALANCE_TEMPERATURE\n");
1264 ctrl.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
1265 }
1266 else if (ctrl_value_mode_param == BRIGHTNESS_CTRL) {
1267 printf("You chose brightness value\n");
1268 ctrl.id = V4L2_CID_BRIGHTNESS;
1269 }
1270 else if (ctrl_value_mode_param == EV) {
1271 printf("You chose exposure value\n");
1272 ctrl.id = V4L2_CID_EXPOSURE;
1273 }
1274 else if (ctrl_value_mode_param == CONTRAST_CTRL) {
1275 printf("You chose contrast value\n");
1276 ctrl.id = V4L2_CID_CONTRAST;
1277 }
1278 else if (ctrl_value_mode_param == SATURATION_CTRL) {
1279 printf("You chose saturation value\n");
1280 ctrl.id = V4L2_CID_SATURATION;
1281 } else if (ctrl_value_mode_param == SHARPNESS_CTRL) {
1282 printf("You chose sharpness value\n");
1283 ctrl.id = V4L2_CID_SHARPNESS;
1284 }
1285
1286 // rc = ioctl(camfd, VIDIOC_G_CTRL, &ctrl);
1287 return rc;
1288 #endif
1289 return ctrl_value_mode_param;
1290 }
1291
1292 /*===========================================================================
1293 * FUNCTION - toggle_afr -
1294 *
1295 * DESCRIPTION:
1296 * ===========================================================================*/
toggle_afr()1297 int toggle_afr () {
1298 #if 0
1299 if (fps_mode == FPS_MODE_AUTO) {
1300 printf("\nSetting FPS_MODE_FIXED\n");
1301 fps_mode = FPS_MODE_FIXED;
1302 } else {
1303 printf("\nSetting FPS_MODE_AUTO\n");
1304 fps_mode = FPS_MODE_AUTO;
1305 }
1306 return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_FPS_MODE, fps_mode);
1307 #endif
1308 return 0;
1309 }
1310
set_zoom(mm_camera_lib_handle * lib_handle,int zoom_action_param)1311 int set_zoom (mm_camera_lib_handle *lib_handle, int zoom_action_param) {
1312
1313 if (zoom_action_param == ZOOM_IN) {
1314 zoom_level += ZOOM_STEP;
1315 if (zoom_level > zoom_max_value)
1316 zoom_level = zoom_max_value;
1317 } else if (zoom_action_param == ZOOM_OUT) {
1318 zoom_level -= ZOOM_STEP;
1319 if (zoom_level < ZOOM_MIN_VALUE)
1320 zoom_level = ZOOM_MIN_VALUE;
1321 } else {
1322 CDBG("%s: Invalid zoom_action_param value\n", __func__);
1323 return -EINVAL;
1324 }
1325 return mm_camera_lib_send_command(lib_handle,
1326 MM_CAMERA_LIB_ZOOM,
1327 &zoom_level,
1328 NULL);
1329 }
1330
1331 /*===========================================================================
1332 * FUNCTION - set_iso -
1333 *
1334 * DESCRIPTION:
1335 * ===========================================================================*/
set_iso(mm_camera_lib_handle * lib_handle,int iso_action_param)1336 int set_iso (mm_camera_lib_handle *lib_handle, int iso_action_param) {
1337 cam_iso_mode_type type = 0;
1338 switch (iso_action_param) {
1339 case ISO_AUTO:
1340 printf("\n ISO_AUTO\n");
1341 type = CAM_ISO_MODE_AUTO;
1342 break;
1343 case ISO_DEBLUR:
1344 printf("\n ISO_DEBLUR\n");
1345 type = CAM_ISO_MODE_DEBLUR;
1346 break;
1347 case ISO_100:
1348 printf("\n ISO_100\n");
1349 type = CAM_ISO_MODE_100;
1350 break;
1351 case ISO_200:
1352 printf("\n ISO_200\n");
1353 type = CAM_ISO_MODE_200;
1354 break;
1355 case ISO_400:
1356 printf("\n ISO_400\n");
1357 type = CAM_ISO_MODE_400;
1358 break;
1359 case ISO_800:
1360 printf("\n ISO_800\n");
1361 type = CAM_ISO_MODE_800;
1362 break;
1363 case ISO_1600:
1364 printf("\n ISO_1600\n");
1365 type = CAM_ISO_MODE_1600;
1366 break;
1367 default:
1368 break;
1369 }
1370 return mm_camera_lib_send_command(lib_handle,
1371 MM_CAMERA_LIB_ISO,
1372 &type,
1373 NULL);
1374 }
1375
1376 /*===========================================================================
1377 * FUNCTION - increase_sharpness -
1378 *
1379 * DESCRIPTION:
1380 * ===========================================================================*/
increase_sharpness(mm_camera_lib_handle * lib_handle)1381 int increase_sharpness (mm_camera_lib_handle *lib_handle) {
1382 sharpness += CAMERA_SHARPNESS_STEP;
1383 if (sharpness > CAMERA_MAX_SHARPNESS) {
1384 sharpness = CAMERA_MAX_SHARPNESS;
1385 printf("Reached max SHARPNESS. \n");
1386 }
1387 printf("Increase Sharpness to %d\n", sharpness);
1388 return mm_camera_lib_send_command(lib_handle,
1389 MM_CAMERA_LIB_SHARPNESS,
1390 &sharpness,
1391 NULL);
1392 }
1393
1394 /*===========================================================================
1395 * FUNCTION - decrease_sharpness -
1396 *
1397 * DESCRIPTION:
1398 * ===========================================================================*/
decrease_sharpness(mm_camera_lib_handle * lib_handle)1399 int decrease_sharpness (mm_camera_lib_handle *lib_handle) {
1400 sharpness -= CAMERA_SHARPNESS_STEP;
1401 if (sharpness < CAMERA_MIN_SHARPNESS) {
1402 sharpness = CAMERA_MIN_SHARPNESS;
1403 printf("Reached min SHARPNESS. \n");
1404 }
1405 printf("Decrease Sharpness to %d\n", sharpness);
1406 return mm_camera_lib_send_command(lib_handle,
1407 MM_CAMERA_LIB_SHARPNESS,
1408 &sharpness,
1409 NULL);
1410 }
1411
set_flash_mode(mm_camera_lib_handle * lib_handle,int action_param)1412 int set_flash_mode (mm_camera_lib_handle *lib_handle, int action_param) {
1413 cam_flash_mode_t type = 0;
1414 switch (action_param) {
1415 case FLASH_MODE_OFF:
1416 printf("\n FLASH_MODE_OFF\n");
1417 type = CAM_FLASH_MODE_OFF;
1418 break;
1419 case FLASH_MODE_AUTO:
1420 printf("\n FLASH_MODE_AUTO\n");
1421 type = CAM_FLASH_MODE_AUTO;
1422 break;
1423 case FLASH_MODE_ON:
1424 printf("\n FLASH_MODE_ON\n");
1425 type = CAM_FLASH_MODE_ON;
1426 break;
1427 case FLASH_MODE_TORCH:
1428 printf("\n FLASH_MODE_TORCH\n");
1429 type = CAM_ISO_MODE_100;
1430 break;
1431 default:
1432 break;
1433 }
1434 return mm_camera_lib_send_command(lib_handle,
1435 MM_CAMERA_LIB_FLASH,
1436 &type,
1437 NULL);
1438 }
1439
set_bestshot_mode(mm_camera_lib_handle * lib_handle,int action_param)1440 int set_bestshot_mode(mm_camera_lib_handle *lib_handle, int action_param) {
1441 cam_scene_mode_type type = 0;
1442 switch (action_param) {
1443 case BESTSHOT_AUTO:
1444 printf("\n BEST SHOT AUTO\n");
1445 type = CAM_SCENE_MODE_OFF;
1446 break;
1447 case BESTSHOT_ACTION:
1448 printf("\n BEST SHOT ACTION\n");
1449 type = CAM_SCENE_MODE_ACTION;
1450 break;
1451 case BESTSHOT_PORTRAIT:
1452 printf("\n BEST SHOT PORTRAIT\n");
1453 type = CAM_SCENE_MODE_PORTRAIT;
1454 break;
1455 case BESTSHOT_LANDSCAPE:
1456 printf("\n BEST SHOT LANDSCAPE\n");
1457 type = CAM_SCENE_MODE_LANDSCAPE;
1458 break;
1459 case BESTSHOT_NIGHT:
1460 printf("\n BEST SHOT NIGHT\n");
1461 type = CAM_SCENE_MODE_NIGHT;
1462 break;
1463 case BESTSHOT_NIGHT_PORTRAIT:
1464 printf("\n BEST SHOT NIGHT PORTRAIT\n");
1465 type = CAM_SCENE_MODE_NIGHT_PORTRAIT;
1466 break;
1467 case BESTSHOT_THEATRE:
1468 printf("\n BEST SHOT THREATRE\n");
1469 type = CAM_SCENE_MODE_THEATRE;
1470 break;
1471 case BESTSHOT_BEACH:
1472 printf("\n BEST SHOT BEACH\n");
1473 type = CAM_SCENE_MODE_BEACH;
1474 break;
1475 case BESTSHOT_SNOW:
1476 printf("\n BEST SHOT SNOW\n");
1477 type = CAM_SCENE_MODE_SNOW;
1478 break;
1479 case BESTSHOT_SUNSET:
1480 printf("\n BEST SHOT SUNSET\n");
1481 type = CAM_SCENE_MODE_SUNSET;
1482 break;
1483 case BESTSHOT_ANTISHAKE:
1484 printf("\n BEST SHOT ANTISHAKE\n");
1485 type = CAM_SCENE_MODE_ANTISHAKE;
1486 break;
1487 case BESTSHOT_FIREWORKS:
1488 printf("\n BEST SHOT FIREWORKS\n");
1489 type = CAM_SCENE_MODE_FIREWORKS;
1490 break;
1491 case BESTSHOT_SPORTS:
1492 printf("\n BEST SHOT SPORTS\n");
1493 type = CAM_SCENE_MODE_SPORTS;
1494 break;
1495 case BESTSHOT_PARTY:
1496 printf("\n BEST SHOT PARTY\n");
1497 type = CAM_SCENE_MODE_PARTY;
1498 break;
1499 case BESTSHOT_CANDLELIGHT:
1500 printf("\n BEST SHOT CANDLELIGHT\n");
1501 type = CAM_SCENE_MODE_CANDLELIGHT;
1502 break;
1503 case BESTSHOT_ASD:
1504 printf("\n BEST SHOT ASD\n");
1505 type = CAM_SCENE_MODE_AUTO;
1506 break;
1507 case BESTSHOT_BACKLIGHT:
1508 printf("\n BEST SHOT BACKLIGHT\n");
1509 type = CAM_SCENE_MODE_BACKLIGHT;
1510 break;
1511 case BESTSHOT_FLOWERS:
1512 printf("\n BEST SHOT FLOWERS\n");
1513 type = CAM_SCENE_MODE_FLOWERS;
1514 break;
1515 case BESTSHOT_AR:
1516 printf("\n BEST SHOT AR\n");
1517 type = CAM_SCENE_MODE_AR;
1518 break;
1519 case BESTSHOT_HDR:
1520 printf("\n BEST SHOT HDR\n");
1521 type = CAM_SCENE_MODE_OFF;
1522 break;
1523 default:
1524 break;
1525 }
1526 return mm_camera_lib_send_command(lib_handle,
1527 MM_CAMERA_LIB_BESTSHOT,
1528 &type,
1529 NULL);
1530 }
1531 /*===========================================================================
1532 * FUNCTION - print_current_menu -
1533 *
1534 * DESCRIPTION:
1535 * ===========================================================================*/
print_current_menu(menu_id_change_t current_menu_id)1536 int print_current_menu (menu_id_change_t current_menu_id) {
1537 if (current_menu_id == MENU_ID_MAIN) {
1538 print_menu_preview_video ();
1539 } else if (current_menu_id == MENU_ID_WHITEBALANCECHANGE) {
1540 camera_preview_video_wb_change_tbl();
1541 } else if (current_menu_id == MENU_ID_EXPMETERINGCHANGE) {
1542 camera_preview_video_exp_metering_change_tbl();
1543 } else if (current_menu_id == MENU_ID_GET_CTRL_VALUE) {
1544 camera_preview_video_get_ctrl_value_tbl();
1545 } else if (current_menu_id == MENU_ID_ISOCHANGE) {
1546 camera_preview_video_iso_change_tbl();
1547 } else if (current_menu_id == MENU_ID_BRIGHTNESSCHANGE) {
1548 camera_brightness_change_tbl ();
1549 } else if (current_menu_id == MENU_ID_CONTRASTCHANGE) {
1550 camera_contrast_change_tbl ();
1551 } else if (current_menu_id == MENU_ID_EVCHANGE) {
1552 camera_EV_change_tbl ();
1553 } else if (current_menu_id == MENU_ID_SATURATIONCHANGE) {
1554 camera_saturation_change_tbl ();
1555 } else if (current_menu_id == MENU_ID_ZOOMCHANGE) {
1556 camera_preview_video_zoom_change_tbl();
1557 } else if (current_menu_id == MENU_ID_SHARPNESSCHANGE) {
1558 camera_preview_video_sharpness_change_tbl();
1559 } else if (current_menu_id == MENU_ID_BESTSHOT) {
1560 camera_set_bestshot_tbl();
1561 } else if (current_menu_id == MENU_ID_FLASHMODE) {
1562 camera_set_flashmode_tbl();
1563 } else if (current_menu_id == MENU_ID_SENSORS ) {
1564 camera_sensors_tbl();
1565 } else if (current_menu_id == MENU_ID_SWITCH_RES ) {
1566 camera_resolution_change_tbl();
1567 }
1568
1569 return 0;
1570 }
1571
filter_resolutions(mm_camera_lib_handle * lib_handle,DIMENSION_TBL_T * tbl,size_t tbl_size)1572 int filter_resolutions(mm_camera_lib_handle *lib_handle,
1573 DIMENSION_TBL_T *tbl,
1574 size_t tbl_size)
1575 {
1576 size_t i, j;
1577 cam_capability_t camera_cap;
1578 int rc = 0;
1579
1580 if ( ( NULL == lib_handle ) || ( NULL == tbl ) ) {
1581 return -1;
1582 }
1583
1584 rc = mm_camera_lib_get_caps(lib_handle, &camera_cap);
1585 if ( MM_CAMERA_OK != rc ) {
1586 CDBG_ERROR("%s:mm_camera_lib_get_caps() err=%d\n", __func__, rc);
1587 return -1;
1588 }
1589
1590 for( i = 0 ; i < tbl_size ; i++ ) {
1591 for( j = 0; j < camera_cap.picture_sizes_tbl_cnt; j++ ) {
1592 if ( ( tbl[i].width == camera_cap.picture_sizes_tbl[j].width ) &&
1593 ( tbl[i].height == camera_cap.picture_sizes_tbl[j].height ) ) {
1594 tbl[i].supported = 1;
1595 rc = (int)i;
1596 break;
1597 }
1598 }
1599 }
1600
1601 return rc;
1602 }
1603
1604 /*===========================================================================
1605 * FUNCTION : enableAFR
1606 *
1607 * DESCRIPTION: This function will go through the list
1608 * of supported FPS ranges and select the
1609 * one which has maximum range
1610 *
1611 * PARAMETERS :
1612 * @lib_handle : camera test library handle
1613 *
1614 * RETURN : uint32_t type of stream handle
1615 * MM_CAMERA_OK -- Success
1616 * !=MM_CAMERA_OK -- Error status
1617 *==========================================================================*/
enableAFR(mm_camera_lib_handle * lib_handle)1618 int enableAFR(mm_camera_lib_handle *lib_handle)
1619 {
1620 size_t i, j;
1621 float max_range = 0.0f;
1622 cam_capability_t cap;
1623 int rc = MM_CAMERA_OK;
1624
1625 if ( NULL == lib_handle ) {
1626 return MM_CAMERA_E_INVALID_INPUT;
1627 }
1628
1629 rc = mm_camera_lib_get_caps(lib_handle, &cap);
1630 if ( MM_CAMERA_OK != rc ) {
1631 CDBG_ERROR("%s:mm_camera_lib_get_caps() err=%d\n", __func__, rc);
1632 return rc;
1633 }
1634
1635 for( i = 0, j = 0 ; i < cap.fps_ranges_tbl_cnt ; i++ ) {
1636 if ( max_range < (cap.fps_ranges_tbl[i].max_fps - cap.fps_ranges_tbl[i].min_fps) ) {
1637 j = i;
1638 }
1639 }
1640
1641 rc = mm_camera_lib_send_command(lib_handle,
1642 MM_CAMERA_LIB_FPS_RANGE,
1643 &cap.fps_ranges_tbl[j],
1644 NULL);
1645
1646 CDBG_ERROR("%s : FPS range [%5.2f:%5.2f] rc = %d",
1647 __func__,
1648 cap.fps_ranges_tbl[j].min_fps,
1649 cap.fps_ranges_tbl[j].max_fps,
1650 rc);
1651
1652 return rc;
1653 }
1654
1655 /*===========================================================================
1656 * FUNCTION - submain -
1657 *
1658 * DESCRIPTION:
1659 * ===========================================================================*/
submain()1660 static int submain()
1661 {
1662 int rc = 0;
1663 char tc_buf[3];
1664 menu_id_change_t current_menu_id = MENU_ID_MAIN, next_menu_id;
1665 camera_action_t action_id;
1666 int action_param;
1667 uint8_t previewing = 0;
1668 int isZSL = 0;
1669 uint8_t wnr_enabled = 0;
1670 mm_camera_lib_handle lib_handle;
1671 int num_cameras;
1672 int available_sensors =
1673 (int)(sizeof(sensor_tbl) / sizeof(sensor_tbl[0]));
1674 int available_snap_sizes =
1675 (int)(sizeof(dimension_tbl)/sizeof(dimension_tbl[0]));
1676 int i,c;
1677 mm_camera_lib_snapshot_params snap_dim;
1678 snap_dim.width = DEFAULT_SNAPSHOT_WIDTH;
1679 snap_dim.height = DEFAULT_SNAPSHOT_HEIGHT;
1680 cam_scene_mode_type default_scene= CAM_SCENE_MODE_OFF;
1681 int set_tintless= 0;
1682
1683 mm_camera_test_obj_t test_obj;
1684 memset(&test_obj, 0, sizeof(mm_camera_test_obj_t));
1685
1686 rc = mm_camera_lib_open(&lib_handle, 0);
1687 if (rc != MM_CAMERA_OK) {
1688 CDBG_ERROR("%s:mm_camera_lib_open() err=%d\n", __func__, rc);
1689 return -1;
1690 }
1691
1692 num_cameras = mm_camera_lib_number_of_cameras(&lib_handle);
1693 if ( 0 >= num_cameras ) {
1694 CDBG_ERROR("%s: No camera sensors reported!", __func__);
1695 rc = -1;
1696 goto ERROR;
1697 } else if ( 1 <= num_cameras ) {
1698 c = MIN(num_cameras, available_sensors);
1699 for ( i = 0 ; i < c ; i++ ) {
1700 sensor_tbl[i].present = 1;
1701 }
1702 current_menu_id = MENU_ID_SENSORS;
1703 } else {
1704 i = filter_resolutions(&lib_handle,
1705 dimension_tbl,
1706 (size_t)available_snap_sizes);
1707 if ( ( i < 0 ) || ( i >= available_snap_sizes ) ) {
1708 CDBG_ERROR("%s:filter_resolutions()\n", __func__);
1709 goto ERROR;
1710 }
1711 snap_dim.width = dimension_tbl[i].width;
1712 snap_dim.height = dimension_tbl[i].height;
1713
1714 rc = enableAFR(&lib_handle);
1715 if (rc != MM_CAMERA_OK) {
1716 CDBG_ERROR("%s:enableAFR() err=%d\n", __func__, rc);
1717 goto ERROR;
1718 }
1719
1720 rc = mm_camera_lib_send_command(&lib_handle,
1721 MM_CAMERA_LIB_BESTSHOT,
1722 &default_scene,
1723 NULL);
1724 if (rc != MM_CAMERA_OK) {
1725 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
1726 goto ERROR;
1727 }
1728 }
1729 /*start the eztune server*/
1730 CDBG_HIGH("Starting eztune Server \n");
1731 eztune_server_start(&lib_handle);
1732
1733 do {
1734 print_current_menu (current_menu_id);
1735 fgets(tc_buf, 3, stdin);
1736
1737 next_menu_id = next_menu(current_menu_id, tc_buf[0], & action_id, & action_param);
1738
1739 if (next_menu_id != MENU_ID_INVALID) {
1740 current_menu_id = next_menu_id;
1741 }
1742 if (action_id == ACTION_NO_ACTION) {
1743 continue;
1744 }
1745
1746 switch(action_id) {
1747 case ACTION_START_PREVIEW:
1748 CDBG_ERROR("ACTION_START_PREVIEW \n");
1749 rc = mm_camera_lib_start_stream(&lib_handle);
1750 if (rc != MM_CAMERA_OK) {
1751 CDBG_ERROR("%s:mm_camera_lib_start_stream() err=%d\n", __func__, rc);
1752 goto ERROR;
1753 }
1754 previewing = 1;
1755 break;
1756
1757 case ACTION_STOP_PREVIEW:
1758 CDBG("ACTION_STOP_PREVIEW \n");
1759 rc = mm_camera_lib_stop_stream(&lib_handle);
1760 if (rc != MM_CAMERA_OK) {
1761 CDBG_ERROR("%s:mm_camera_lib_stop_stream() err=%d\n", __func__, rc);
1762 goto ERROR;
1763 }
1764 previewing = 0;
1765 break;
1766
1767 case ACTION_SET_WHITE_BALANCE:
1768 CDBG("Selection for the White Balance changes\n");
1769 set_whitebalance(&lib_handle, action_param);
1770 break;
1771
1772 case ACTION_SET_TINTLESS_ENABLE:
1773 CDBG("Selection for the Tintless enable changes\n");
1774 set_tintless = 1;
1775 rc = mm_camera_lib_send_command(&lib_handle,
1776 MM_CAMERA_LIB_SET_TINTLESS,
1777 &set_tintless,
1778 NULL);
1779 if (rc != MM_CAMERA_OK) {
1780 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
1781 goto ERROR;
1782 }
1783 break;
1784
1785 case ACTION_SET_TINTLESS_DISABLE:
1786 CDBG("Selection for the Tintless disable changes\n");
1787 set_tintless = 0;
1788 rc = mm_camera_lib_send_command(&lib_handle,
1789 MM_CAMERA_LIB_SET_TINTLESS,
1790 &set_tintless,
1791 NULL);
1792 if (rc != MM_CAMERA_OK) {
1793 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
1794 goto ERROR;
1795 }
1796 break;
1797
1798 case ACTION_SET_EXP_METERING:
1799 CDBG("Selection for the Exposure Metering changes\n");
1800 set_exp_metering(&lib_handle, action_param);
1801 break;
1802
1803 case ACTION_GET_CTRL_VALUE:
1804 CDBG("Selection for getting control value\n");
1805 get_ctrl_value(action_param);
1806 break;
1807
1808 case ACTION_BRIGHTNESS_INCREASE:
1809 printf("Increase brightness\n");
1810 increase_brightness(&lib_handle);
1811 break;
1812
1813 case ACTION_BRIGHTNESS_DECREASE:
1814 printf("Decrease brightness\n");
1815 decrease_brightness(&lib_handle);
1816 break;
1817
1818 case ACTION_CONTRAST_INCREASE:
1819 CDBG("Selection for the contrast increase\n");
1820 increase_contrast (&lib_handle);
1821 break;
1822
1823 case ACTION_CONTRAST_DECREASE:
1824 CDBG("Selection for the contrast decrease\n");
1825 decrease_contrast (&lib_handle);
1826 break;
1827
1828 case ACTION_EV_INCREASE:
1829 CDBG("Selection for the EV increase\n");
1830 increase_EV ();
1831 break;
1832
1833 case ACTION_EV_DECREASE:
1834 CDBG("Selection for the EV decrease\n");
1835 decrease_EV ();
1836 break;
1837
1838 case ACTION_SATURATION_INCREASE:
1839 CDBG("Selection for the EV increase\n");
1840 increase_saturation (&lib_handle);
1841 break;
1842
1843 case ACTION_SATURATION_DECREASE:
1844 CDBG("Selection for the EV decrease\n");
1845 decrease_saturation (&lib_handle);
1846 break;
1847
1848 case ACTION_TOGGLE_AFR:
1849 CDBG("Select for auto frame rate toggling\n");
1850 toggle_afr();
1851 break;
1852
1853 case ACTION_SET_ISO:
1854 CDBG("Select for ISO changes\n");
1855 set_iso(&lib_handle, action_param);
1856 break;
1857
1858 case ACTION_SET_ZOOM:
1859 CDBG("Selection for the zoom direction changes\n");
1860 set_zoom(&lib_handle, action_param);
1861 break;
1862
1863 case ACTION_SHARPNESS_INCREASE:
1864 CDBG("Selection for sharpness increase\n");
1865 increase_sharpness(&lib_handle);
1866 break;
1867
1868 case ACTION_SHARPNESS_DECREASE:
1869 CDBG("Selection for sharpness decrease\n");
1870 decrease_sharpness(&lib_handle);
1871 break;
1872
1873 case ACTION_SET_BESTSHOT_MODE:
1874 CDBG("Selection for bestshot\n");
1875 set_bestshot_mode(&lib_handle, action_param);
1876 break;
1877
1878 case ACTION_SET_FLASH_MODE:
1879 printf("\n Selection for flashmode\n");
1880 set_flash_mode(&lib_handle, action_param);
1881 break;
1882
1883 case ACTION_SWITCH_CAMERA:
1884 rc = mm_camera_lib_close(&lib_handle);
1885 if (rc != MM_CAMERA_OK) {
1886 CDBG_ERROR("%s:mm_camera_lib_close() err=%d\n", __func__, rc);
1887 goto ERROR;
1888 }
1889
1890 rc = mm_camera_lib_open(&lib_handle, action_param);
1891 if (rc != MM_CAMERA_OK) {
1892 CDBG_ERROR("%s:mm_camera_lib_open() err=%d\n", __func__, rc);
1893 goto ERROR;
1894 }
1895
1896 i = filter_resolutions(&lib_handle,
1897 dimension_tbl,
1898 sizeof(dimension_tbl)/sizeof(dimension_tbl[0]));
1899 if ( ( i < 0 ) || ( i >= available_snap_sizes ) ) {
1900 CDBG_ERROR("%s:filter_resolutions()\n", __func__);
1901 goto ERROR;
1902 }
1903 snap_dim.width = dimension_tbl[i].width;
1904 snap_dim.height = dimension_tbl[i].height;
1905
1906 rc = enableAFR(&lib_handle);
1907 if (rc != MM_CAMERA_OK) {
1908 CDBG_ERROR("%s:enableAFR() err=%d\n", __func__, rc);
1909 goto ERROR;
1910 }
1911
1912 rc = mm_camera_lib_send_command(&lib_handle,
1913 MM_CAMERA_LIB_BESTSHOT,
1914 &default_scene,
1915 NULL);
1916 if (rc != MM_CAMERA_OK) {
1917 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
1918 goto ERROR;
1919 }
1920 break;
1921
1922 case ACTION_TOGGLE_ZSL:
1923 printf("ZSL Toggle !!!\n");
1924 isZSL = !isZSL;
1925 if ( isZSL ) {
1926 printf("ZSL on !!!\n");
1927 } else {
1928 printf("ZSL off !!!\n");
1929 }
1930 rc = mm_camera_lib_send_command(&lib_handle,
1931 MM_CAMERA_LIB_ZSL_ENABLE,
1932 &isZSL,
1933 NULL);
1934 if (rc != MM_CAMERA_OK) {
1935 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
1936 goto ERROR;
1937 }
1938 break;
1939
1940 case ACTION_TAKE_RAW_SNAPSHOT:
1941 CDBG_HIGH("\n Take RAW snapshot\n");
1942
1943 rc = mm_camera_lib_send_command(&lib_handle,
1944 MM_CAMERA_LIB_DO_AF,
1945 NULL,
1946 NULL);
1947
1948 if (rc != MM_CAMERA_OK) {
1949 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
1950 goto ERROR;
1951 }
1952
1953 rc = mm_camera_lib_send_command(&lib_handle,
1954 MM_CAMERA_LIB_RAW_CAPTURE,
1955 NULL,
1956 NULL);
1957 if (rc != MM_CAMERA_OK) {
1958 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
1959 goto ERROR;
1960 }
1961 break;
1962
1963 case ACTION_TAKE_JPEG_SNAPSHOT:
1964 CDBG_HIGH("\n Take JPEG snapshot\n");
1965
1966 rc = mm_camera_lib_send_command(&lib_handle,
1967 MM_CAMERA_LIB_DO_AF,
1968 NULL,
1969 NULL);
1970
1971 if (rc != MM_CAMERA_OK) {
1972 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
1973 goto ERROR;
1974 }
1975
1976 rc = mm_camera_lib_send_command(&lib_handle,
1977 MM_CAMERA_LIB_JPEG_CAPTURE,
1978 &snap_dim,
1979 NULL);
1980 if (rc != MM_CAMERA_OK) {
1981 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
1982 goto ERROR;
1983 }
1984 break;
1985 case ACTION_SWITCH_RESOLUTION:
1986 printf("\n Switch snapshot resolution to %dx%d\n",
1987 dimension_tbl[action_param].width,
1988 dimension_tbl[action_param].height);
1989 snap_dim.width = dimension_tbl[action_param].width;
1990 snap_dim.height = dimension_tbl[action_param].height;
1991 break;
1992
1993 case ACTION_START_RECORDING:
1994 CDBG("Start recording action\n");
1995 #if 0
1996 if (mm_app_start_video(cam_id) < 0)
1997 goto ERROR;
1998 is_rec = 1;
1999 #endif
2000 break;
2001 case ACTION_STOP_RECORDING:
2002 CDBG("Stop recording action\n");
2003 #if 0
2004 if(is_rec) {
2005 if (mm_app_stop_video(cam_id) < 0)
2006 goto ERROR;
2007 is_rec = 0;
2008 }
2009 #endif
2010 break;
2011 case ACTION_TAKE_LIVE_SNAPSHOT:
2012 printf("Selection for live shot\n");
2013 #if 0
2014 if(is_rec)
2015 mm_app_take_live_snapshot(cam_id);
2016 else
2017 printf("\n !!! Use live snapshot option while recording only !!!\n");
2018 #endif
2019 break;
2020
2021 case ACTION_TOGGLE_WNR:
2022 wnr_enabled = !wnr_enabled;
2023 printf("WNR Enabled = %d\n", wnr_enabled);
2024 rc = mm_camera_lib_send_command(&lib_handle,
2025 MM_CAMERA_LIB_WNR_ENABLE,
2026 &wnr_enabled,
2027 NULL);
2028 if (rc != MM_CAMERA_OK) {
2029 CDBG_ERROR("%s:mm_camera_lib_send_command() err=%d\n", __func__, rc);
2030 goto ERROR;
2031 }
2032 break;
2033
2034 case ACTION_EXIT:
2035 printf("Exiting....\n");
2036 break;
2037 case ACTION_NO_ACTION:
2038 printf("Go back to main menu");
2039 break;
2040
2041 default:
2042 printf("\n\n!!!!!WRONG INPUT: %d!!!!\n", action_id);
2043 break;
2044 }
2045
2046 usleep(1000 * 1000);
2047 CDBG("action_id = %d\n", action_id);
2048
2049 } while (action_id != ACTION_EXIT);
2050 action_id = ACTION_NO_ACTION;
2051
2052 mm_camera_lib_close(&lib_handle);
2053 return 0;
2054
2055 ERROR:
2056
2057 mm_camera_lib_close(&lib_handle);
2058
2059 return rc;
2060 }
2061
2062