xref: /hardware/qcom/camera/QCamera2/stack/mm-camera-test/src/mm_qcamera_main_menu.c

/* Copyright (c) 2013-2014, 2016, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *     * Neither the name of The Linux Foundation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

// System dependencies
#include <ctype.h>
#include <errno.h>

// Camera dependencies
#include "mm_qcamera_main_menu.h"
#include "mm_qcamera_app.h"
#include "mm_qcamera_dbg.h"

/*===========================================================================
 * Macro
 *===========================================================================*/
#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
#define VIDEO_BUFFER_SIZE       (PREVIEW_WIDTH * PREVIEW_HEIGHT * 3/2)
#define THUMBNAIL_BUFFER_SIZE   (THUMBNAIL_WIDTH * THUMBNAIL_HEIGHT * 3/2)
#define SNAPSHOT_BUFFER_SIZE    (PICTURE_WIDTH * PICTURE_HEIGHT * 3/2)
//TODO:check this Macros with current app.

/*===========================================================================
 * Defines
 *===========================================================================*/
//#define VIDEO_FRAMES_NUM      4
#define THUMBNAIL_FRAMES_NUM  1
#define SNAPSHOT_FRAMES_NUM   1
#define MAX_NUM_FORMAT        32
#define ZOOM_STEP             2
#define ZOOM_MIN_VALUE        0
#define EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR 12
#define EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR -12
#define EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR 0
#define EXPOSURE_COMPENSATION_DENOMINATOR 6

//TODO: find correct values of Contrast defines.
#define CAMERA_MIN_CONTRAST    0
#define CAMERA_DEF_CONTRAST    5
#define CAMERA_MAX_CONTRAST    10
#define CAMERA_CONTRAST_STEP   1

//TODO: find correct values of Brightness defines.
#define CAMERA_MIN_BRIGHTNESS  0
#define CAMERA_DEF_BRIGHTNESS  3
#define CAMERA_MAX_BRIGHTNESS  6
#define CAMERA_BRIGHTNESS_STEP 1

//TODO: find correct values of Saturation defines.
#define CAMERA_MIN_SATURATION  0
#define CAMERA_DEF_SATURATION  5
#define CAMERA_MAX_SATURATION  10
#define CAMERA_SATURATION_STEP 1

#define CAMERA_MIN_SHARPNESS 0
#define CAMERA_MAX_SHARPNESS 10
#define CAMERA_DEF_SHARPNESS 5
#define CAMERA_SHARPNESS_STEP 1

const CAMERA_MAIN_MENU_TBL_T camera_main_menu_tbl[] = {
  {START_PREVIEW,               "Start preview"},
  {STOP_PREVIEW,               "Stop preview/video"},
  {SET_WHITE_BALANCE,          "Set white balance mode"},
  {SET_TINTLESS_ENABLE,        "Set Tintless Enable"},
  {SET_TINTLESS_DISABLE,       "Set Tintless Disable"},
  {SET_EXP_METERING,           "Set exposure metering mode"},
  {GET_CTRL_VALUE,             "Get control value menu"},
  {TOGGLE_AFR,                 "Toggle auto frame rate. Default fixed frame rate"},
  {SET_ISO,                    "ISO changes."},
  {BRIGHTNESS_GOTO_SUBMENU,    "Brightness changes."},
  {CONTRAST_GOTO_SUBMENU,      "Contrast changes."},
  {EV_GOTO_SUBMENU,            "EV changes."},
  {SATURATION_GOTO_SUBMENU,    "Saturation changes."},
  {SET_ZOOM,                   "Set Digital Zoom."},
  {SET_SHARPNESS,              "Set Sharpness."},
  {TAKE_JPEG_SNAPSHOT,         "Take a snapshot"},
  {START_RECORDING,            "Start RECORDING"},
  {STOP_RECORDING,             "Stop RECORDING"},
  {BEST_SHOT,                  "Set best-shot mode"},
  {LIVE_SHOT,                  "Take a live snapshot"},
  {FLASH_MODES,                "Set Flash modes"},
  {TOGGLE_ZSL,                 "Toggle ZSL On/Off"},
  {TAKE_RAW_SNAPSHOT,          "Take RAW snapshot"},
  {SWITCH_SNAP_RESOLUTION,     "Select Jpeg resolution"},
  {TOGGLE_WNR,                 "Toggle Wavelet Denoise"},
  {EXIT,                       "Exit"}
};

CAMERA_SENSOR_MENU_TLB_T sensor_tbl[] = {
        {"Primary Camera",      0},
        {"Secondary Camera",    0},
        {"Camera Sensor 3",     0},
        {"Camera Sensor 4",     0}
};

const CAMERA_BRIGHTNESS_TBL_T brightness_change_tbl[] = {
  {INC_BRIGHTNESS, "Increase Brightness by one step."},
  {DEC_BRIGHTNESS, "Decrease Brightness by one step."},
};

const CAMERA_CONTRST_TBL_T contrast_change_tbl[] = {
  {INC_CONTRAST, "Increase Contrast by one step."},
  {DEC_CONTRAST, "Decrease Contrast by one step."},
};

const CAMERA_EV_TBL_T camera_EV_tbl[] = {
  {INCREASE_EV, "Increase EV by one step."},
  {DECREASE_EV, "Decrease EV by one step."},
};

const CAMERA_SATURATION_TBL_T camera_saturation_tbl[] = {
  {INC_SATURATION, "Increase Satuation by one step."},
  {DEC_SATURATION, "Decrease Satuation by one step."},
};

const CAMERA_SHARPNESS_TBL_T camera_sharpness_tbl[] = {
  {INC_SHARPNESS, "Increase Sharpness."},
  {DEC_SHARPNESS, "Decrease Sharpness."},
};

const WHITE_BALANCE_TBL_T white_balance_tbl[] = {
  {   WB_AUTO,               "White Balance - Auto"},
  {   WB_INCANDESCENT,       "White Balance - Incandescent"},
  {   WB_FLUORESCENT,        "White Balance - Fluorescent"},
  {   WB_WARM_FLUORESCENT,   "White Balance - Warm Fluorescent"},
  {   WB_DAYLIGHT,           "White Balance - Daylight"},
  {   WB_CLOUDY_DAYLIGHT,    "White Balance - Cloudy Daylight"},
  {   WB_TWILIGHT,           "White Balance - Twilight"},
  {   WB_SHADE,              "White Balance - Shade"},
};

const GET_CTRL_TBL_T get_ctrl_tbl[] = {
  {     WHITE_BALANCE_STATE,            "Get white balance state (auto/off)"},
  {     WHITE_BALANCE_TEMPERATURE,      "Get white balance temperature"},
  {     BRIGHTNESS_CTRL,                "Get brightness value"},
  {     EV,                             "Get exposure value"},
  {     CONTRAST_CTRL,                  "Get contrast value"},
  {     SATURATION_CTRL,                "Get saturation value"},
  {     SHARPNESS_CTRL,                 "Get sharpness value"},
};

const EXP_METERING_TBL_T exp_metering_tbl[] = {
  {   AUTO_EXP_FRAME_AVG,          "Exposure Metering - Frame Average"},
  {   AUTO_EXP_CENTER_WEIGHTED,    "Exposure Metering - Center Weighted"},
  {   AUTO_EXP_SPOT_METERING,      "Exposure Metering - Spot Metering"},
  {   AUTO_EXP_SMART_METERING,     "Exposure Metering - Smart Metering"},
  {   AUTO_EXP_USER_METERING,      "Exposure Metering - User Metering"},
  {   AUTO_EXP_SPOT_METERING_ADV,  "Exposure Metering - Spot Metering Adv"},
  {   AUTO_EXP_CENTER_WEIGHTED_ADV,"Exposure Metering - Center Weighted Adv"},
};

const ISO_TBL_T iso_tbl[] = {
  {   ISO_AUTO,   "ISO: Auto"},
  {   ISO_DEBLUR, "ISO: Deblur"},
  {   ISO_100,    "ISO: 100"},
  {   ISO_200,    "ISO: 200"},
  {   ISO_400,    "ISO: 400"},
  {   ISO_800,    "ISO: 800"},
  {   ISO_1600,   "ISO: 1600"},
};

const ZOOM_TBL_T zoom_tbl[] = {
  {   ZOOM_IN,  "Zoom In one step"},
  {   ZOOM_OUT, "Zoom Out one step"},
};

const BESTSHOT_MODE_TBT_T bestshot_mode_tbl[] = {
  {BESTSHOT_AUTO,           "Bestshot Mode: Auto"},
  {BESTSHOT_ACTION,         "Bestshot Mode: Action"},
  {BESTSHOT_PORTRAIT,       "Bestshot Mode: Portrait"},
  {BESTSHOT_LANDSCAPE,      "Bestshot Mode: Landscape"},
  {BESTSHOT_NIGHT,          "Bestshot Mode: Night"},
  {BESTSHOT_NIGHT_PORTRAIT, "Bestshot Mode: Night Portrait"},
  {BESTSHOT_THEATRE,        "Bestshot Mode: Theatre"},
  {BESTSHOT_BEACH,          "Bestshot Mode: Beach"},
  {BESTSHOT_SNOW,           "Bestshot Mode: Snow"},
  {BESTSHOT_SUNSET,         "Bestshot Mode: Sunset"},
  {BESTSHOT_ANTISHAKE,      "Bestshot Mode: Antishake"},
  {BESTSHOT_FIREWORKS,      "Bestshot Mode: Fireworks"},
  {BESTSHOT_SPORTS,         "Bestshot Mode: Sports"},
  {BESTSHOT_PARTY,          "Bestshot Mode: Party"},
  {BESTSHOT_CANDLELIGHT,    "Bestshot Mode: Candlelight"},
  {BESTSHOT_ASD,            "Bestshot Mode: ASD"},
  {BESTSHOT_BACKLIGHT,      "Bestshot Mode: Backlight"},
  {BESTSHOT_FLOWERS,        "Bestshot Mode: Flowers"},
  {BESTSHOT_AR,             "Bestshot Mode: Augmented Reality"},
  {BESTSHOT_HDR,            "Bestshot Mode: HDR"},
};

const FLASH_MODE_TBL_T flashmodes_tbl[] = {
  {   FLASH_MODE_OFF,   "Flash Mode Off"},
  {   FLASH_MODE_AUTO,  "Flash Mode Auto"},
  {   FLASH_MODE_ON,    "Flash Mode On"},
  {   FLASH_MODE_TORCH, "Flash Mode Torch"},
};

DIMENSION_TBL_T dimension_tbl[] = {
{VGA_WIDTH,      VGA_HEIGHT,      "VGA",   "Size: VGA <640x480>"   , 0},
{MP1_WIDTH,      MP1_HEIGHT,      "1MP",   "Size: 1MP <1280x960>"  , 0},
{MP5_WIDTH,      MP5_HEIGHT,      "5MP",   "Size: 5MP <2592x1944>",  0},
{MP8_WIDTH,      MP8_HEIGHT,      "8MP",   "Size: 8MP <3264x2448>",  0},
{MP12_WIDTH,     MP12_HEIGHT,     "12MP",  "Size: 12MP <4000x3000>", 0},
};

/*===========================================================================
 * Forward declarations
 *===========================================================================*/
//static void system_dimension_set(mm_camera_test_obj_t *test_obj);
/*===========================================================================
 * Static global variables
 *===========================================================================*/
USER_INPUT_DISPLAY_T input_display;
int preview_video_resolution_flag = 0;

//TODO: default values.
#if 1
int brightness = CAMERA_DEF_BRIGHTNESS;
int contrast = CAMERA_DEF_CONTRAST;
int saturation = CAMERA_DEF_SATURATION;
int sharpness = CAMERA_DEF_SHARPNESS;
#else
int brightness = 0;
int contrast = 0;
int saturation = 0;
int sharpness = 0;
#endif
//TODO: find new method to calculate ev.
//int32_t ev_numerator = EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR;

//TODO:
//fps_mode_t fps_mode = FPS_MODE_FIXED;
int zoom_level;
int zoom_max_value;
int cam_id;
int is_rec = 0;


static int submain();

/*===========================================================================
 * FUNCTION    - keypress_to_event -
 *
 * DESCRIPTION:
 *==========================================================================*/
int keypress_to_event(char keypress)
{
  int out_buf = INVALID_KEY_PRESS;
  if ((keypress >= 'A' && keypress <= 'Z') ||
    (keypress >= 'a' && keypress <= 'z')) {
    out_buf = tolower(keypress);
    out_buf = out_buf - 'a';
  } else if (keypress >= '0' && keypress <= '9') {
    out_buf = keypress - '0';
  }
  return out_buf;
}

int next_menu(menu_id_change_t current_menu_id, char keypress, camera_action_t * action_id_ptr, int * action_param)
{
  int output_to_event;
  menu_id_change_t next_menu_id = MENU_ID_INVALID;
  * action_id_ptr = ACTION_NO_ACTION;

  output_to_event = keypress_to_event(keypress);
  LOGD("current_menu_id=%d\n",current_menu_id);
  printf("output_to_event=%d\n",output_to_event);
  switch(current_menu_id) {
    case MENU_ID_MAIN:
      switch(output_to_event) {
        case START_PREVIEW:
          * action_id_ptr = ACTION_START_PREVIEW;
          LOGD("START_PREVIEW\n");
          break;
        case STOP_PREVIEW:
          * action_id_ptr = ACTION_STOP_PREVIEW;
          LOGD("STOP_PREVIEW\n");
          break;

        case SET_WHITE_BALANCE:
          next_menu_id = MENU_ID_WHITEBALANCECHANGE;
          LOGD("next_menu_id = MENU_ID_WHITEBALANCECHANGE = %d\n", next_menu_id);
          break;

        case SET_TINTLESS_ENABLE:
          * action_id_ptr = ACTION_SET_TINTLESS_ENABLE;
          next_menu_id = MENU_ID_MAIN;
          LOGD("next_menu_id = MENU_ID_TINTLESSENABLE = %d\n", next_menu_id);
          break;

        case SET_TINTLESS_DISABLE:
          * action_id_ptr = ACTION_SET_TINTLESS_DISABLE;
          next_menu_id = MENU_ID_MAIN;
          LOGD("next_menu_id = MENU_ID_TINTLESSDISABLE = %d\n", next_menu_id);
          break;

        case SET_EXP_METERING:
          next_menu_id = MENU_ID_EXPMETERINGCHANGE;
          LOGD("next_menu_id = MENU_ID_EXPMETERINGCHANGE = %d\n", next_menu_id);
          break;

        case GET_CTRL_VALUE:
          next_menu_id = MENU_ID_GET_CTRL_VALUE;
          LOGD("next_menu_id = MENU_ID_GET_CTRL_VALUE = %d\n", next_menu_id);
          break;

        case BRIGHTNESS_GOTO_SUBMENU:
          next_menu_id = MENU_ID_BRIGHTNESSCHANGE;
          LOGD("next_menu_id = MENU_ID_BRIGHTNESSCHANGE = %d\n", next_menu_id);
          break;

        case CONTRAST_GOTO_SUBMENU:
          next_menu_id = MENU_ID_CONTRASTCHANGE;
          break;

        case EV_GOTO_SUBMENU:
          next_menu_id = MENU_ID_EVCHANGE;
          break;

        case SATURATION_GOTO_SUBMENU:
          next_menu_id = MENU_ID_SATURATIONCHANGE;
          break;

        case TOGGLE_AFR:
          * action_id_ptr = ACTION_TOGGLE_AFR;
          LOGD("next_menu_id = MENU_ID_TOGGLEAFR = %d\n", next_menu_id);
          break;

        case SET_ISO:
          next_menu_id = MENU_ID_ISOCHANGE;
          LOGD("next_menu_id = MENU_ID_ISOCHANGE = %d\n", next_menu_id);
          break;

        case SET_ZOOM:
          next_menu_id = MENU_ID_ZOOMCHANGE;
          LOGD("next_menu_id = MENU_ID_ZOOMCHANGE = %d\n", next_menu_id);
          break;

        case BEST_SHOT:
          next_menu_id = MENU_ID_BESTSHOT;
          LOGD("next_menu_id = MENU_ID_BESTSHOT = %d\n", next_menu_id);
          break;

        case LIVE_SHOT:
          * action_id_ptr = ACTION_TAKE_LIVE_SNAPSHOT;
          LOGD("\nTaking Live snapshot\n");
          break;

        case FLASH_MODES:
          next_menu_id = MENU_ID_FLASHMODE;
          LOGD("next_menu_id = MENU_ID_FLASHMODE = %d\n", next_menu_id);
          break;

        case SET_SHARPNESS:
          next_menu_id = MENU_ID_SHARPNESSCHANGE;
          LOGD("next_menu_id = MENU_ID_SHARPNESSCHANGE = %d\n", next_menu_id);
          break;

        case SWITCH_SNAP_RESOLUTION:
          next_menu_id = MENU_ID_SWITCH_RES;
          LOGD("next_menu_id = MENU_ID_SWITCH_RES = %d\n", next_menu_id);
          break;

        case TAKE_JPEG_SNAPSHOT:
          * action_id_ptr = ACTION_TAKE_JPEG_SNAPSHOT;
          printf("\n Taking JPEG snapshot\n");
          break;

        case START_RECORDING:
          * action_id_ptr = ACTION_START_RECORDING;
          LOGD("Start recording\n");
          break;
        case STOP_RECORDING:
          * action_id_ptr = ACTION_STOP_RECORDING;
          LOGD("Stop recording\n");
          break;
        case TOGGLE_ZSL:
          * action_id_ptr = ACTION_TOGGLE_ZSL;
          LOGD("Toggle ZSL\n");
          break;
        case TAKE_RAW_SNAPSHOT:
            * action_id_ptr = ACTION_TAKE_RAW_SNAPSHOT;
            next_menu_id = MENU_ID_MAIN;
            LOGD("Capture RAW\n");
            break;
        case TOGGLE_WNR:
            * action_id_ptr = ACTION_TOGGLE_WNR;
            next_menu_id = MENU_ID_MAIN;
            LOGD("Toggle WNR");
            break;
        case EXIT:
          * action_id_ptr = ACTION_EXIT;
          LOGD("Exit \n");
          break;
        default:
          next_menu_id = MENU_ID_MAIN;
          LOGD("next_menu_id = MENU_ID_MAIN = %d\n", next_menu_id);
          break;
      }
      break;

    case MENU_ID_SWITCH_RES:
        printf("MENU_ID_SWITCH_RES\n");
        *action_id_ptr = ACTION_SWITCH_RESOLUTION;
        *action_param = output_to_event;
        int available_sizes = sizeof(dimension_tbl)/sizeof(dimension_tbl[0]);
        if ( ( *action_param >= 0 ) &&
             ( *action_param < available_sizes ) &&
             ( dimension_tbl[*action_param].supported )) {
            next_menu_id = MENU_ID_MAIN;
        }
        else {
          next_menu_id = current_menu_id;
        }
        break;

    case MENU_ID_SENSORS:
        next_menu_id = MENU_ID_MAIN;
        *action_id_ptr = ACTION_SWITCH_CAMERA;
        *action_param = output_to_event;
        break;

    case MENU_ID_WHITEBALANCECHANGE:
      printf("MENU_ID_WHITEBALANCECHANGE\n");
      if (output_to_event >= WB_MAX) {
        next_menu_id = current_menu_id;
        * action_id_ptr = ACTION_NO_ACTION;
      } else {
        next_menu_id = MENU_ID_MAIN;
        * action_id_ptr = ACTION_SET_WHITE_BALANCE;
        * action_param = output_to_event;
      }
      break;

    case MENU_ID_EXPMETERINGCHANGE:
      printf("MENU_ID_EXPMETERINGCHANGE\n");
      if (output_to_event >= AUTO_EXP_MAX) {
        next_menu_id = current_menu_id;
        * action_id_ptr = ACTION_NO_ACTION;
      } else {
        next_menu_id = MENU_ID_MAIN;
        * action_id_ptr = ACTION_SET_EXP_METERING;
        * action_param = output_to_event;
      }
      break;

    case MENU_ID_GET_CTRL_VALUE:
      printf("MENU_ID_GET_CTRL_VALUE\n");
      * action_id_ptr = ACTION_GET_CTRL_VALUE;
      if (output_to_event > 0 &&
        output_to_event <= (int)(sizeof(get_ctrl_tbl)/sizeof(get_ctrl_tbl[0]))) {
          next_menu_id = MENU_ID_MAIN;
          * action_param = output_to_event;
      }
      else {
        next_menu_id = current_menu_id;
      }
      break;

    case MENU_ID_BRIGHTNESSCHANGE:
      switch (output_to_event) {
        case INC_BRIGHTNESS:
          * action_id_ptr = ACTION_BRIGHTNESS_INCREASE;
          next_menu_id = MENU_ID_MAIN;
          break;

        case DEC_BRIGHTNESS:
          * action_id_ptr = ACTION_BRIGHTNESS_DECREASE;
          next_menu_id = MENU_ID_MAIN;
          break;

        default:
          next_menu_id = MENU_ID_BRIGHTNESSCHANGE;
          break;
      }
      break;

    case MENU_ID_CONTRASTCHANGE:
      switch (output_to_event) {
        case INC_CONTRAST:
          * action_id_ptr = ACTION_CONTRAST_INCREASE;
          next_menu_id = MENU_ID_MAIN;
          break;

        case DEC_CONTRAST:
          * action_id_ptr = ACTION_CONTRAST_DECREASE;
          next_menu_id = MENU_ID_MAIN;
          break;

        default:
          next_menu_id = MENU_ID_CONTRASTCHANGE;
          break;
      }
      break;

    case MENU_ID_EVCHANGE:
      switch (output_to_event) {
        case INCREASE_EV:
          * action_id_ptr = ACTION_EV_INCREASE;
          next_menu_id = MENU_ID_MAIN;
          break;

        case DECREASE_EV:
          * action_id_ptr = ACTION_EV_DECREASE;
          next_menu_id = MENU_ID_MAIN;
          break;

        default:
          next_menu_id = MENU_ID_EVCHANGE;
          break;
      }
      break;

    case MENU_ID_SATURATIONCHANGE:
      switch (output_to_event) {
        case INC_SATURATION:
          * action_id_ptr = ACTION_SATURATION_INCREASE;
          next_menu_id = MENU_ID_MAIN;
          break;

        case DEC_SATURATION:
          * action_id_ptr = ACTION_SATURATION_DECREASE;
          next_menu_id = MENU_ID_MAIN;
          break;

        default:
          next_menu_id = MENU_ID_EVCHANGE;
          break;
      }
      break;

    case MENU_ID_ISOCHANGE:
      printf("MENU_ID_ISOCHANGE\n");
      if (output_to_event >= ISO_MAX) {
        next_menu_id = current_menu_id;
        * action_id_ptr = ACTION_NO_ACTION;
      } else {
        next_menu_id = MENU_ID_MAIN;
        * action_id_ptr = ACTION_SET_ISO;
        * action_param = output_to_event;
      }
      break;

    case MENU_ID_ZOOMCHANGE:
      * action_id_ptr = ACTION_SET_ZOOM;
      if (output_to_event > 0 &&
        output_to_event <= (int)(sizeof(zoom_tbl)/sizeof(zoom_tbl[0]))) {
          next_menu_id = MENU_ID_MAIN;
          * action_param = output_to_event;
      } else {
        next_menu_id = current_menu_id;
      }
      break;

    case MENU_ID_SHARPNESSCHANGE:
      switch (output_to_event) {
        case INC_SHARPNESS:
          * action_id_ptr = ACTION_SHARPNESS_INCREASE;
          next_menu_id = MENU_ID_MAIN;
          break;
        case DEC_SHARPNESS:
          * action_id_ptr = ACTION_SHARPNESS_DECREASE;
          next_menu_id = MENU_ID_MAIN;
          break;
        default:
          next_menu_id = MENU_ID_SHARPNESSCHANGE;
          break;
      }
      break;

    case MENU_ID_BESTSHOT:
      if (output_to_event >= BESTSHOT_MAX) {
        next_menu_id = current_menu_id;
        * action_id_ptr = ACTION_NO_ACTION;
      } else {
        next_menu_id = MENU_ID_MAIN;
        * action_id_ptr = ACTION_SET_BESTSHOT_MODE;
        * action_param = output_to_event;
      }
      break;

    case MENU_ID_FLASHMODE:
      if (output_to_event >= FLASH_MODE_MAX) {
        next_menu_id = current_menu_id;
        * action_id_ptr = ACTION_NO_ACTION;
      } else {
        next_menu_id = MENU_ID_MAIN;
        * action_id_ptr = ACTION_SET_FLASH_MODE;
        * action_param = output_to_event;
      }
      break;

    default:
      LOGD("menu id is wrong: %d\n", current_menu_id);
      break;
  }

  return next_menu_id;
}

/*===========================================================================
 * FUNCTION    - print_menu_preview_video -
 *
 * DESCRIPTION:
 * ===========================================================================*/
static void print_menu_preview_video(void) {
  unsigned int i;
  if (!is_rec) {
    printf("\n");
    printf("===========================================\n");
    printf("      Camera is in preview/video mode now        \n");
    printf("===========================================\n\n");
  } else {
    printf("\n");
    printf("===========================================\n");
    printf("      Camera is in RECORDING mode now       \n");
    printf("        Press 'Q' To Stop Recording          \n");
    printf("        Press 'S' To Take Live Snapshot       \n");
    printf("===========================================\n\n");
  }
  char menuNum = 'A';
  for (i = 0; i < sizeof(camera_main_menu_tbl)/sizeof(camera_main_menu_tbl[0]); i++) {
    if (i == BASE_OFFSET) {
      menuNum = '1';
    }

    printf("%c.  %s\n", menuNum, camera_main_menu_tbl[i].menu_name);
    menuNum++;
  }

  printf("\nPlease enter your choice: ");

  return;
}

static void camera_preview_video_wb_change_tbl(void) {
  unsigned int i;
  printf("\n");
  printf("==========================================================\n");
  printf("      Camera is in white balance change mode       \n");
  printf("==========================================================\n\n");

  char submenuNum = 'A';
  for (i = 0 ; i < sizeof(white_balance_tbl) /
                   sizeof(white_balance_tbl[0]); i++) {
        printf("%c.  %s\n", submenuNum, white_balance_tbl[i].wb_name);
        submenuNum++;
  }
  printf("\nPlease enter your choice for White Balance modes: ");
  return;
}

static void camera_preview_video_get_ctrl_value_tbl(void) {
  unsigned int i;
  printf("\n");
  printf("==========================================================\n");
  printf("      Camera is in get control value mode       \n");
  printf("==========================================================\n\n");

  char submenuNum = 'A';
  for (i = 0 ; i < sizeof(get_ctrl_tbl) /
                   sizeof(get_ctrl_tbl[0]); i++) {
        printf("%c.  %s\n", submenuNum, get_ctrl_tbl[i].get_ctrl_name);
        submenuNum++;
  }
  printf("\nPlease enter your choice for control value you want to get: ");
  return;
}

static void camera_preview_video_exp_metering_change_tbl(void) {
  unsigned int i;
  printf("\n");
  printf("==========================================================\n");
  printf("      Camera is in exposure metering change mode       \n");
  printf("==========================================================\n\n");

  char submenuNum = 'A';
  for (i = 0 ; i < sizeof(exp_metering_tbl) /
                   sizeof(exp_metering_tbl[0]); i++) {
        printf("%c.  %s\n", submenuNum, exp_metering_tbl[i].exp_metering_name);
        submenuNum++;
  }
  printf("\nPlease enter your choice for exposure metering modes: ");
  return;
}

static void camera_contrast_change_tbl(void) {
    unsigned int i;

    printf("\n");
    printf("==========================================================\n");
    printf("      Camera is in change contrast resolution mode       \n");
    printf("==========================================================\n\n");

    char contrastmenuNum = 'A';
    for (i = 0; i < sizeof(contrast_change_tbl) /
                    sizeof(contrast_change_tbl[0]); i++) {
        printf("%c.  %s\n", contrastmenuNum,
                            contrast_change_tbl[i].contrast_name);
        contrastmenuNum++;
    }

    printf("\nPlease enter your choice for contrast Change: ");
    return;
}

static void camera_EV_change_tbl(void) {
  unsigned int i;

  printf("\n");
  printf("===========================================\n");
  printf("      Camera is in EV change mode now       \n");
  printf("===========================================\n\n");

  char submenuNum = 'A';
  for (i = 0; i < sizeof(camera_EV_tbl)/sizeof(camera_EV_tbl[0]); i++) {
    printf("%c.  %s\n", submenuNum, camera_EV_tbl[i].EV_name);
    submenuNum++;
  }

  printf("\nPlease enter your choice for EV changes: ");
  return;
}

static void camera_resolution_change_tbl(void) {
    unsigned int i;

    printf("\n");
    printf("==========================================================\n");
    printf("      Camera is in snapshot resolution mode               \n");
    printf("==========================================================\n\n");

    for (i = 0; i < sizeof(dimension_tbl) /
      sizeof(dimension_tbl[0]); i++) {
        if ( dimension_tbl[i].supported ) {
            printf("%d.  %s\n", i,
                    dimension_tbl[i].str_name);
        }
    }

    printf("\nPlease enter your choice for Resolution: ");
    return;
}

static void camera_preview_video_zoom_change_tbl(void) {
    unsigned int i;
    zoom_max_value = MAX_ZOOMS_CNT;
    printf("\nCurrent Zoom Value = %d ,Max Zoom Value = %d\n",zoom_level,zoom_max_value);
    char submenuNum = 'A';
    for (i = 0 ; i < sizeof(zoom_tbl) /
                   sizeof(zoom_tbl[0]); i++) {
        printf("%c.  %s\n", submenuNum, zoom_tbl[i].zoom_direction_name);
        submenuNum++;
    }
    printf("\nPlease enter your choice for zoom change direction: ");
    return;
}

static void camera_brightness_change_tbl(void) {
    unsigned int i;

    printf("\n");
    printf("==========================================================\n");
    printf("      Camera is in change brightness mode       \n");
    printf("==========================================================\n\n");

    char brightnessmenuNum = 'A';
    for (i = 0; i < sizeof(brightness_change_tbl) /
                    sizeof(brightness_change_tbl[0]); i++) {
        printf("%c.  %s\n", brightnessmenuNum,
                            brightness_change_tbl[i].brightness_name);
        brightnessmenuNum++;
    }

    printf("\nPlease enter your choice for Brightness Change: ");
    return;
}

static void camera_saturation_change_tbl(void) {
    unsigned int i;

    printf("\n");
    printf("==========================================================\n");
    printf("      Camera is in change saturation mode       \n");
    printf("==========================================================\n\n");

    char saturationmenuNum = 'A';
    for (i = 0; i < sizeof(camera_saturation_tbl) /
                    sizeof(camera_saturation_tbl[0]); i++) {
        printf("%c.  %s\n", saturationmenuNum,
                            camera_saturation_tbl[i].saturation_name);
        saturationmenuNum++;
    }

    printf("\nPlease enter your choice for Saturation Change: ");
    return;
}

static void camera_preview_video_iso_change_tbl(void) {
  unsigned int i;
  printf("\n");
  printf("==========================================================\n");
  printf("      Camera is in ISO change mode       \n");
  printf("==========================================================\n\n");

  char submenuNum = 'A';
  for (i = 0 ; i < sizeof(iso_tbl) /
                   sizeof(iso_tbl[0]); i++) {
        printf("%c.  %s\n", submenuNum, iso_tbl[i].iso_modes_name);
        submenuNum++;
  }
  printf("\nPlease enter your choice for iso modes: ");
  return;
}

static void camera_preview_video_sharpness_change_tbl(void) {
  unsigned int i;
  printf("\n");
  printf("==========================================================\n");
  printf("      Camera is in sharpness change mode       \n");
  printf("==========================================================\n\n");

  char submenuNum = 'A';
  for (i = 0 ; i < sizeof(camera_sharpness_tbl) /
                   sizeof(camera_sharpness_tbl[0]); i++) {
        printf("%c.  %s\n", submenuNum, camera_sharpness_tbl[i].sharpness_name);
        submenuNum++;
  }
  printf("\nPlease enter your choice for sharpness modes: ");
  return;
}

static void camera_set_bestshot_tbl(void)
{
  unsigned int i;

  printf("\n");
  printf("===========================================\n");
  printf("      Camera is in set besthot mode now       \n");
  printf("===========================================\n\n");


  char bsmenuNum = 'A';
  for (i = 0; i < sizeof(bestshot_mode_tbl)/sizeof(bestshot_mode_tbl[0]); i++) {
    printf("%c.  %s\n", bsmenuNum,
      bestshot_mode_tbl[i].name);
    bsmenuNum++;
  }

  printf("\nPlease enter your choice of Bestshot Mode: ");
  return;
}

static void camera_set_flashmode_tbl(void)
{
  unsigned int i;

  printf("\n");
  printf("===========================================\n");
  printf("      Camera is in set flash mode now       \n");
  printf("===========================================\n\n");


  char bsmenuNum = 'A';
  for (i = 0; i < sizeof(flashmodes_tbl)/sizeof(flashmodes_tbl[0]); i++) {
    printf("%c.  %s\n", bsmenuNum,
      flashmodes_tbl[i].name);
    bsmenuNum++;
  }

  printf("\nPlease enter your choice of Bestshot Mode: ");
  return;
}

static void camera_sensors_tbl(void)
{
  unsigned int i;
  size_t available_sensors = sizeof(sensor_tbl)/sizeof(sensor_tbl[0]);

  printf("\n");
  printf("===========================================\n");
  printf("      Camera Sensor to be used:            \n");
  printf("===========================================\n\n");


  char bsmenuNum = 'A';
  for (i = 0; ( i < available_sensors ) && ( sensor_tbl[i].present ) ; i++) {
    printf("%c.  %s\n", bsmenuNum,
            sensor_tbl[i].menu_name);
    bsmenuNum++;
  }

  printf("\nPlease enter your choice for sensor: ");
  return;
}

/*===========================================================================
 * FUNCTION     - increase_contrast -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int increase_contrast (mm_camera_lib_handle *lib_handle) {
        contrast += CAMERA_CONTRAST_STEP;
        if (contrast > CAMERA_MAX_CONTRAST) {
                contrast = CAMERA_MAX_CONTRAST;
                printf("Reached max CONTRAST. \n");
        }
        printf("Increase Contrast to %d\n", contrast);
        return mm_camera_lib_send_command(lib_handle,
                                          MM_CAMERA_LIB_CONTRAST,
                                          &contrast,
                                          NULL);
}

/*===========================================================================
 * FUNCTION     - decrease_contrast -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int decrease_contrast (mm_camera_lib_handle *lib_handle) {
        contrast -= CAMERA_CONTRAST_STEP;
        if (contrast < CAMERA_MIN_CONTRAST) {
                contrast = CAMERA_MIN_CONTRAST;
                printf("Reached min CONTRAST. \n");
        }
        printf("Decrease Contrast to %d\n", contrast);
        return mm_camera_lib_send_command(lib_handle,
                                          MM_CAMERA_LIB_CONTRAST,
                                          &contrast,
                                          NULL);
}

/*===========================================================================
 * FUNCTION     - decrease_brightness -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int decrease_brightness (mm_camera_lib_handle *lib_handle) {
        brightness -= CAMERA_BRIGHTNESS_STEP;
        if (brightness < CAMERA_MIN_BRIGHTNESS) {
                brightness = CAMERA_MIN_BRIGHTNESS;
                printf("Reached min BRIGHTNESS. \n");
        }
        printf("Decrease Brightness to %d\n", brightness);
        return mm_camera_lib_send_command(lib_handle,
                                          MM_CAMERA_LIB_BRIGHTNESS,
                                          &brightness,
                                          NULL);
}

/*===========================================================================
 * FUNCTION     - increase_brightness -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int increase_brightness (mm_camera_lib_handle *lib_handle) {
        brightness += CAMERA_BRIGHTNESS_STEP;
        if (brightness > CAMERA_MAX_BRIGHTNESS) {
                brightness = CAMERA_MAX_BRIGHTNESS;
                printf("Reached max BRIGHTNESS. \n");
        }
        printf("Increase Brightness to %d\n", brightness);
        return mm_camera_lib_send_command(lib_handle,
                                          MM_CAMERA_LIB_BRIGHTNESS,
                                          &brightness,
                                          NULL);
}

/*===========================================================================
 * FUNCTION     - increase_EV -
 *
 * DESCRIPTION:
 * ===========================================================================*/

int increase_EV (void) {
#if 0
   int rc = 0;
   int32_t value = 0;
   rc = cam_config_is_parm_supported(cam_id, MM_CAMERA_PARM_EXPOSURE_COMPENSATION);
    if(!rc) {
       printf("MM_CAMERA_PARM_EXPOSURE_COMPENSATION mode is not supported for this sensor");
       return -1;
    }
    ev_numerator += 1;
    if(ev_numerator >= EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR &&
            ev_numerator <= EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR){
        int16_t  numerator16 = (int16_t)(ev_numerator & 0x0000ffff);
        uint16_t denominator16 = EXPOSURE_COMPENSATION_DENOMINATOR;
        value = numerator16 << 16 | denominator16;
    } else {
       printf("Reached max EV.\n");
    }
    return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_EXPOSURE_COMPENSATION, value);
#endif
  return 0;
}

/*===========================================================================
 * FUNCTION     - decrease_EV -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int decrease_EV (void) {
#if 0
   int rc = 0;
   int32_t  value = 0;
   rc = cam_config_is_parm_supported(cam_id, MM_CAMERA_PARM_EXPOSURE_COMPENSATION);
    if(!rc) {
       printf("MM_CAMERA_PARM_EXPOSURE_COMPENSATION mode is not supported for this sensor");
       return -1;
    }
    ev_numerator -= 1;
    if(ev_numerator >= EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR &&
            ev_numerator <= EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR){
        int16_t  numerator16 = (int16_t)(ev_numerator & 0x0000ffff);
        uint16_t denominator16 = EXPOSURE_COMPENSATION_DENOMINATOR;
        value = numerator16 << 16 | denominator16;
    } else {
       printf("Reached min EV.\n");
    }
    return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_EXPOSURE_COMPENSATION, value);
#endif
  return 0;
}

/*===========================================================================
 * FUNCTION     - increase_saturation -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int increase_saturation (mm_camera_lib_handle *lib_handle) {
#if 0
  saturation += CAMERA_SATURATION_STEP;
  if (saturation > CAMERA_MAX_SATURATION) {
    saturation = CAMERA_MAX_SATURATION;
    printf("Reached max saturation. \n");
  }
  printf("Increase Saturation to %d\n", saturation);
  return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_SATURATION, saturation);
#endif
  saturation += CAMERA_SATURATION_STEP;
  if (saturation > CAMERA_MAX_SATURATION) {
    saturation = CAMERA_MAX_SATURATION;
    printf("Reached max saturation. \n");
  }
  printf("Increase saturation to %d\n", contrast);
  return mm_camera_lib_send_command(lib_handle,
                                       MM_CAMERA_LIB_SATURATION,
                                       &saturation,
                                       NULL);
}

/*===========================================================================
 * FUNCTION     - decrease_saturation -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int decrease_saturation (mm_camera_lib_handle *lib_handle) {
#if 0
  saturation -= CAMERA_SATURATION_STEP;
  if (saturation < CAMERA_MIN_SATURATION) {
    saturation = CAMERA_MIN_SATURATION;
    printf("Reached min saturation. \n");
  }
  printf("Dcrease Saturation to %d\n", saturation);
  return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_SATURATION, saturation);
#endif
  saturation -= CAMERA_SATURATION_STEP;
  if (saturation < CAMERA_MIN_SATURATION) {
    saturation = CAMERA_MIN_SATURATION;
    printf("Reached min saturation. \n");
  }
  printf("decrease saturation to %d\n", contrast);
  return mm_camera_lib_send_command(lib_handle,
                                       MM_CAMERA_LIB_SATURATION,
                                       &saturation,
                                       NULL);
}


int take_jpeg_snapshot(mm_camera_test_obj_t *test_obj, int is_burst_mode)
{
  LOGH("\nEnter take_jpeg_snapshot!!\n");
  int rc = mm_app_take_picture (test_obj, (uint8_t)is_burst_mode);
  if (MM_CAMERA_OK != rc) {
    LOGE(" mm_app_take_picture() err=%d\n",  rc);
  }
  return rc;
}

/*===========================================================================
 * FUNCTION    - main -
 *
 * DESCRIPTION:
 *==========================================================================*/
int main()
{
    char tc_buf[3];
    int mode = 0;
    int rc = 0;

    printf("Please Select Execution Mode:\n");
    printf("0: Menu Based 1: Regression\n");
    fgets(tc_buf, 3, stdin);
    mode = tc_buf[0] - '0';
    if(mode == 0) {
      printf("\nStarting Menu based!!\n");
    } else if(mode == 1) {
      printf("Starting Regression testing!!\n");
      if(!mm_app_start_regression_test(1)) {
         printf("\nRegressiion test passed!!\n");
         return 0;
      } else {
        printf("\nRegression test failed!!\n");
        exit(-1);
      }
    } else {
       printf("\nPlease Enter 0 or 1\n");
       printf("\nExisting the App!!\n");
       exit(-1);
    }


    rc = submain();

    printf("Exiting application\n");

    return rc;
}

/*===========================================================================
 * FUNCTION     - set_whitebalance -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int set_whitebalance (mm_camera_lib_handle *lib_handle, int wb_action_param) {
        cam_wb_mode_type type = 0;
        switch (wb_action_param) {
                case WB_AUTO:
                        printf("\n WB_AUTO\n");
                        type = CAM_WB_MODE_AUTO;
                        break;
                case WB_INCANDESCENT:
                        printf("\n WB_INCANDESCENT\n");
                        type = CAM_WB_MODE_INCANDESCENT;
                        break;
                case WB_FLUORESCENT:
                        printf("\n WB_FLUORESCENT\n");
                        type = CAM_WB_MODE_FLUORESCENT;
                        break;
                case WB_WARM_FLUORESCENT:
                        printf("\n WB_WARM_FLUORESCENT\n");
                        type = CAM_WB_MODE_WARM_FLUORESCENT;
                        break;
                case WB_DAYLIGHT:
                        printf("\n WB_DAYLIGHT\n");
                        type = CAM_WB_MODE_DAYLIGHT;
                        break;
                case WB_CLOUDY_DAYLIGHT:
                        printf("\n WB_CLOUDY_DAYLIGHT\n");
                        type = CAM_WB_MODE_CLOUDY_DAYLIGHT;
                        break;
               case WB_TWILIGHT:
                        printf("\n WB_TWILIGHT\n");
                        type = CAM_WB_MODE_TWILIGHT;
                        break;
               case WB_SHADE:
                        printf("\n WB_SHADE\n");
                        type = CAM_WB_MODE_SHADE;
                        break;
                default:
                        break;
        }
        return mm_camera_lib_send_command(lib_handle,
                                          MM_CAMERA_LIB_WB,
                                          &type,
                                          NULL);
}


/*===========================================================================
 * FUNCTION     - set_exp_metering -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int set_exp_metering (mm_camera_lib_handle *lib_handle, int exp_metering_action_param) {
        cam_auto_exposure_mode_type type = 0;
        switch (exp_metering_action_param) {
		case AUTO_EXP_FRAME_AVG:
                        printf("\nAUTO_EXP_FRAME_AVG\n");
                        type = CAM_AEC_MODE_FRAME_AVERAGE;
                        break;
                case AUTO_EXP_CENTER_WEIGHTED:
                        printf("\n AUTO_EXP_CENTER_WEIGHTED\n");
                        type = CAM_AEC_MODE_CENTER_WEIGHTED;
                        break;
                case AUTO_EXP_SPOT_METERING:
                        printf("\n AUTO_EXP_SPOT_METERING\n");
                        type = CAM_AEC_MODE_SPOT_METERING;
                        break;
                case AUTO_EXP_SMART_METERING:
                        printf("\n AUTO_EXP_SMART_METERING\n");
                        type = CAM_AEC_MODE_SMART_METERING;
                        break;
                case AUTO_EXP_USER_METERING:
                        printf("\n AUTO_EXP_USER_METERING\n");
                        type = CAM_AEC_MODE_USER_METERING;
                        break;
                case AUTO_EXP_SPOT_METERING_ADV:
                        printf("\n AUTO_EXP_SPOT_METERING_ADV\n");
                        type = CAM_AEC_MODE_SPOT_METERING_ADV;
                        break;
                case AUTO_EXP_CENTER_WEIGHTED_ADV:
                        printf("\n AUTO_EXP_CENTER_WEIGHTED_ADV\n");
                        type = CAM_AEC_MODE_CENTER_WEIGHTED_ADV;
                        break;
                default:
                        break;
        }
        return mm_camera_lib_send_command(lib_handle,
                                          MM_CAMERA_LIB_EXPOSURE_METERING,
                                          &type,
                                          NULL);
}

int get_ctrl_value (int ctrl_value_mode_param){
#if 0
    int rc = 0;
    struct v4l2_control ctrl;

    if (ctrl_value_mode_param == WHITE_BALANCE_STATE) {
        printf("You chose WHITE_BALANCE_STATE\n");
        ctrl.id = V4L2_CID_AUTO_WHITE_BALANCE;
    }
    else if (ctrl_value_mode_param == WHITE_BALANCE_TEMPERATURE) {
        printf("You chose WHITE_BALANCE_TEMPERATURE\n");
        ctrl.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
    }
    else if (ctrl_value_mode_param == BRIGHTNESS_CTRL) {
        printf("You chose brightness value\n");
        ctrl.id = V4L2_CID_BRIGHTNESS;
    }
    else if (ctrl_value_mode_param == EV) {
        printf("You chose exposure value\n");
        ctrl.id = V4L2_CID_EXPOSURE;
    }
    else if (ctrl_value_mode_param == CONTRAST_CTRL) {
        printf("You chose contrast value\n");
        ctrl.id = V4L2_CID_CONTRAST;
    }
    else if (ctrl_value_mode_param == SATURATION_CTRL) {
        printf("You chose saturation value\n");
        ctrl.id = V4L2_CID_SATURATION;
    } else if (ctrl_value_mode_param == SHARPNESS_CTRL) {
        printf("You chose sharpness value\n");
        ctrl.id = V4L2_CID_SHARPNESS;
    }

  //  rc = ioctl(camfd, VIDIOC_G_CTRL, &ctrl);
    return rc;
#endif
  return ctrl_value_mode_param;
}

/*===========================================================================
 * FUNCTION     - toggle_afr -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int toggle_afr () {
#if 0
    if (fps_mode == FPS_MODE_AUTO) {
        printf("\nSetting FPS_MODE_FIXED\n");
        fps_mode = FPS_MODE_FIXED;
    } else {
        printf("\nSetting FPS_MODE_AUTO\n");
        fps_mode = FPS_MODE_AUTO;
    }
    return mm_app_set_config_parm(cam_id, MM_CAMERA_PARM_FPS_MODE, fps_mode);
#endif
  return 0;
}

int set_zoom (mm_camera_lib_handle *lib_handle, int zoom_action_param) {

    if (zoom_action_param == ZOOM_IN) {
        zoom_level += ZOOM_STEP;
        if (zoom_level > zoom_max_value)
            zoom_level = zoom_max_value;
    } else if (zoom_action_param == ZOOM_OUT) {
        zoom_level -= ZOOM_STEP;
        if (zoom_level < ZOOM_MIN_VALUE)
            zoom_level = ZOOM_MIN_VALUE;
    } else {
        LOGD(" Invalid zoom_action_param value\n");
        return -EINVAL;
    }
    return mm_camera_lib_send_command(lib_handle,
                                      MM_CAMERA_LIB_ZOOM,
                                      &zoom_level,
                                      NULL);
}

/*===========================================================================
 * FUNCTION     - set_iso -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int set_iso (mm_camera_lib_handle *lib_handle, int iso_action_param) {
    cam_iso_mode_type type = 0;
    switch (iso_action_param) {
        case ISO_AUTO:
            printf("\n ISO_AUTO\n");
            type = CAM_ISO_MODE_AUTO;
            break;
        case ISO_DEBLUR:
            printf("\n ISO_DEBLUR\n");
            type = CAM_ISO_MODE_DEBLUR;
            break;
        case ISO_100:
            printf("\n ISO_100\n");
            type = CAM_ISO_MODE_100;
            break;
        case ISO_200:
            printf("\n ISO_200\n");
            type = CAM_ISO_MODE_200;
            break;
        case ISO_400:
            printf("\n ISO_400\n");
            type = CAM_ISO_MODE_400;
            break;
        case ISO_800:
            printf("\n ISO_800\n");
            type = CAM_ISO_MODE_800;
            break;
        case ISO_1600:
            printf("\n ISO_1600\n");
            type = CAM_ISO_MODE_1600;
            break;
        default:
            break;
    }
    return mm_camera_lib_send_command(lib_handle,
                                      MM_CAMERA_LIB_ISO,
                                      &type,
                                      NULL);
}

/*===========================================================================
 * FUNCTION     - increase_sharpness -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int increase_sharpness (mm_camera_lib_handle *lib_handle) {
    sharpness += CAMERA_SHARPNESS_STEP;
    if (sharpness > CAMERA_MAX_SHARPNESS) {
        sharpness = CAMERA_MAX_SHARPNESS;
        printf("Reached max SHARPNESS. \n");
    }
    printf("Increase Sharpness to %d\n", sharpness);
    return mm_camera_lib_send_command(lib_handle,
                                      MM_CAMERA_LIB_SHARPNESS,
                                      &sharpness,
                                      NULL);
}

/*===========================================================================
 * FUNCTION     - decrease_sharpness -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int decrease_sharpness (mm_camera_lib_handle *lib_handle) {
    sharpness -= CAMERA_SHARPNESS_STEP;
    if (sharpness < CAMERA_MIN_SHARPNESS) {
        sharpness = CAMERA_MIN_SHARPNESS;
        printf("Reached min SHARPNESS. \n");
    }
    printf("Decrease Sharpness to %d\n", sharpness);
    return mm_camera_lib_send_command(lib_handle,
                                      MM_CAMERA_LIB_SHARPNESS,
                                      &sharpness,
                                      NULL);
}

int set_flash_mode (mm_camera_lib_handle *lib_handle, int action_param) {
    cam_flash_mode_t type = 0;
    switch (action_param) {
        case FLASH_MODE_OFF:
            printf("\n FLASH_MODE_OFF\n");
            type = CAM_FLASH_MODE_OFF;
            break;
        case FLASH_MODE_AUTO:
            printf("\n FLASH_MODE_AUTO\n");
            type = CAM_FLASH_MODE_AUTO;
            break;
        case FLASH_MODE_ON:
            printf("\n FLASH_MODE_ON\n");
            type = CAM_FLASH_MODE_ON;
            break;
        case FLASH_MODE_TORCH:
            printf("\n FLASH_MODE_TORCH\n");
            type = CAM_FLASH_MODE_TORCH;
            break;
        default:
            break;
    }
    return mm_camera_lib_send_command(lib_handle,
                                      MM_CAMERA_LIB_FLASH,
                                      &type,
                                      NULL);
}

int set_bestshot_mode(mm_camera_lib_handle *lib_handle, int action_param) {
    cam_scene_mode_type type = 0;
    switch (action_param) {
       case BESTSHOT_AUTO:
            printf("\n BEST SHOT AUTO\n");
            type = CAM_SCENE_MODE_OFF;
            break;
        case BESTSHOT_ACTION:
            printf("\n BEST SHOT ACTION\n");
            type = CAM_SCENE_MODE_ACTION;
            break;
        case BESTSHOT_PORTRAIT:
            printf("\n BEST SHOT PORTRAIT\n");
            type = CAM_SCENE_MODE_PORTRAIT;
            break;
        case BESTSHOT_LANDSCAPE:
            printf("\n BEST SHOT LANDSCAPE\n");
            type = CAM_SCENE_MODE_LANDSCAPE;
            break;
        case BESTSHOT_NIGHT:
            printf("\n BEST SHOT NIGHT\n");
            type = CAM_SCENE_MODE_NIGHT;
            break;
        case BESTSHOT_NIGHT_PORTRAIT:
            printf("\n BEST SHOT NIGHT PORTRAIT\n");
            type = CAM_SCENE_MODE_NIGHT_PORTRAIT;
            break;
        case BESTSHOT_THEATRE:
            printf("\n BEST SHOT THREATRE\n");
            type = CAM_SCENE_MODE_THEATRE;
            break;
        case BESTSHOT_BEACH:
            printf("\n BEST SHOT BEACH\n");
            type = CAM_SCENE_MODE_BEACH;
            break;
        case BESTSHOT_SNOW:
            printf("\n BEST SHOT SNOW\n");
            type = CAM_SCENE_MODE_SNOW;
            break;
        case BESTSHOT_SUNSET:
            printf("\n BEST SHOT SUNSET\n");
            type = CAM_SCENE_MODE_SUNSET;
            break;
        case BESTSHOT_ANTISHAKE:
            printf("\n BEST SHOT ANTISHAKE\n");
            type = CAM_SCENE_MODE_ANTISHAKE;
            break;
        case BESTSHOT_FIREWORKS:
            printf("\n BEST SHOT FIREWORKS\n");
            type = CAM_SCENE_MODE_FIREWORKS;
            break;
        case BESTSHOT_SPORTS:
            printf("\n BEST SHOT SPORTS\n");
            type = CAM_SCENE_MODE_SPORTS;
            break;
        case BESTSHOT_PARTY:
            printf("\n BEST SHOT PARTY\n");
            type = CAM_SCENE_MODE_PARTY;
            break;
        case BESTSHOT_CANDLELIGHT:
            printf("\n BEST SHOT CANDLELIGHT\n");
            type = CAM_SCENE_MODE_CANDLELIGHT;
            break;
        case BESTSHOT_ASD:
            printf("\n BEST SHOT ASD\n");
            type = CAM_SCENE_MODE_AUTO;
            break;
        case BESTSHOT_BACKLIGHT:
            printf("\n BEST SHOT BACKLIGHT\n");
            type = CAM_SCENE_MODE_BACKLIGHT;
            break;
        case BESTSHOT_FLOWERS:
            printf("\n BEST SHOT FLOWERS\n");
            type = CAM_SCENE_MODE_FLOWERS;
            break;
        case BESTSHOT_AR:
            printf("\n BEST SHOT AR\n");
            type = CAM_SCENE_MODE_AR;
            break;
        case BESTSHOT_HDR:
            printf("\n BEST SHOT HDR\n");
            type = CAM_SCENE_MODE_OFF;
            break;
        default:
            break;
        }
        return mm_camera_lib_send_command(lib_handle,
                                          MM_CAMERA_LIB_BESTSHOT,
                                          &type,
                                          NULL);
}
/*===========================================================================
 * FUNCTION     - print_current_menu -
 *
 * DESCRIPTION:
 * ===========================================================================*/
int print_current_menu (menu_id_change_t current_menu_id) {
  if (current_menu_id == MENU_ID_MAIN) {
    print_menu_preview_video ();
  } else if (current_menu_id == MENU_ID_WHITEBALANCECHANGE) {
    camera_preview_video_wb_change_tbl();
  } else if (current_menu_id == MENU_ID_EXPMETERINGCHANGE) {
    camera_preview_video_exp_metering_change_tbl();
  } else if (current_menu_id == MENU_ID_GET_CTRL_VALUE) {
    camera_preview_video_get_ctrl_value_tbl();
  } else if (current_menu_id == MENU_ID_ISOCHANGE) {
    camera_preview_video_iso_change_tbl();
  } else if (current_menu_id == MENU_ID_BRIGHTNESSCHANGE) {
    camera_brightness_change_tbl ();
  } else if (current_menu_id == MENU_ID_CONTRASTCHANGE) {
    camera_contrast_change_tbl ();
  } else if (current_menu_id == MENU_ID_EVCHANGE) {
    camera_EV_change_tbl ();
  } else if (current_menu_id == MENU_ID_SATURATIONCHANGE) {
    camera_saturation_change_tbl ();
  } else if (current_menu_id == MENU_ID_ZOOMCHANGE) {
    camera_preview_video_zoom_change_tbl();
  } else if (current_menu_id == MENU_ID_SHARPNESSCHANGE) {
    camera_preview_video_sharpness_change_tbl();
  } else if (current_menu_id == MENU_ID_BESTSHOT) {
    camera_set_bestshot_tbl();
  } else if (current_menu_id == MENU_ID_FLASHMODE) {
    camera_set_flashmode_tbl();
  } else if (current_menu_id == MENU_ID_SENSORS ) {
    camera_sensors_tbl();
  } else if (current_menu_id == MENU_ID_SWITCH_RES ) {
    camera_resolution_change_tbl();
  }

  return 0;
}

int filter_resolutions(mm_camera_lib_handle *lib_handle,
                       DIMENSION_TBL_T *tbl,
                       size_t tbl_size)
{
    size_t i, j;
    cam_capability_t camera_cap;
    int rc = 0;

    if ( ( NULL == lib_handle ) || ( NULL == tbl ) ) {
        return -1;
    }

    rc = mm_camera_lib_get_caps(lib_handle, &camera_cap);
    if ( MM_CAMERA_OK != rc ) {
        LOGE("mm_camera_lib_get_caps() err=%d\n",  rc);
        return -1;
    }

    for( i = 0 ; i < tbl_size ; i++ ) {
        for( j = 0; j < camera_cap.picture_sizes_tbl_cnt; j++ ) {
            if ( ( tbl[i].width == camera_cap.picture_sizes_tbl[j].width ) &&
                 ( tbl[i].height == camera_cap.picture_sizes_tbl[j].height ) ) {
                tbl[i].supported = 1;
                rc = (int)i;
                break;
            }
        }
    }

    return rc;
}

/*===========================================================================
 * FUNCTION   : enableAFR
 *
 * DESCRIPTION: This function will go through the list
 *              of supported FPS ranges and select the
 *              one which has maximum range
 *
 * PARAMETERS :
 *   @lib_handle   : camera test library handle
 *
 * RETURN     : uint32_t type of stream handle
 *              MM_CAMERA_OK  -- Success
 *              !=MM_CAMERA_OK -- Error status
 *==========================================================================*/
int enableAFR(mm_camera_lib_handle *lib_handle)
{
    size_t i, j;
    float max_range = 0.0f;
    cam_capability_t cap;
    int rc = MM_CAMERA_OK;

    if ( NULL == lib_handle ) {
        return MM_CAMERA_E_INVALID_INPUT;
    }

    rc = mm_camera_lib_get_caps(lib_handle, &cap);
    if ( MM_CAMERA_OK != rc ) {
        LOGE("mm_camera_lib_get_caps() err=%d\n",  rc);
        return rc;
    }

    for( i = 0, j = 0 ; i < cap.fps_ranges_tbl_cnt ; i++ ) {
        if ( max_range < (cap.fps_ranges_tbl[i].max_fps - cap.fps_ranges_tbl[i].min_fps) ) {
            j = i;
        }
    }

    rc = mm_camera_lib_send_command(lib_handle,
                                    MM_CAMERA_LIB_FPS_RANGE,
                                    &cap.fps_ranges_tbl[j],
                                    NULL);

    LOGE("FPS range [%5.2f:%5.2f] rc = %d",
              cap.fps_ranges_tbl[j].min_fps,
              cap.fps_ranges_tbl[j].max_fps,
              rc);

    return rc;
}

/*===========================================================================
 * FUNCTION     - submain -
 *
 * DESCRIPTION:
 * ===========================================================================*/
static int submain()
{
    int rc = 0;
    char tc_buf[3];
    menu_id_change_t current_menu_id = MENU_ID_MAIN, next_menu_id;
    camera_action_t action_id;
    int action_param;
    uint8_t previewing = 0;
    int isZSL = 0;
    uint8_t wnr_enabled = 0;
    mm_camera_lib_handle lib_handle;
    int num_cameras;
    int available_sensors =
        (int)(sizeof(sensor_tbl) / sizeof(sensor_tbl[0]));
    int available_snap_sizes =
        (int)(sizeof(dimension_tbl)/sizeof(dimension_tbl[0]));
    int i,c;
    mm_camera_lib_snapshot_params snap_dim;
    snap_dim.width = DEFAULT_SNAPSHOT_WIDTH;
    snap_dim.height = DEFAULT_SNAPSHOT_HEIGHT;
    cam_scene_mode_type default_scene= CAM_SCENE_MODE_OFF;
    int set_tintless= 0;

    mm_camera_test_obj_t test_obj;
    memset(&test_obj, 0, sizeof(mm_camera_test_obj_t));

    rc = mm_camera_lib_open(&lib_handle, 0);
    if (rc != MM_CAMERA_OK) {
        LOGE("mm_camera_lib_open() err=%d\n",  rc);
        return -1;
    }

    num_cameras = mm_camera_lib_number_of_cameras(&lib_handle);
    if ( 0 >= num_cameras ) {
        LOGE(" No camera sensors reported!");
        rc = -1;
        goto ERROR;
    } else if ( 1 <= num_cameras ) {
        c = MIN(num_cameras, available_sensors);
        for ( i = 0 ; i < c ; i++ ) {
            sensor_tbl[i].present = 1;
        }
        current_menu_id = MENU_ID_SENSORS;
    } else {
        i = filter_resolutions(&lib_handle,
                                dimension_tbl,
                                (size_t)available_snap_sizes);
        if ( ( i < 0 ) || ( i >= available_snap_sizes ) ) {
            LOGE("filter_resolutions()\n");
            goto ERROR;
        }
        snap_dim.width = dimension_tbl[i].width;
        snap_dim.height = dimension_tbl[i].height;

        rc = enableAFR(&lib_handle);
        if (rc != MM_CAMERA_OK) {
            LOGE("enableAFR() err=%d\n",  rc);
            goto ERROR;
        }

        rc =  mm_camera_lib_send_command(&lib_handle,
                                         MM_CAMERA_LIB_BESTSHOT,
                                         &default_scene,
                                         NULL);
        if (rc != MM_CAMERA_OK) {
            LOGE("mm_camera_lib_send_command() err=%d\n",  rc);
            goto ERROR;
        }
    }
    /*start the eztune server*/
    LOGH("Starting eztune Server \n");
    eztune_server_start(&lib_handle);

    do {
        print_current_menu (current_menu_id);
        fgets(tc_buf, 3, stdin);

        next_menu_id = next_menu(current_menu_id, tc_buf[0], & action_id, & action_param);

        if (next_menu_id != MENU_ID_INVALID) {
          current_menu_id = next_menu_id;
        }
        if (action_id == ACTION_NO_ACTION) {
          continue;
        }

        switch(action_id) {
            case ACTION_START_PREVIEW:
                LOGE("ACTION_START_PREVIEW \n");
                rc = mm_camera_lib_start_stream(&lib_handle);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_start_stream() err=%d\n",  rc);
                    goto ERROR;
                }
                previewing = 1;
                break;

            case ACTION_STOP_PREVIEW:
                LOGD("ACTION_STOP_PREVIEW \n");
                rc = mm_camera_lib_stop_stream(&lib_handle);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_stop_stream() err=%d\n",  rc);
                    goto ERROR;
                }
                previewing = 0;
                break;

            case ACTION_SET_WHITE_BALANCE:
                LOGD("Selection for the White Balance changes\n");
                set_whitebalance(&lib_handle, action_param);
                break;

            case ACTION_SET_TINTLESS_ENABLE:
                LOGD("Selection for the Tintless enable changes\n");
                set_tintless = 1;
                rc =  mm_camera_lib_send_command(&lib_handle,
                                                 MM_CAMERA_LIB_SET_TINTLESS,
                                                 &set_tintless,
                                                 NULL);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_send_command() err=%d\n",  rc);
                    goto ERROR;
                }
                break;

            case ACTION_SET_TINTLESS_DISABLE:
                LOGD("Selection for the Tintless disable changes\n");
                set_tintless = 0;
                rc =  mm_camera_lib_send_command(&lib_handle,
                                                 MM_CAMERA_LIB_SET_TINTLESS,
                                                 &set_tintless,
                                                 NULL);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_send_command() err=%d\n",  rc);
                    goto ERROR;
                }
                break;

            case ACTION_SET_EXP_METERING:
                LOGD("Selection for the Exposure Metering changes\n");
                set_exp_metering(&lib_handle, action_param);
                break;

            case ACTION_GET_CTRL_VALUE:
                LOGD("Selection for getting control value\n");
                get_ctrl_value(action_param);
                break;

            case ACTION_BRIGHTNESS_INCREASE:
                printf("Increase brightness\n");
                increase_brightness(&lib_handle);
                break;

            case ACTION_BRIGHTNESS_DECREASE:
                printf("Decrease brightness\n");
                decrease_brightness(&lib_handle);
                break;

            case ACTION_CONTRAST_INCREASE:
                LOGD("Selection for the contrast increase\n");
                increase_contrast (&lib_handle);
                break;

            case ACTION_CONTRAST_DECREASE:
                LOGD("Selection for the contrast decrease\n");
                decrease_contrast (&lib_handle);
                break;

            case ACTION_EV_INCREASE:
                LOGD("Selection for the EV increase\n");
                increase_EV ();
                break;

            case ACTION_EV_DECREASE:
                LOGD("Selection for the EV decrease\n");
                decrease_EV ();
                break;

            case ACTION_SATURATION_INCREASE:
                LOGD("Selection for the EV increase\n");
                increase_saturation (&lib_handle);
                break;

            case ACTION_SATURATION_DECREASE:
                LOGD("Selection for the EV decrease\n");
                decrease_saturation (&lib_handle);
                break;

            case ACTION_TOGGLE_AFR:
                LOGD("Select for auto frame rate toggling\n");
                toggle_afr();
                break;

            case ACTION_SET_ISO:
                LOGD("Select for ISO changes\n");
                set_iso(&lib_handle, action_param);
                break;

            case ACTION_SET_ZOOM:
                LOGD("Selection for the zoom direction changes\n");
                set_zoom(&lib_handle, action_param);
                break;

            case ACTION_SHARPNESS_INCREASE:
                LOGD("Selection for sharpness increase\n");
                increase_sharpness(&lib_handle);
                break;

            case ACTION_SHARPNESS_DECREASE:
                LOGD("Selection for sharpness decrease\n");
                decrease_sharpness(&lib_handle);
                break;

            case ACTION_SET_BESTSHOT_MODE:
                LOGD("Selection for bestshot\n");
                set_bestshot_mode(&lib_handle, action_param);
                break;

            case ACTION_SET_FLASH_MODE:
                printf("\n Selection for flashmode\n");
                set_flash_mode(&lib_handle, action_param);
                break;

            case ACTION_SWITCH_CAMERA:
                rc = mm_camera_lib_close(&lib_handle);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_close() err=%d\n",  rc);
                    goto ERROR;
                }

                rc = mm_camera_lib_open(&lib_handle, action_param);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_open() err=%d\n",  rc);
                    goto ERROR;
                }

                i = filter_resolutions(&lib_handle,
                                        dimension_tbl,
                                        sizeof(dimension_tbl)/sizeof(dimension_tbl[0]));
                if ( ( i < 0 ) || ( i >=  available_snap_sizes ) ) {
                    LOGE("filter_resolutions()\n");
                    goto ERROR;
                }
                snap_dim.width = dimension_tbl[i].width;
                snap_dim.height = dimension_tbl[i].height;

                rc = enableAFR(&lib_handle);
                if (rc != MM_CAMERA_OK) {
                    LOGE("enableAFR() err=%d\n",  rc);
                    goto ERROR;
                }

                rc =  mm_camera_lib_send_command(&lib_handle,
                                                 MM_CAMERA_LIB_BESTSHOT,
                                                 &default_scene,
                                                 NULL);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_send_command() err=%d\n",  rc);
                    goto ERROR;
                }
                break;

            case ACTION_TOGGLE_ZSL:
                printf("ZSL Toggle !!!\n");
                isZSL = !isZSL;
                if ( isZSL ) {
                    printf("ZSL on !!!\n");
                } else {
                    printf("ZSL off !!!\n");
                }
                rc = mm_camera_lib_send_command(&lib_handle,
                                                MM_CAMERA_LIB_ZSL_ENABLE,
                                                &isZSL,
                                                NULL);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_send_command() err=%d\n",  rc);
                    goto ERROR;
                }
                break;

            case ACTION_TAKE_RAW_SNAPSHOT:
                LOGH("\n Take RAW snapshot\n");

                rc = mm_camera_lib_send_command(&lib_handle,
                                                MM_CAMERA_LIB_DO_AF,
                                                NULL,
                                                NULL);

                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_send_command() err=%d\n",  rc);
                    goto ERROR;
                }

                rc = mm_camera_lib_send_command(&lib_handle,
                                                MM_CAMERA_LIB_RAW_CAPTURE,
                                                NULL,
                                                NULL);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_send_command() err=%d\n",  rc);
                    goto ERROR;
                }
                break;

            case ACTION_TAKE_JPEG_SNAPSHOT:
                LOGH("\n Take JPEG snapshot\n");

                rc = mm_camera_lib_send_command(&lib_handle,
                                                MM_CAMERA_LIB_JPEG_CAPTURE,
                                                &snap_dim,
                                                NULL);
                if (rc != MM_CAMERA_OK) {
                    LOGE("mm_camera_lib_send_command() err=%d\n",  rc);
                    goto ERROR;
                }
                break;
            case ACTION_SWITCH_RESOLUTION:
                printf("\n Switch snapshot resolution to %dx%d\n",
                       dimension_tbl[action_param].width,
                       dimension_tbl[action_param].height);
                snap_dim.width = dimension_tbl[action_param].width;
                snap_dim.height = dimension_tbl[action_param].height;
                break;

      case ACTION_START_RECORDING:
        LOGD("Start recording action\n");
#if 0
        if (mm_app_start_video(cam_id) < 0)
          goto ERROR;
        is_rec = 1;
#endif
        break;
      case ACTION_STOP_RECORDING:
        LOGD("Stop recording action\n");
#if 0
        if(is_rec) {
          if (mm_app_stop_video(cam_id) < 0)
            goto ERROR;
          is_rec = 0;
        }
#endif
        break;
      case ACTION_TAKE_LIVE_SNAPSHOT:
        printf("Selection for live shot\n");
#if 0
        if(is_rec)
           mm_app_take_live_snapshot(cam_id);
        else
           printf("\n !!! Use live snapshot option while recording only !!!\n");
#endif
        break;

        case ACTION_TOGGLE_WNR:
          wnr_enabled = !wnr_enabled;
          printf("WNR Enabled = %d\n", wnr_enabled);
          rc = mm_camera_lib_send_command(&lib_handle,
                                          MM_CAMERA_LIB_WNR_ENABLE,
                                          &wnr_enabled,
                                          NULL);
          if (rc != MM_CAMERA_OK) {
              LOGE("mm_camera_lib_send_command() err=%d\n",  rc);
              goto ERROR;
          }
          break;

        case ACTION_EXIT:
            printf("Exiting....\n");
            break;
        case ACTION_NO_ACTION:
            printf("Go back to main menu");
            break;

        default:
            printf("\n\n!!!!!WRONG INPUT: %d!!!!\n", action_id);
            break;
    }

    usleep(1000 * 1000);
    LOGD("action_id = %d\n", action_id);

  } while (action_id != ACTION_EXIT);
  action_id = ACTION_NO_ACTION;

    mm_camera_lib_close(&lib_handle);
    return 0;

ERROR:

    mm_camera_lib_close(&lib_handle);

    return rc;
}