• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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