#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <semaphore.h>
#include <pthread.h>
#include <string.h>
#include <assert.h>
#include <climits>

#include <ui/DisplayInfo.h>

#include <gui/SurfaceTexture.h>
#include <gui/SurfaceTextureClient.h>
#include <ui/GraphicBuffer.h>

#include <camera/Camera.h>
#include <camera/ICamera.h>
#include <media/mediarecorder.h>

#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <cutils/properties.h>
#include <camera/CameraParameters.h>
#include <camera/ShotParameters.h>
#include <system/audio.h>
#include <system/camera.h>

#include <binder/IMemory.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>

#include <cutils/memory.h>
#include <utils/Log.h>

#include <sys/wait.h>

#include "camera_test.h"
#include "camera_test_surfacetexture.h"
#ifdef ANDROID_API_JB_OR_LATER
#include "camera_test_bufferqueue.h"
#endif

using namespace android;

int camera_index = 0;
int print_menu;

sp<Camera> camera;
sp<MediaRecorder> recorder;
sp<SurfaceComposerClient> client;
sp<SurfaceControl> surfaceControl;
sp<Surface> previewSurface;
sp<BufferSourceThread> bufferSourceOutputThread;
sp<BufferSourceInput> bufferSourceInput;

CameraParameters params;
ShotParameters shotParams;
float compensation = 0.0;
double latitude = 0.0;
double longitude = 0.0;
double degree_by_step = 17.5609756;
double altitude = 0.0;
int awb_mode = 0;
int effects_mode = 0;
int scene_mode = 0;
int caf_mode = 0;
int tempBracketRange = 1;
int tempBracketIdx = 0;
int measurementIdx = 0;
int expBracketIdx = BRACKETING_IDX_DEFAULT;
int AutoConvergenceModeIDX = 0;
int gbceIDX = 0;
int glbceIDX = 0;
int rotation = 0;
int previewRotation = 0;
bool reSizePreview = true;
bool hardwareActive = false;
bool recordingMode = false;
bool previewRunning = false;
bool vstabtoggle = false;
bool AutoExposureLocktoggle = false;
bool AutoWhiteBalanceLocktoggle = false;
bool vnftoggle = false;
bool faceDetectToggle = false;
bool metaDataToggle = false;
bool shotConfigFlush = false;
bool streamCapture = false;
int saturation = 0;
int zoomIDX = 0;
int videoCodecIDX = 0;
int audioCodecIDX = 0;
int outputFormatIDX = 0;
int contrast = 0;
int brightness = 0;
unsigned int burst = 0;
unsigned int burstCount = 0;
int sharpness = 0;
int iso_mode = 0;
int capture_mode = 0;
int exposure_mode = 0;
int ippIDX = 0;
int ippIDX_old = 0;
int previewFormat = 0;
int pictureFormat = 0;
int jpegQuality = 85;
int thumbQuality = 85;
int flashIdx = 0;
int fpsRangeIdx = 0;
timeval autofocus_start, picture_start;
char script_name[80];
int prevcnt = 0;
int videoFd = -1;
int afTimeoutIdx = 0;
int platformID = BLAZE_TABLET2;
int numAntibanding = 0;
int numEffects = 0;
int numcaptureSize = 0;
int nummodevalues = 0;
int numVcaptureSize = 0;
int numpreviewSize = 0;
int numthumbnailSize = 0;
int numawb = 0;
int numscene = 0;
int numfocus = 0;
int numflash = 0;
int numExposureMode = 0;
int numisoMode = 0;
int antibanding_mode = 0;
int effectsStrLenght = 0;
int numfps = 0;
int numpreviewFormat = 0;
int numpictureFormat = 0;
int *constFramerate = 0;
int rangeCnt = 0;
int constCnt = 0;
int focus_mode = 0;
int thumbSizeIDX =  0;
int previewSizeIDX = 1;
int captureSizeIDX = 0;
int VcaptureSizeIDX = 1;
int frameRateIDX = 0;
char *str;
char *param;
char *antibandStr = 0;
char *exposureModeStr = 0;
char *isoModeStr = 0;
char *effectssStr = 0;
char *captureSizeStr  = 0;
char *modevaluesstr = 0;
char *videosnapshotstr = 0;
char *autoconvergencestr = 0;
char *VcaptureSizeStr  = 0;
char *thumbnailSizeStr  = 0;
char *vstabstr = 0;
char *vnfstr = 0;
char *zoomstr = 0;
char *smoothzoomstr = 0;
char *AutoExposureLockstr = 0;
char *AutoWhiteBalanceLockstr = 0;
char *previewSizeStr = 0;
char *awbStr = 0;
char *sceneStr = 0;
char *focusStr = 0;
char *flashStr = 0;
char *fpsstr = 0;
char *previewFormatStr = 0;
char *pictureFormatStr = 0;
char **modevalues = 0;
char **elem;
char **antiband = 0;
char **effectss = 0;
char **awb = 0;
char **scene = 0;
char **focus = 0;
char **flash = 0;
char **exposureMode = 0;
char **isoMode = 0;
char **previewFormatArray = 0;
char **pictureFormatArray = 0;
char **fps_const_str = 0;
char **rangeDescription = 0;
char **fps_range_str = 0;
param_Array ** capture_Array = 0;
param_Array ** Vcapture_Array = 0;
param_Array ** preview_Array = 0;
param_Array ** thumbnail_Array = 0;
fps_Array * fpsArray = 0;
int iterationCount = 1;
bool iterationPrint = true;

int enableMisalignmentCorrectionIdx = 0;

char **autoconvergencemode = 0;
int numAutoConvergence = 0;
const char MeteringAreas[] = "(-656,-671,188,454,1)";

char **stereoLayout;
int numLay = 0;

char **stereoCapLayout;
int numCLay = 0;

int stereoLayoutIDX = 1;
int stereoCapLayoutIDX = 0;

char *layoutstr =0;
char *capturelayoutstr =0;

char output_dir_path[256];
char videos_dir_path[256 + 8];
char images_dir_path[256 + 8];

const char *cameras[] = {"Primary Camera", "Secondary Camera 1", "Stereo Camera"};
const char *measurement[] = {"disable", "enable"};

param_NamedExpBracketList_t expBracketing[] = {
  {
    "Disabled",
    PARAM_EXP_BRACKET_PARAM_NONE,
    PARAM_EXP_BRACKET_VALUE_NONE,
    PARAM_EXP_BRACKET_APPLY_NONE,
    "0"
  },
  {
    "Relative exposure compensation",
    PARAM_EXP_BRACKET_PARAM_COMP,
    PARAM_EXP_BRACKET_VALUE_REL,
    PARAM_EXP_BRACKET_APPLY_ADJUST,
    "-300,-150,0,150,300,150,0,-150,-300"
  },
  {
    "Relative exposure compensation (forced)",
    PARAM_EXP_BRACKET_PARAM_COMP,
    PARAM_EXP_BRACKET_VALUE_REL,
    PARAM_EXP_BRACKET_APPLY_FORCED,
    "-300F,-150F,0F,150F,300F,150F,0F,-150F,-300F"
  },
  {
    "Absolute exposure and gain",
    PARAM_EXP_BRACKET_PARAM_PAIR,
    PARAM_EXP_BRACKET_VALUE_ABS,
    PARAM_EXP_BRACKET_APPLY_ADJUST,
    "(33000,10),(0,70),(33000,100),(0,130),(33000,160),(0,180),(33000,200),(0,130),(33000,200)"
  },
  {
    "Absolute exposure and gain (forced)",
    PARAM_EXP_BRACKET_PARAM_PAIR,
    PARAM_EXP_BRACKET_VALUE_ABS,
    PARAM_EXP_BRACKET_APPLY_FORCED,
    "(33000,10)F,(0,70)F,(33000,100)F,(0,130)F,(33000,160)F,(0,180)F,(33000,200)F,(0,130)F,(33000,200)F"
  },
  {
    "Relative exposure and gain",
    PARAM_EXP_BRACKET_PARAM_PAIR,
    PARAM_EXP_BRACKET_VALUE_REL,
    PARAM_EXP_BRACKET_APPLY_ADJUST,
    "(-300,-100),(-300,+0),(-100, +0),(-100,+100),(+0,+0),(+100,-100),(+100,+0),(+300,+0),(+300,+100)"
  },
  {
    "Relative exposure and gain (forced)",
    PARAM_EXP_BRACKET_PARAM_PAIR,
    PARAM_EXP_BRACKET_VALUE_REL,
    PARAM_EXP_BRACKET_APPLY_FORCED,
    "(-300,-100)F,(-300,+0)F,(-100, +0)F,(-100,+100)F,(+0,+0)F,(+100,-100)F,(+100,+0)F,(+300,+0)F,(+300,+100)F"
  },
};

const char *tempBracketing[] = {"false", "true"};
const char *faceDetection[] = {"disable", "enable"};
const char *afTimeout[] = {"enable", "disable" };

const char *misalignmentCorrection[] = {"enable", "disable" };

#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
const char *ipp_mode[] = { "off", "Chroma Suppression", "Edge Enhancement" };
#else
const char *ipp_mode[] = { "off", "ldc", "nsf", "ldc-nsf" };
#endif


const char *caf [] = { "Off", "On" };

int numCamera = 0;
bool stereoMode = false;

int manualExp = 0;
int manualExpMin = 0;
int manualExpMax = 0;
int manualExpStep = 0;
int manualGain = 0;
int manualGainMin = 0;
int manualGainMax = 0;
int manualGainStep = 0;
int manualConv = 0;
int manualConvMin = 0;
int manualConvMax = 0;
int manualConvStep = 0;

param_Array previewSize [] = {
  { 0,   0,  "NULL"},
  { 128, 96, "SQCIF" },
  { 176, 144, "QCIF" },
  { 352, 288, "CIF" },
  { 320, 240, "QVGA" },
  { 352, 288, "CIF" },
  { 640, 480, "VGA" },
  { 720, 480, "NTSC" },
  { 720, 576, "PAL" },
  { 800, 480, "WVGA" },
  { 848, 480, "WVGA2"},
  { 864, 480, "WVGA3"},
  { 992, 560, "WVGA4"},
  { 1280, 720, "HD" },
  { 1920, 1080, "FULLHD"},
  { 240, 160,"240x160"},
  { 768, 576,  "768x576" },
  { 960, 720, "960x720"},
  { 256, 96,"SQCIF"},// stereo
  { 128, 192, "SQCIF"},
  { 352, 144,"QCIF"},
  { 176, 288, "QCIF"},
  { 480, 160, "240x160"},
  { 240, 320, "240x160"},
  { 704, 288, "CIF"},
  { 352, 576, "CIF"},
  { 640, 240,"QVGA"},
  { 320, 480, "QVGA"},
  { 1280, 480,"VGA"},
  { 640, 960, "VGA"},
  { 1536, 576,"768x576"},
  { 768, 1152, "768x576"},
  { 1440, 480,"NTSC"},
  { 720, 960,"NTSC"},
  { 1440, 576, "PAL"},
  { 720, 1152, "PAL"},
  { 1600, 480, "WVGA"},
  { 800, 960,"WVGA"},
  { 2560, 720, "HD"},
  { 1280, 1440,  "HD"}
};

size_t length_previewSize =  ARRAY_SIZE(previewSize);

param_Array thumbnailSize [] = {
  { 0,   0,  "NULL"},
  { 128, 96, "SQCIF" },
  { 176, 144, "QCIF" },
  { 352, 288, "CIF" },
  { 320, 240, "QVGA" },
  { 352, 288, "CIF" },
  { 640, 480, "VGA" },
};

size_t length_thumbnailSize =  ARRAY_SIZE(thumbnailSize);

param_Array VcaptureSize [] = {
  { 0,   0,  "NULL"},
  { 128, 96, "SQCIF" },
  { 176, 144, "QCIF" },
  { 352, 288, "CIF" },
  { 320, 240, "QVGA" },
  { 352, 288, "CIF" },
  { 640, 480, "VGA" },
  { 720, 480, "NTSC" },
  { 720, 576, "PAL" },
  { 800, 480, "WVGA" },
  #if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
  { 848, 480, "WVGA2"},
  { 864, 480, "WVGA3"},
  { 992, 560, "WVGA4"},
  #endif
  { 1280, 720, "HD" },
  { 1920, 1080, "FULLHD"},
  { 240, 160,"240x160"},
  { 768, 576,  "768x576" },
  { 960, 720, "960x720"},
  { 256, 96,"SQCIF"},// stereo
  { 128, 192, "SQCIF"},
  { 352, 144,"QCIF"},
  { 176, 288, "QCIF"},
  { 480, 160, "240x160"},
  { 240, 320, "240x160"},
  { 704, 288, "CIF"},
  { 352, 576, "CIF"},
  { 640, 240,"QVGA"},
  { 320, 480, "QVGA"},
  { 1280, 480,"VGA"},
  { 640, 960, "VGA"},
  { 1536, 576,"768x576"},
  { 768, 1152, "768x576"},
  { 1440, 480,"NTSC"},
  { 720, 960,"NTSC"},
  { 1440, 576, "PAL"},
  { 720, 1152, "PAL"},
  { 1600, 480, "WVGA"},
  { 800, 960,"WVGA"},
  { 2560, 720, "HD"},
  { 1280, 1440,  "HD"}
};

size_t lenght_Vcapture_size = ARRAY_SIZE(VcaptureSize);

param_Array captureSize[] = {
  {  320, 240,  "QVGA" },
  {  640, 480,  "VGA" },
  {  800, 600,  "SVGA" },
  { 1152, 864,  "1MP" },
  { 1280, 1024, "1.3MP" },
  { 1600, 1200,  "2MP" },
  { 2016, 1512,  "3MP" },
  { 2592, 1944,  "5MP" },
  { 2608, 1960,  "5MP" },
  { 3264, 2448,  "8MP" },
  { 3648, 2736, "10MP"},
  { 4032, 3024, "12MP"},
  { 640, 240,   "QVGA"},   //stereo
  { 320, 480, "QVGA"},
  { 1280, 480, "VGA"},
  { 640, 960,  "VGA"},
  { 2560, 960,  "1280x960"},
  { 1280, 1920,  "1280x960"},
  { 2304, 864,  "1MP"},
  { 1152, 1728,   "1MP"},
  { 2560, 1024,  "1.3MP"},
  { 1280, 2048, "1.3MP"},
  { 3200, 1200,   "2MP"},
  { 1600, 2400,  "2MP"},
  { 4096, 1536,  "3MP"},
  { 2048, 3072,  "3MP"}
};

size_t length_capture_Size = ARRAY_SIZE(captureSize);

outformat outputFormat[] = {
        { OUTPUT_FORMAT_THREE_GPP, "3gp" },
        { OUTPUT_FORMAT_MPEG_4, "mp4" },
    };

size_t length_outformat = ARRAY_SIZE(outputFormat);

video_Codecs videoCodecs[] = {
  { VIDEO_ENCODER_H263, "H263" },
  { VIDEO_ENCODER_H264, "H264" },
  { VIDEO_ENCODER_MPEG_4_SP, "MPEG4"}
};

size_t length_video_Codecs = ARRAY_SIZE(videoCodecs);

audio_Codecs audioCodecs[] = {
  { AUDIO_ENCODER_AMR_NB, "AMR_NB" },
  { AUDIO_ENCODER_AMR_WB, "AMR_WB" },
  { AUDIO_ENCODER_AAC, "AAC" },
  { AUDIO_ENCODER_HE_AAC, "AAC+" },
  { AUDIO_ENCODER_LIST_END, "disabled"},
};

size_t length_audio_Codecs = ARRAY_SIZE(audioCodecs);

V_bitRate VbitRate[] = {
  {    64000, "64K"  },
  {   128000, "128K" },
  {   192000, "192K" },
  {   240000, "240K" },
  {   320000, "320K" },
  {   360000, "360K" },
  {   384000, "384K" },
  {   420000, "420K" },
  {   768000, "768K" },
  {  1000000, "1M"   },
  {  1500000, "1.5M" },
  {  2000000, "2M"   },
  {  4000000, "4M"   },
  {  6000000, "6M"   },
  {  8000000, "8M"   },
  { 10000000, "10M"  },
};

size_t length_V_bitRate = ARRAY_SIZE(VbitRate);

Zoom zoom[] = {
  { 0,  "1x"  },
  { 12,  "1.5x"},
  { 20, "2x"  },
  { 28, "2.5x"},
  { 32, "3x"  },
  { 36, "3.5x"},
  { 40, "4x"  },
  { 60, "8x"  },
};

size_t length_Zoom = ARRAY_SIZE(zoom);

pixel_format pixelformat[] = {
  { HAL_PIXEL_FORMAT_YCbCr_422_I, CameraParameters::PIXEL_FORMAT_YUV422I },
  { HAL_PIXEL_FORMAT_YCrCb_420_SP, CameraParameters::PIXEL_FORMAT_YUV420SP },
  { HAL_PIXEL_FORMAT_RGB_565, CameraParameters::PIXEL_FORMAT_RGB565 },
  { -1, CameraParameters::PIXEL_FORMAT_JPEG },
  { -1, CameraParameters::PIXEL_FORMAT_BAYER_RGGB },
  };

const char *gbce[] = {"disable", "enable"};

int VbitRateIDX = ARRAY_SIZE(VbitRate) - 1;

static unsigned int recording_counter = 1;

int dump_preview = 0;
int bufferStarvationTest = 0;
bool showfps = false;

const char *metering[] = {
    "center",
    "average",
};
int meter_mode = 0;
bool stressTest = false;
bool stopScript = false;
int restartCount = 0;
bool firstTime = true;
bool firstTimeStereo = true;

//TI extensions for enable/disable algos
const char *algoExternalGamma[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoNSF1[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoNSF2[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoSharpening[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoThreeLinColorMap[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoGIC[] = {CameraParameters::FALSE, CameraParameters::TRUE};
int algoExternalGammaIDX = 0;
int algoNSF1IDX = 1;
int algoNSF2IDX = 1;
int algoSharpeningIDX = 1;
int algoThreeLinColorMapIDX = 1;
int algoGICIDX = 1;

/** Buffer source reset */
bool bufferSourceInputReset = false;
bool bufferSourceOutputReset = false;

/** Gamma table */
const char *gammaTbl22 = "("
    "0:8,8:12,20:8,28:8,36:8,44:12,56:8,64:8,72:8,80:12,92:4,96:8,104:4,108:8,116:8,124:8,"
    "132:4,136:8,144:4,148:8,156:4,160:8,168:4,172:4,176:4,180:8,188:4,192:8,200:4,204:4,208:4,212:4,"
    "216:4,220:4,224:4,228:8,236:4,240:4,244:4,248:4,252:4,256:4,260:4,264:4,268:0,268:4,272:4,276:4,"
    "280:4,284:4,288:4,292:4,296:4,300:4,304:0,304:4,308:4,312:4,316:4,320:4,324:0,324:4,328:4,332:4,"
    "336:0,336:4,340:4,344:4,348:0,348:4,352:4,356:4,360:0,360:4,364:4,368:4,372:0,372:4,376:0,376:4,"
    "380:4,384:4,388:0,388:4,392:0,392:4,396:4,400:4,404:0,404:4,408:0,408:4,412:0,412:4,416:4,420:4,"
    "424:0,424:4,428:0,428:4,432:0,432:4,436:4,440:4,444:0,444:4,448:0,448:4,452:0,452:4,456:0,456:4,"
    "460:0,460:4,464:0,464:4,468:4,472:4,476:0,476:4,480:0,480:4,484:0,484:4,488:0,488:4,492:0,492:4,"
    "496:0,496:4,500:0,500:4,504:0,504:4,508:0,508:4,512:0,512:4,516:0,516:4,520:0,520:4,524:0,524:4,"
    "528:0,528:4,532:0,532:4,536:0,536:4,540:0,540:4,544:0,544:4,548:0,548:4,552:0,552:4,556:0,556:4,"
    "560:0,560:4,564:0,564:4,568:0,568:4,572:0,572:4,576:0,576:4,580:0,580:0,580:0,580:4,584:0,584:4,"
    "588:0,588:4,592:0,592:4,596:0,596:4,600:0,600:4,604:0,604:4,608:0,608:0,608:0,608:4,612:0,612:4,"
    "616:0,616:4,620:0,620:4,624:0,624:4,628:0,628:4,632:0,632:0,632:0,632:4,636:0,636:4,640:0,640:4,"
    "644:0,644:4,648:0,648:0,648:0,648:4,652:0,652:4,656:0,656:4,660:0,660:4,664:0,664:0,664:0,664:4,"
    "668:0,668:4,672:0,672:4,676:0,676:4,680:0,680:0,680:0,680:4,684:0,684:4,688:0,688:4,692:0,692:0,"
    "692:0,692:4,696:0,696:4,700:0,700:4,704:0,704:0,704:0,704:4,708:0,708:4,712:0,712:4,716:0,716:0,"
    "716:0,716:4,720:0,720:4,724:0,724:0,724:0,724:4,728:0,728:4,732:0,732:4,736:0,736:0,736:0,736:4,"
    "740:0,740:4,744:0,744:0,744:0,744:4,748:0,748:4,752:0,752:0,752:0,752:4,756:0,756:4,760:0,760:4,"
    "764:0,764:0,764:0,764:4,768:0,768:4,772:0,772:0,772:0,772:4,776:0,776:4,780:0,780:0,780:0,780:4,"
    "784:0,784:4,788:0,788:0,788:0,788:4,792:0,792:4,796:0,796:0,796:0,796:4,800:0,800:0,800:0,800:4,"
    "804:0,804:4,808:0,808:0,808:0,808:4,812:0,812:4,816:0,816:0,816:0,816:4,820:0,820:4,824:0,824:0,"
    "824:0,824:4,828:0,828:0,828:0,828:4,832:0,832:4,836:0,836:0,836:0,836:4,840:0,840:4,844:0,844:0,"
    "844:0,844:4,848:0,848:0,848:0,848:4,852:0,852:4,856:0,856:0,856:0,856:4,860:0,860:0,860:0,860:4,"
    "864:0,864:4,868:0,868:0,868:0,868:4,872:0,872:0,872:0,872:4,876:0,876:0,876:0,876:4,880:0,880:4,"
    "884:0,884:0,884:0,884:4,888:0,888:0,888:0,888:4,892:0,892:4,896:0,896:0,896:0,896:4,900:0,900:0,"
    "900:0,900:4,904:0,904:0,904:0,904:4,908:0,908:4,912:0,912:0,912:0,912:4,916:0,916:0,916:0,916:4,"
    "920:0,920:0,920:0,920:4,924:0,924:0,924:0,924:4,928:0,928:4,932:0,932:0,932:0,932:4,936:0,936:0,"
    "936:0,936:4,940:0,940:0,940:0,940:4,944:0,944:0,944:0,944:4,948:0,948:0,948:0,948:4,952:0,952:0,"
    "952:0,952:4,956:0,956:4,960:0,960:0,960:0,960:4,964:0,964:0,964:0,964:4,968:0,968:0,968:0,968:4,"
    "972:0,972:0,972:0,972:4,976:0,976:0,976:0,976:4,980:0,980:0,980:0,980:4,984:0,984:0,984:0,984:4,"
    "988:0,988:0,988:0,988:4,992:0,992:0,992:0,992:4,996:0,996:0,996:0,996:4,1000:0,1000:0,1000:0,1000:4,"
    "1004:0,1004:0,1004:0,1004:4,1008:0,1008:0,1008:0,1008:4,1012:0,1012:4,1016:0,1016:0,1016:0,1016:4,1020:0,1020:0"
    ")";
const char *gammaTbl0 = "("
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,"
    "4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0,4:0"
    ")";
const param_GammaTblList_t manualGammaModes[] = {
    {"Off",     NULL,       NULL,       NULL},
    {"White",   gammaTbl22, gammaTbl22, gammaTbl22},
    {"Yellow",  gammaTbl22, gammaTbl22, gammaTbl0},
    {"Cyan",    gammaTbl0,  gammaTbl22, gammaTbl22},
    {"Green",   gammaTbl0,  gammaTbl22, gammaTbl0},
    {"Magenta", gammaTbl22, gammaTbl0,  gammaTbl22},
    {"Red",     gammaTbl22, gammaTbl0,  gammaTbl0},
    {"Blue",    gammaTbl0,  gammaTbl0,  gammaTbl22},
    {"Black",   gammaTbl0,  gammaTbl0,  gammaTbl0}
};
int manualGammaModeIDX = 0;

/** Calculate delay from a reference time */
unsigned long long timeval_delay(const timeval *ref) {
    unsigned long long st, end, delay;
    timeval current_time;

    gettimeofday(&current_time, 0);

    st = ref->tv_sec * 1000000 + ref->tv_usec;
    end = current_time.tv_sec * 1000000 + current_time.tv_usec;
    delay = end - st;

    return delay;
}

/** Callback for takePicture() */
void my_raw_callback(const sp<IMemory>& mem) {

    static int      counter = 1;
    unsigned char   *buff = NULL;
    int             size;
    int             fd = -1;
    char            fn[384];

    LOG_FUNCTION_NAME;

    if (mem == NULL)
        goto out;

    if( strcmp(modevalues[capture_mode], "cp-cam") ) {
        //Start preview after capture.
        camera->startPreview();
    }

    fn[0] = 0;
    sprintf(fn, "%s/img%03d.raw", images_dir_path, counter);
    fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777);

    if (fd < 0)
        goto out;

    size = mem->size();

    if (size <= 0)
        goto out;

    buff = (unsigned char *)mem->pointer();

    if (!buff)
        goto out;

    if (size != write(fd, buff, size))
        printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno));

    counter++;
    printf("%s: buffer=%08X, size=%d stored at %s\n",
           __FUNCTION__, (int)buff, size, fn);

out:

    if (fd >= 0)
        close(fd);

    LOG_FUNCTION_NAME_EXIT;
}

void saveFile(const sp<IMemory>& mem) {
    static int      counter = 1;
    unsigned char   *buff = NULL;
    int             size;
    int             fd = -1;
    char            fn[384];

    LOG_FUNCTION_NAME;

    if (mem == NULL)
        goto out;

    fn[0] = 0;
    sprintf(fn, "%s/preview%03d.yuv", images_dir_path, counter);
    fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777);
    if(fd < 0) {
        CAMHAL_LOGE("Unable to open file %s: %s", fn, strerror(fd));
        goto out;
    }

    size = mem->size();
    if (size <= 0) {
        CAMHAL_LOGE("IMemory object is of zero size");
        goto out;
    }

    buff = (unsigned char *)mem->pointer();
    if (!buff) {
        CAMHAL_LOGE("Buffer pointer is invalid");
        goto out;
    }

    if (size != write(fd, buff, size))
        printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno));

    counter++;
    printf("%s: buffer=%08X, size=%d\n",
           __FUNCTION__, (int)buff, size);

out:

    if (fd >= 0)
        close(fd);

    LOG_FUNCTION_NAME_EXIT;
}


void debugShowFPS()
{
    static int mFrameCount = 0;
    static int mLastFrameCount = 0;
    static nsecs_t mLastFpsTime = 0;
    static float mFps = 0;
    mFrameCount++;
    if ( ( mFrameCount % 30 ) == 0 ) {
        nsecs_t now = systemTime();
        nsecs_t diff = now - mLastFpsTime;
        mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
        mLastFpsTime = now;
        mLastFrameCount = mFrameCount;
        printf("####### [%d] Frames, %f FPS", mFrameCount, mFps);
    }
}

/** Callback for startPreview() */
void my_preview_callback(const sp<IMemory>& mem) {

    printf("PREVIEW Callback 0x%x", ( unsigned int ) mem->pointer());
    if (dump_preview) {

        if(prevcnt==50)
        saveFile(mem);

        prevcnt++;

        uint8_t *ptr = (uint8_t*) mem->pointer();

        printf("PRV_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7], ptr[8], ptr[9]);

    }

    debugShowFPS();
}

/** Callback for takePicture() */
void my_jpeg_callback(const sp<IMemory>& mem) {
    static int  counter = 1;
    unsigned char   *buff = NULL;
    int     size;
    int     fd = -1;
    char        fn[384];

    LOG_FUNCTION_NAME;

    if( strcmp(modevalues[capture_mode], "cp-cam")) {
        if(burstCount > 1) {
            burstCount --;
            // Restart preview if taking a single capture
            // or after the last iteration of burstCount
        } else if(burstCount == 0 || burstCount == 1) {
            camera->startPreview();
            burstCount = burst;
        }
    }

    if (mem == NULL)
        goto out;

    fn[0] = 0;
    sprintf(fn, "%s/img%03d.jpg", images_dir_path, counter);
    fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777);

    if(fd < 0) {
        CAMHAL_LOGE("Unable to open file %s: %s", fn, strerror(fd));
        goto out;
    }

    size = mem->size();
    if (size <= 0) {
        CAMHAL_LOGE("IMemory object is of zero size");
        goto out;
    }

    buff = (unsigned char *)mem->pointer();
    if (!buff) {
        CAMHAL_LOGE("Buffer pointer is invalid");
        goto out;
    }

    if (size != write(fd, buff, size))
        printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno));

    counter++;
    printf("%s: buffer=%08X, size=%d stored at %s\n",
           __FUNCTION__, (int)buff, size, fn);

out:

    if (fd >= 0)
        close(fd);

    LOG_FUNCTION_NAME_EXIT;
}

void my_face_callback(camera_frame_metadata_t *metadata) {
    int idx;

    if ( NULL == metadata ) {
        return;
    }

    for ( idx = 0 ; idx < metadata->number_of_faces ; idx++ ) {
        printf("Face %d at %d,%d %d,%d \n",
               idx,
               metadata->faces[idx].rect[0],
               metadata->faces[idx].rect[1],
               metadata->faces[idx].rect[2],
               metadata->faces[idx].rect[3]);
    }

}

void CameraHandler::notify(int32_t msgType, int32_t ext1, int32_t ext2) {

    printf("Notify cb: %d %d %d\n", msgType, ext1, ext2);

    if ( msgType & CAMERA_MSG_FOCUS )
        printf("AutoFocus %s in %llu us\n", (ext1) ? "OK" : "FAIL", timeval_delay(&autofocus_start));

    if ( msgType & CAMERA_MSG_SHUTTER )
        printf("Shutter done in %llu us\n", timeval_delay(&picture_start));
    if ( msgType  == 1) {
        printf("Camera Test CAMERA_MSG_ERROR.....\n");
        if (stressTest)
          {
            printf("Camera Test Notified of Error Restarting.....\n");
            stopScript = true;
          }
        else
          {
            printf("Camera Test Notified of Error Stopping.....\n");
            stopScript =false;
            stopPreview();
            closeCamera();
            if (recordingMode)
              {
                stopRecording();
                closeRecorder();
                recordingMode = false;
              }
          }
      }
}

void CameraHandler::postData(int32_t msgType,
                             const sp<IMemory>& dataPtr,
                             camera_frame_metadata_t *metadata) {
    int32_t msgMask;
    printf("Data cb: %d\n", msgType);

    if ( msgType & CAMERA_MSG_PREVIEW_FRAME )
        my_preview_callback(dataPtr);

    msgMask = CAMERA_MSG_RAW_IMAGE;
#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
    msgMask |= CAMERA_MSG_RAW_BURST;
#endif
    if ( msgType & msgMask) {
        printf("RAW done in %llu us\n", timeval_delay(&picture_start));
        my_raw_callback(dataPtr);
    }

    if (msgType & CAMERA_MSG_POSTVIEW_FRAME) {
        printf("Postview frame %llu us\n", timeval_delay(&picture_start));
    }

    if (msgType & CAMERA_MSG_COMPRESSED_IMAGE ) {
        printf("JPEG done in %llu us\n", timeval_delay(&picture_start));
        my_jpeg_callback(dataPtr);
    }

    if ( ( msgType & CAMERA_MSG_PREVIEW_METADATA ) &&
         ( NULL != metadata ) ) {
        if (metaDataToggle) {
            printf("Preview exposure: %6d    Preview gain: %4d\n",
                   metadata->exposure_time, metadata->analog_gain);
        }

        if (faceDetectToggle) {
            printf("Face detected %d \n", metadata->number_of_faces);
            my_face_callback(metadata);
        }
    }
}

void CameraHandler::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)

{
    static uint32_t count = 0;

    //if(count==100)
    //saveFile(dataPtr);

    count++;

    uint8_t *ptr = (uint8_t*) dataPtr->pointer();

#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
    if ( msgType & CAMERA_MSG_RAW_BURST) {
        printf("RAW done timestamp: %llu\n", timestamp);
        my_raw_callback(dataPtr);
    } else
#endif
    {
        printf("Recording cb: %d %lld %p\n", msgType, timestamp, dataPtr.get());
        printf("VID_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7], ptr[8], ptr[9]);
        camera->releaseRecordingFrame(dataPtr);
    }
}

int createPreviewSurface(unsigned int width, unsigned int height, int32_t pixFormat) {
    unsigned int previewWidth, previewHeight;
    DisplayInfo dinfo;
    SurfaceComposerClient::getDisplayInfo(0, &dinfo);

    const unsigned MAX_PREVIEW_SURFACE_WIDTH = dinfo.w;
    const unsigned MAX_PREVIEW_SURFACE_HEIGHT = dinfo.h;

    if ( MAX_PREVIEW_SURFACE_WIDTH < width ) {
        previewWidth = MAX_PREVIEW_SURFACE_WIDTH;
    } else {
        previewWidth = width;
    }

    if ( MAX_PREVIEW_SURFACE_HEIGHT < height ) {
        previewHeight = MAX_PREVIEW_SURFACE_HEIGHT;
    } else {
        previewHeight = height;
    }

    client = new SurfaceComposerClient();

    if ( NULL == client.get() ) {
        printf("Unable to establish connection to Surface Composer \n");

        return -1;
    }

#ifdef ANDROID_API_JB_MR1_OR_LATER
    surfaceControl = client->createSurface(String8("camera_test_menu"),
            previewWidth, previewHeight, pixFormat, 0);
#else
    surfaceControl = client->createSurface(0,
            previewWidth, previewHeight, pixFormat, 0);
#endif

    previewSurface = surfaceControl->getSurface();

    client->openGlobalTransaction();
    surfaceControl->setLayer(0x7fffffff);
    surfaceControl->setPosition(0, 0);
    surfaceControl->setSize(previewWidth, previewHeight);
    surfaceControl->show();
    client->closeGlobalTransaction();

    return 0;
}

void printSupportedParams()
{
    printf("\n\r\tSupported Cameras: %s", params.get("camera-indexes"));
    printf("\n\r\tSupported Picture Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
    printf("\n\r\tSupported Picture Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS));
    printf("\n\r\tSupported Video Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
    printf("\n\r\tSupported Preview Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
    printf("\n\r\tSupported Preview Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS));
    printf("\n\r\tSupported Preview Frame Rates: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES));
    printf("\n\r\tSupported Thumbnail Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES));
    printf("\n\r\tSupported Whitebalance Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE));
    printf("\n\r\tSupported Effects: %s", params.get(CameraParameters::KEY_SUPPORTED_EFFECTS));
    printf("\n\r\tSupported Scene Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES));
    printf("\n\r\tSupported ISO Modes: %s", params.get("iso-mode-values"));
    printf("\n\r\tSupported Focus Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES));
    printf("\n\r\tSupported Antibanding Options: %s", params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING));
    printf("\n\r\tSupported Flash Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));
    printf("\n\r\tSupported Focus Areas: %d", params.getInt(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS));
    printf("\n\r\tSupported Metering Areas: %d", params.getInt(CameraParameters::KEY_MAX_NUM_METERING_AREAS));
    printf("\n\r\tSupported Preview FPS Range: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE));
    printf("\n\r\tSupported Exposure modes: %s", params.get("exposure-mode-values"));
    printf("\n\r\tSupported VSTAB modes: %s", params.get(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED));
    printf("\n\r\tSupported VNF modes: %s", params.get("vnf-supported"));
    printf("\n\r\tSupported AutoExposureLock: %s", params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED));
    printf("\n\r\tSupported AutoWhiteBalanceLock: %s", params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED));
    printf("\n\r\tSupported Zoom: %s", params.get(CameraParameters::KEY_ZOOM_SUPPORTED));
    printf("\n\r\tSupported Smooth Zoom: %s", params.get(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED));
    printf("\n\r\tSupported Video Snapshot: %s", params.get(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED));
    printf("\n\r\tSupported Capture modes: %s", params.get("mode-values"));

    if ( NULL != params.get(CameraParameters::KEY_FOCUS_DISTANCES) ) {
        printf("\n\r\tFocus Distances: %s \n", params.get(CameraParameters::KEY_FOCUS_DISTANCES));
    }

    return;
}


int destroyPreviewSurface() {

    if ( NULL != previewSurface.get() ) {
        previewSurface.clear();
    }

    if ( NULL != surfaceControl.get() ) {
        surfaceControl->clear();
        surfaceControl.clear();
    }

    if ( NULL != client.get() ) {
        client->dispose();
        client.clear();
    }

    return 0;
}

int openRecorder() {
    recorder = new MediaRecorder();

    if ( NULL == recorder.get() ) {
        printf("Error while creating MediaRecorder\n");

        return -1;
    }

    return 0;
}

int closeRecorder() {
    if ( NULL == recorder.get() ) {
        printf("invalid recorder reference\n");

        return -1;
    }

    if ( recorder->init() < 0 ) {
        printf("recorder failed to initialize\n");

        return -1;
    }

    if ( recorder->close() < 0 ) {
        printf("recorder failed to close\n");

        return -1;
    }

    if ( recorder->release() < 0 ) {
        printf("error while releasing recorder\n");

        return -1;
    }

    recorder.clear();

    return 0;
}

int configureRecorder() {

    char videoFile[384],vbit_string[50];
    videoFd = -1;
    struct CameraInfo cameraInfo;
    camera->getCameraInfo(camera_index, &cameraInfo);

    if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) {
        printf("invalid recorder and/or camera references\n");

        return -1;
    }

    camera->unlock();

    sprintf(vbit_string,"video-param-encoding-bitrate=%u", VbitRate[VbitRateIDX].bit_rate);
    String8 bit_rate(vbit_string);
    if ( recorder->setParameters(bit_rate) < 0 ) {
        printf("error while configuring bit rate\n");

        return -1;
    }

    if ( recorder->setCamera(camera->remote(), camera->getRecordingProxy()) < 0 ) {
        printf("error while setting the camera\n");

        return -1;
    }

    if ( recorder->setVideoSource(VIDEO_SOURCE_CAMERA) < 0 ) {
        printf("error while configuring camera video source\n");

        return -1;
    }


    if ( AUDIO_ENCODER_LIST_END != audioCodecs[audioCodecIDX].type ) {
        if ( recorder->setAudioSource(AUDIO_SOURCE_DEFAULT) < 0 ) {
            printf("error while configuring camera audio source\n");

            return -1;
        }
    }

    if ( recorder->setOutputFormat(outputFormat[outputFormatIDX].type) < 0 ) {
        printf("error while configuring output format\n");

        return -1;
    }

    sprintf(videoFile, "%s/video%d.%s", videos_dir_path, recording_counter, outputFormat[outputFormatIDX].desc);

    videoFd = open(videoFile, O_CREAT | O_RDWR);

    if(videoFd < 0){
        printf("Error while creating video filename\n");

        return -1;
    }

    if ( recorder->setOutputFile(videoFd, 0, 0) < 0 ) {
        printf("error while configuring video filename\n");

        return -1;
    }

    recording_counter++;

    if (cameraInfo.orientation == 90 || cameraInfo.orientation == 270 ) {
        if (Vcapture_Array[VcaptureSizeIDX]->height == 1080) {
            Vcapture_Array[VcaptureSizeIDX]->height = 1088;
        }
        if ( recorder->setVideoSize(Vcapture_Array[VcaptureSizeIDX]->height, Vcapture_Array[VcaptureSizeIDX]->width) < 0 ) {
            printf("error while configuring video size\n");
            return -1;
        }
    } else {
        if ( recorder->setVideoSize(Vcapture_Array[VcaptureSizeIDX]->width, Vcapture_Array[VcaptureSizeIDX]->height) < 0 ) {
            printf("error while configuring video size\n");
            return -1;
        }
    }

    if ( recorder->setVideoEncoder(videoCodecs[videoCodecIDX].type) < 0 ) {
        printf("error while configuring video codec\n");

        return -1;
    }

    if ( AUDIO_ENCODER_LIST_END != audioCodecs[audioCodecIDX].type ) {
        if ( recorder->setAudioEncoder(audioCodecs[audioCodecIDX].type) < 0 ) {
            printf("error while configuring audio codec\n");

            return -1;
        }
    }

    if ( recorder->setPreviewSurface( surfaceControl->getSurface() ) < 0 ) {
        printf("error while configuring preview surface\n");

        return -1;
    }

    return 0;
}

int startRecording() {
    if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) {
        printf("invalid recorder and/or camera references\n");

        return -1;
    }

    camera->unlock();

    if ( recorder->prepare() < 0 ) {
        printf("recorder prepare failed\n");

        return -1;
    }

    if ( recorder->start() < 0 ) {
        printf("recorder start failed\n");

        return -1;
    }

    return 0;
}

int stopRecording() {
    if ( NULL == recorder.get() ) {
        printf("invalid recorder reference\n");

        return -1;
    }

    if ( recorder->stop() < 0 ) {
        printf("recorder failed to stop\n");

        return -1;
    }

    if ( 0 < videoFd ) {
        close(videoFd);
    }

    return 0;
}

int openCamera() {

    antibandStr = new char [256];
    effectssStr = new char [256];
    exposureModeStr = new char [256];
    captureSizeStr = new char [500];
    VcaptureSizeStr = new char [500];
    previewSizeStr = new char [500];
    thumbnailSizeStr = new char [500];
    awbStr = new char [400];
    sceneStr = new char [400];
    isoModeStr = new char [256];
    focusStr = new char [256];
    flashStr = new char [256];
    fpsstr = new char [256];
    previewFormatStr = new char [256];
    pictureFormatStr = new char [256];
    constFramerate = new int[32];
    vstabstr = new char[256];
    vnfstr = new char[256];
    AutoExposureLockstr = new char[256];
    AutoWhiteBalanceLockstr = new char[256];
    zoomstr = new char[256];
    smoothzoomstr = new char[256];
    modevaluesstr = new char[256];
    videosnapshotstr = new char[256];
    autoconvergencestr = new char[256];
    layoutstr = new char[256];
    capturelayoutstr = new char[256];

    requestBufferSourceReset();

    printf("openCamera(camera_index=%d)\n", camera_index);
    camera = Camera::connect(camera_index);

    if ( NULL == camera.get() ) {
        printf("Unable to connect to CameraService\n");
        printf("Retrying... \n");
        sleep(1);
        camera = Camera::connect(camera_index);

        if ( NULL == camera.get() ) {
            printf("Giving up!! \n");
            return -1;
        }
    }

    if ( firstTime ) {
        params = camera->getParameters();
        firstTime = false;
    }
    getParametersFromCapabilities();
    getSizeParametersFromCapabilities();
    initDefaults();
    camera->setParameters(params.flatten());
    camera->setListener(new CameraHandler());

    hardwareActive = true;



    return 0;
}

int closeCamera() {
    if ( NULL == camera.get() ) {
        printf("invalid camera reference\n");

        return -1;
    }

    deleteAllocatedMemory();

    camera->disconnect();
    camera.clear();

    hardwareActive = false;
    return 0;
}

void createBufferOutputSource() {
    if(bufferSourceOutputThread.get() && bufferSourceOutputReset) {
        bufferSourceOutputThread->requestExit();
        bufferSourceOutputThread.clear();
    }
    if(!bufferSourceOutputThread.get()) {
#ifdef ANDROID_API_JB_OR_LATER
        bufferSourceOutputThread = new BQ_BufferSourceThread(123, camera);
#else
        bufferSourceOutputThread = new ST_BufferSourceThread(false, 123, camera);
#endif
        bufferSourceOutputThread->run();
    }
    bufferSourceOutputReset = false;
}

void createBufferInputSource() {
    if (bufferSourceInput.get() && bufferSourceInputReset) {
        bufferSourceInput.clear();
    }
    if (!bufferSourceInput.get()) {
#ifdef ANDROID_API_JB_OR_LATER
        bufferSourceInput = new BQ_BufferSourceInput(1234, camera);
#else
        bufferSourceInput = new ST_BufferSourceInput(1234, camera);
#endif
    }
    bufferSourceInputReset = false;
}

void requestBufferSourceReset() {
    bufferSourceInputReset = true;
    bufferSourceOutputReset = true;
}

int startPreview() {
    int previewWidth, previewHeight;
    struct CameraInfo cameraInfo;
    DisplayInfo dinfo;
    int orientation;
    unsigned int correctedHeight;

    SurfaceComposerClient::getDisplayInfo(0, &dinfo);

    printf ("dinfo.orientation = %d\n", dinfo.orientation);
    printf ("dinfo.w = %d\n", dinfo.w);
    printf ("dinfo.h = %d\n", dinfo.h);

    // calculate display orientation from sensor orientation
    camera->getCameraInfo(camera_index, &cameraInfo);
    if (cameraInfo.facing == CAMERA_FACING_FRONT) {
        orientation = (cameraInfo.orientation + dinfo.orientation) % 360;
        orientation = (360 - orientation) % 360;  // compensate the mirror
    } else {  // back-facing
        orientation = (cameraInfo.orientation - dinfo.orientation + 360) % 360;
    }


    if (reSizePreview) {
        int orientedWidth, orientedHeight;

        if(recordingMode)
        {
            previewWidth = Vcapture_Array[VcaptureSizeIDX]->width;
            previewHeight = Vcapture_Array[VcaptureSizeIDX]->height;
        }else
        {
            previewWidth = preview_Array[previewSizeIDX]->width;
            previewHeight = preview_Array[previewSizeIDX]->height;
        }

        // corrected height for aspect ratio
        if ((orientation == 90) || (orientation == 270)) {
            orientedHeight = previewWidth;
            orientedWidth = previewHeight;
        } else {
            orientedHeight = previewHeight;
            orientedWidth = previewWidth;
        }
        correctedHeight = (dinfo.w * orientedHeight) / orientedWidth;
        printf("correctedHeight = %d", correctedHeight);

        if ( createPreviewSurface(dinfo.w, correctedHeight,
                                  pixelformat[previewFormat].pixelFormatDesc) < 0 ) {
            printf("Error while creating preview surface\n");
            return -1;
        }

        if ( !hardwareActive ) {
            openCamera();
        }
        if(stereoMode && firstTimeStereo)
        {
             params.set(KEY_S3D_PRV_FRAME_LAYOUT, stereoLayout[stereoLayoutIDX]);
             params.set(KEY_S3D_CAP_FRAME_LAYOUT, stereoCapLayout[stereoCapLayoutIDX]);
        }

        if ((cameraInfo.orientation == 90 || cameraInfo.orientation == 270) && recordingMode) {
            params.setPreviewSize(previewHeight, previewWidth);
        } else {
            params.setPreviewSize(previewWidth, previewHeight);
        }
        params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);

        // calculate display orientation from sensor orientation
        camera->getCameraInfo(camera_index, &cameraInfo);
        if (cameraInfo.facing == CAMERA_FACING_FRONT) {
            orientation = (cameraInfo.orientation + dinfo.orientation) % 360;
            orientation= (360 - orientation) % 360;  // compensate the mirror
        } else {  // back-facing
            orientation = (cameraInfo.orientation - dinfo.orientation + 360) % 360;
        }

        if(!strcmp(params.get(KEY_MODE), "video-mode") ) {
            orientation = 0;
        }

        camera->sendCommand(CAMERA_CMD_SET_DISPLAY_ORIENTATION, orientation, 0);

        camera->setParameters(params.flatten());
        camera->setPreviewDisplay(previewSurface);
    }

    if(hardwareActive) prevcnt = 0;
    camera->startPreview();
    previewRunning = true;
    reSizePreview = false;

    const char *format = params.getPictureFormat();
    if((NULL != format) && isRawPixelFormat(format)) {
        createBufferOutputSource();
        createBufferInputSource();
    }

    return 0;
}

int getParametersFromCapabilities() {
    const char *valstr = NULL;

    numCamera = camera->getNumberOfCameras();

    params.unflatten(camera->getParameters());

    valstr = params.get(KEY_AUTOCONVERGENCE_MODE_VALUES);
    if (NULL != valstr) {
        strcpy(autoconvergencestr, valstr);
        getSupportedParameters(autoconvergencestr,&numAutoConvergence,(char***)&autoconvergencemode);
    } else {
        printf("no supported parameteters for autoconvergence\n\t");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_EFFECTS);
    if (NULL != valstr) {
        strcpy(effectssStr, valstr);
        getSupportedParameters(effectssStr, &numEffects, (char***)&effectss);
    } else {
        printf("Color effects are not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING);
    if (NULL != valstr) {
        strcpy(antibandStr, valstr);
        getSupportedParameters(antibandStr, &numAntibanding, (char***)&antiband);
    } else {
        printf("Antibanding not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE);
    if (NULL != valstr) {
        strcpy(awbStr, valstr);
        getSupportedParameters(awbStr, &numawb, (char***)&awb);
    } else {
        printf("White balance is not supported\n");
    }

    valstr = params.get(KEY_S3D_PRV_FRAME_LAYOUT_VALUES);
    if ((NULL != valstr) && (0 != strcmp(valstr, "none"))) {
        stereoMode = true;
        strcpy(layoutstr, valstr);
        getSupportedParameters(layoutstr,&numLay,(char***)&stereoLayout);
    } else {
        stereoMode = false;
        printf("layout is not supported\n");
    }

    valstr = params.get(KEY_S3D_CAP_FRAME_LAYOUT_VALUES);
    if ((NULL != valstr) && (0 != strcmp(valstr, "none"))) {
        strcpy(capturelayoutstr, valstr);
        getSupportedParameters(capturelayoutstr,&numCLay,(char***)&stereoCapLayout);
    } else {
        printf("capture layout is not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES);
    if (NULL != valstr) {
        strcpy(sceneStr, valstr);
        getSupportedParameters(sceneStr, &numscene, (char***)&scene);
    } else {
        printf("Scene modes are not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES);
    if (NULL != valstr) {
        strcpy(focusStr, valstr);
        getSupportedParameters(focusStr, &numfocus, (char***)&focus);
    } else {
        printf("Focus modes are not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
    if (NULL != valstr) {
        strcpy(flashStr, valstr);
        getSupportedParameters(flashStr, &numflash, (char***)&flash);
    } else {
        printf("Flash modes are not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
    if (NULL != valstr) {
        strcpy(VcaptureSizeStr, valstr);
        getSupportedParametersVideoCaptureSize(VcaptureSizeStr, &numVcaptureSize, VcaptureSize, lenght_Vcapture_size);
    } else {
        printf("Preview sizes are not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE);
    if (NULL != valstr) {
        strcpy(fpsstr, valstr);
        getSupportedParametersfps(fpsstr, &numfps);
    } else {
        printf("Preview fps range is not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
    if (NULL != valstr) {
        strcpy(previewFormatStr, valstr);
        getSupportedParameters(previewFormatStr, &numpreviewFormat, (char ***)&previewFormatArray);
    } else {
        printf("Preview formats are not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS);
    if (NULL != valstr) {
        strcpy(pictureFormatStr, valstr);
        getSupportedParameters(pictureFormatStr, &numpictureFormat, (char ***)&pictureFormatArray);
    } else {
        printf("Picture formats are not supported\n");
    }

    valstr = params.get("exposure-mode-values");
    if (NULL != valstr) {
        strcpy(exposureModeStr, valstr);
        getSupportedParameters(exposureModeStr, &numExposureMode, (char***)&exposureMode);
    } else {
        printf("Exposure modes are not supported\n");
    }

    valstr = params.get("iso-mode-values");
    if (NULL != valstr) {
        strcpy(isoModeStr, valstr);
        getSupportedParameters(isoModeStr, &numisoMode , (char***)&isoMode);
    } else {
        printf("iso modes are not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES);
    if (NULL != valstr) {
        strcpy(thumbnailSizeStr, valstr);
        getSupportedParametersThumbnailSize(thumbnailSizeStr, &numthumbnailSize, thumbnailSize, length_thumbnailSize);
    } else {
        printf("Thumbnail sizes are not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED);
    if (NULL != valstr) {
        strcpy(vstabstr, valstr);
    } else {
        printf("VSTAB is not supported\n");
    }

    valstr = params.get("vnf-supported");
    if (NULL != valstr) {
        strcpy(vnfstr, valstr);
    } else {
        printf("VNF is not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED);
    if (NULL != valstr) {
        strcpy(AutoExposureLockstr, valstr);
    } else {
        printf("AutoExposureLock is not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED);
    if (NULL != valstr) {
        strcpy(AutoWhiteBalanceLockstr, valstr);
    } else {
        printf("AutoWhiteBalanceLock is not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_ZOOM_SUPPORTED);
    if (NULL != valstr) {
        strcpy(zoomstr, valstr);
    } else {
        printf("Zoom is not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED);
    if (NULL != valstr) {
        strcpy(smoothzoomstr, valstr);
    } else {
        printf("SmoothZoom is not supported\n");
    }

    valstr = params.get("mode-values");
    if (NULL != valstr) {
        strcpy(modevaluesstr, valstr);
        getSupportedParameters(modevaluesstr, &nummodevalues , (char***)&modevalues);
    } else {
        printf("Mode values is not supported\n");
    }

    valstr = params.get(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED);
    if (NULL != valstr) {
        strcpy(videosnapshotstr, valstr);
    } else {
        printf("Video Snapshot is not supported\n");
    }

    if (params.get(KEY_SUPPORTED_MANUAL_CONVERGENCE_MIN) != NULL) {
        manualConvMin = params.getInt(KEY_SUPPORTED_MANUAL_CONVERGENCE_MIN);
    } else {
        printf("no supported parameteters for manual convergence min\n\t");
    }

    if (params.get(KEY_SUPPORTED_MANUAL_CONVERGENCE_MAX) != NULL) {
        manualConvMax = params.getInt(KEY_SUPPORTED_MANUAL_CONVERGENCE_MAX);
    } else {
        printf("no supported parameteters for manual convergence max\n\t");
    }

    if (params.get(KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP) != NULL) {
        manualConvStep = params.getInt(KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP);
    } else {
        printf("no supported parameteters for manual convergence step\n\t");
    }

    if (params.get(KEY_SUPPORTED_MANUAL_EXPOSURE_MIN) != NULL) {
        manualExpMin = params.getInt(KEY_SUPPORTED_MANUAL_EXPOSURE_MIN);
    } else {
        printf("no supported parameteters for manual exposure min\n\t");
    }

    if (params.get(KEY_SUPPORTED_MANUAL_EXPOSURE_MAX) != NULL) {
        manualExpMax = params.getInt(KEY_SUPPORTED_MANUAL_EXPOSURE_MAX);
    } else {
        printf("no supported parameteters for manual exposure max\n\t");
    }

    if (params.get(KEY_SUPPORTED_MANUAL_EXPOSURE_STEP) != NULL) {
        manualExpStep = params.getInt(KEY_SUPPORTED_MANUAL_EXPOSURE_STEP);
    } else {
        printf("no supported parameteters for manual exposure step\n\t");
    }

    if (params.get(KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN) != NULL) {
        manualGainMin = params.getInt(KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN);
    } else {
        printf("no supported parameteters for manual gain min\n\t");
    }

    if (params.get(KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX) != NULL) {
        manualGainMax = params.getInt(KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX);
    } else {
        printf("no supported parameteters for manual gain max\n\t");
    }

    if (params.get(KEY_SUPPORTED_MANUAL_GAIN_ISO_STEP) != NULL) {
        manualGainStep = params.getInt(KEY_SUPPORTED_MANUAL_GAIN_ISO_STEP);
    } else {
        printf("no supported parameteters for manual gain step\n\t");
    }

    return 0;
}

void getSizeParametersFromCapabilities() {
    if(!stereoMode) {
        if (params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES) != NULL) {
            strcpy(captureSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
        } else {
            printf("Picture sizes are not supported\n");
        }

        if (params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES) != NULL) {
            strcpy(previewSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
            strcpy(VcaptureSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
        } else {
            printf("Preview sizes are not supported\n");
        }
    } else { //stereo
        if(strcmp(stereoLayout[stereoLayoutIDX],"tb-full") == 0)
        {
                    if (params.get(KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES) != NULL) {
                        strcpy(previewSizeStr, params.get(KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES));
                        strcpy(VcaptureSizeStr, params.get(KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES));
                    } else {
                        printf("Preview sizes are not supported\n");
                    }
        }
        else  if(strcmp(stereoLayout[stereoLayoutIDX],"ss-full") == 0)
        {
                    if (params.get(KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES) != NULL) {
                        strcpy(previewSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES));
                        strcpy(VcaptureSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES));
                    } else {
                        printf("Preview sizes are not supported\n");
                    }
        }
        else  if(strcmp(stereoLayout[stereoLayoutIDX],"tb-subsampled") == 0)
        {
                    if (params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES) != NULL) {
                        strcpy(previewSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
                        strcpy(VcaptureSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
                    } else {
                        printf("Preview sizes are not supported\n");
                    }
        }
        else  if(strcmp(stereoLayout[stereoLayoutIDX],"ss-subsampled") == 0)
        {
                    if (params.get(KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES) != NULL) {
                        strcpy(previewSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES));
                        strcpy(VcaptureSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES));
                    } else {
                        printf("Preview sizes are not supported\n");
                    }
        }
        else
        {
                    printf("Preview sizes are not supported\n");
        }
        if(strcmp(stereoCapLayout[stereoCapLayoutIDX],"tb-full") == 0)
        {
                    if (params.get(KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES) != NULL) {
                        strcpy(captureSizeStr, params.get(KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES));
                    } else {
                        printf("Picture sizes are not supported\n");
                    }
        }
        else  if(strcmp(stereoCapLayout[stereoCapLayoutIDX],"ss-full") == 0)
        {
                    if (params.get(KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES) != NULL) {
                        strcpy(captureSizeStr, params.get(KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES));
                    } else {
                        printf("Picture sizes are not supported\n");
                    }
        }
        else
        {
                    printf("Picture sizes are not supported\n");
        }

    }
    getSupportedParametersCaptureSize(captureSizeStr, &numcaptureSize, captureSize, length_capture_Size);
    getSupportedParametersPreviewSize(previewSizeStr, &numpreviewSize, previewSize, length_previewSize);
    getSupportedParametersVideoCaptureSize(VcaptureSizeStr, &numVcaptureSize, VcaptureSize, lenght_Vcapture_size);
}

int getDefaultParameter(const char* val, int numOptions,  char **array) {
    int cnt = 0;

    if ((NULL == val) || (NULL == array)) {
        printf("Some default parameters are not valid");
        return 0;
    }

    for(cnt=0;cnt<numOptions;cnt++) {
        if (NULL == array[cnt]) {
            printf("Some parameter arrays are not valid");
            continue;
        }
        if (strcmp(val, array[cnt]) ==0 ) {
            return cnt;
        }
    }
    return 0;
}

int getDefaultParameterResol(const char* val, int numOptions,  param_Array **array) {
    int cnt = 0;

    for(cnt=0;cnt<numOptions;cnt++) {
        if (strcmp(val, array[cnt]->name) ==0 ) {
            return cnt;
        }
    }
    return 0;
}

int getSupportedParameters(char* parameters, int *optionsCount, char  ***elem) {
    str = new char [400];
    param = new char [400];
    int cnt = 0;

    strcpy(str, parameters);
    param = strtok(str, ",");
    *elem = new char*[30];

    while (param != NULL) {
        (*elem)[cnt] = new char[strlen(param) + 1];
        strcpy((*elem)[cnt], param);
        param = strtok (NULL, ",");
        cnt++;
    }
    *optionsCount = cnt;
    return 0;
}

int getSupportedParametersfps(char* parameters, int *optionsCount) {
    str = new char [400];
    param = new char [400];
    int cnt = 0;
    constCnt = 0;
    rangeCnt = 0;
    strcpy(str, parameters);
    fps_const_str = new char*[32];
    fps_range_str = new char*[32];
    rangeDescription = new char*[32];
    fpsArray = new fps_Array[50];
    param = strtok(str, "(,)");

    while (param != NULL) {
        fps_const_str[constCnt] = new char;
        fps_range_str[rangeCnt] = new char;
        rangeDescription[rangeCnt] = new char;
        fpsArray[cnt].rangeMin = atoi(param);
        param = strtok (NULL, "(,)");
        fpsArray[cnt].rangeMax = atoi(param);
        param = strtok (NULL, "(,)");
        if (fpsArray[cnt].rangeMin == fpsArray[cnt].rangeMax) {
            sprintf(fps_const_str[constCnt], "%d,%d", fpsArray[cnt].rangeMin, fpsArray[cnt].rangeMax);
            constFramerate[constCnt] = fpsArray[cnt].rangeMin/1000;
            sprintf(fps_range_str[rangeCnt], "%d,%d", fpsArray[cnt].rangeMin, fpsArray[cnt].rangeMax);
            sprintf(rangeDescription[rangeCnt], "[%d:%d]", fpsArray[cnt].rangeMin/1000, fpsArray[cnt].rangeMax/1000);
            constCnt ++;
            rangeCnt ++;

        } else {
            sprintf(fps_range_str[rangeCnt], "%d,%d", fpsArray[cnt].rangeMin, fpsArray[cnt].rangeMax);
            sprintf(rangeDescription[rangeCnt], "[%d:%d]", fpsArray[cnt].rangeMin/1000, fpsArray[cnt].rangeMax/1000);
            rangeCnt ++;
        }

        cnt++;
    }
    *optionsCount = cnt;
    return 0;
}


int getSupportedParametersCaptureSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
    str = new char [400];
    param = new char [400];
    int cnt = 0;
    strcpy(str, parameters);
    param = strtok(str, ",x");
    capture_Array = new param_Array*[50];
    while (param != NULL) {

        capture_Array[cnt] = new param_Array;
        capture_Array[cnt]->width = atoi(param);
        param = strtok (NULL, ",x");
        capture_Array[cnt]->height = atoi(param);
        param = strtok (NULL, ",x");

        int x = getSupportedParametersNames(capture_Array[cnt]->width,
                capture_Array[cnt]->height, array, arraySize);

        if (x > -1) {
            strcpy(capture_Array[cnt]->name, array[x].name);
        } else {
            strcpy(capture_Array[cnt]->name, "Needs to be added/Not supported");
        }

        cnt++;
    }

    *optionsCount = cnt;
    return 0;
}

int getSupportedParametersVideoCaptureSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
    str = new char [800];
    param = new char [800];
    int cnt = 0;
    strcpy(str, parameters);
    param = strtok(str, ",x");
    Vcapture_Array = new param_Array*[100];
    while (param != NULL) {

        Vcapture_Array[cnt] = new param_Array;
        Vcapture_Array[cnt]->width = atoi(param);
        param = strtok (NULL, ",x");
        Vcapture_Array[cnt]->height = atoi(param);
        param = strtok (NULL, ",x");

        int x = getSupportedParametersNames(Vcapture_Array[cnt]->width,
                Vcapture_Array[cnt]->height, array, arraySize);

        if (x > -1) {
            strcpy(Vcapture_Array[cnt]->name, array[x].name);
        } else {
            strcpy(Vcapture_Array[cnt]->name, "Needs to be added/Not supported");
        }

        cnt++;
    }

    *optionsCount = cnt;
    return 0;
}

int getSupportedParametersPreviewSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
    str = new char [500];
    param = new char [500];
    int cnt = 0;
    strcpy(str, parameters);
    param = strtok(str, ",x");
    preview_Array = new param_Array*[60];
    while (param != NULL) {
        preview_Array[cnt] = new param_Array;
        preview_Array[cnt]->width = atoi(param);
        param = strtok (NULL, ",x");
        preview_Array[cnt]->height = atoi(param);
        param = strtok (NULL, ",x");

        int x = getSupportedParametersNames(preview_Array[cnt]->width,
                preview_Array[cnt]->height, array, arraySize);
        if (x > -1) {
            strcpy(preview_Array[cnt]->name, array[x].name);
        } else {
            strcpy(preview_Array[cnt]->name, "Needs to be added/Not supported");
        }

        cnt++;
    }

    *optionsCount = cnt;
    return 0;
}

int getSupportedParametersThumbnailSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
    str = new char [500];
    param = new char [500];
    int cnt = 0;
    strcpy(str, parameters);
    param = strtok(str, ",x");
    thumbnail_Array = new param_Array*[60];
    while (param != NULL) {
        thumbnail_Array[cnt] = new param_Array;
        thumbnail_Array[cnt]->width = atoi(param);
        param = strtok (NULL, ",x");
        thumbnail_Array[cnt]->height = atoi(param);
        param = strtok (NULL, ",x");

        int x = getSupportedParametersNames(thumbnail_Array[cnt]->width,
                thumbnail_Array[cnt]->height, array, arraySize);
        if (x > -1) {
            strcpy(thumbnail_Array[cnt]->name, array[x].name);
        } else {
            strcpy(thumbnail_Array[cnt]->name, "Needs to be added/Not supported");
        }

        cnt++;
    }

    *optionsCount = cnt;
    return 0;
}

int getSupportedParametersNames(int width, int height, param_Array array[], int arraySize) {
    for (int i = 0; i<arraySize; i++) {

        if ((width == array[i].width) && (height == array[i].height)) {
            return (i);
        }
    }
    return -1;
}

int deleteAllocatedMemory() {
    int i;

    for (i=0; i<numAntibanding; i++){
        delete [] antiband[i];
    }




    for (i=0; i<numEffects; i++){
        delete [] effectss[i];
    }

    for (i=0; i<numExposureMode; i++){
        delete [] exposureMode[i];
    }

    for (i=0; i<numawb; i++) {
        delete [] awb[i];
    }

    for (i=0; i<numscene; i++){
        delete [] scene[i];
    }

    for (i=0; i<numfocus; i++){
        delete [] focus[i];
    }

    for (i=0; i<numflash; i++){
        delete [] flash[i];
    }

    for (i=0; i<numpreviewSize; i++){
        delete [] preview_Array[i];
    }

    for (i=0; i<numcaptureSize; i++){
        delete [] capture_Array[i];
    }

    for (i=0; i<numVcaptureSize; i++){
        delete [] Vcapture_Array[i];
    }

    for (i=0; i<numthumbnailSize; i++){
        delete [] thumbnail_Array[i];
    }

    for (i=0; i<constCnt; i++){
        delete [] fps_const_str[i];
    }

    for (i=0; i<rangeCnt; i++){
        delete [] fps_range_str[i];
    }

    for (i=0; i<rangeCnt; i++){
        delete [] rangeDescription[i];
    }

    for (i=0; i<numpreviewFormat; i++){
        delete [] previewFormatArray[i];
    }

    for (i=0; i<numpictureFormat; i++){
        delete [] pictureFormatArray[i];
    }

    for (i=0; i<nummodevalues; i++){
        delete [] modevalues[i];
    }

    if (numLay) {
        for (i = 0; i < numLay; i++) {
            delete [] stereoLayout[i];
        }
        numLay = 0;
    }

    if (numCLay) {
        for (i = 0; i < numCLay; i++) {
            delete [] stereoCapLayout[i];
        }
        numCLay = 0;
    }

    delete [] antibandStr;
    delete [] effectssStr;
    delete [] exposureModeStr;
    delete [] awbStr;
    delete [] sceneStr;
    delete [] focusStr;
    delete [] flashStr;
    delete [] previewSizeStr;
    delete [] captureSizeStr;
    delete [] VcaptureSizeStr;
    delete [] thumbnailSizeStr;
    delete [] fpsstr;
    delete [] previewFormatStr;
    delete [] pictureFormatStr;
    delete [] fpsArray;
    delete [] vstabstr;
    delete [] vnfstr;
    delete [] isoModeStr;
    delete [] AutoExposureLockstr;
    delete [] AutoWhiteBalanceLockstr;
    delete [] zoomstr;
    delete [] smoothzoomstr;
    delete [] modevaluesstr;
    delete [] videosnapshotstr;
    delete [] autoconvergencestr;
    delete [] layoutstr;
    delete [] capturelayoutstr;

    // Release buffer sources if any
    if (bufferSourceOutputThread.get()) {
        bufferSourceOutputThread->requestExit();
        bufferSourceOutputThread.clear();
    }
    if ( bufferSourceInput.get() ) {
        bufferSourceInput.clear();
    }

    return 0;
}

int trySetVideoStabilization(bool toggle) {
    if (strcmp(vstabstr, "true") == 0) {
        params.set(params.KEY_VIDEO_STABILIZATION, toggle ? params.TRUE : params.FALSE);
        return 0;
    }
    return 0;
}

int trySetVideoNoiseFilter(bool toggle) {
    if (strcmp(vnfstr, "true") == 0) {
        params.set("vnf", toggle ? params.TRUE : params.FALSE);
        return 0;
    }
    return 0;
}

int trySetAutoExposureLock(bool toggle) {
    if (strcmp(AutoExposureLockstr, "true") == 0) {
        params.set(KEY_AUTO_EXPOSURE_LOCK, toggle ? params.TRUE : params.FALSE);
        return 0;
    }
    return 0;
}

int trySetAutoWhiteBalanceLock(bool toggle) {
    if (strcmp(AutoWhiteBalanceLockstr, "true") == 0) {
        params.set(KEY_AUTO_WHITEBALANCE_LOCK, toggle ? params.TRUE : params.FALSE);
        return 0;
    }
    return 0;
}

bool isRawPixelFormat (const char *format) {
    bool ret = false;
    if ((0 == strcmp (format, CameraParameters::PIXEL_FORMAT_YUV422I)) ||
        (0 == strcmp (format, CameraParameters::PIXEL_FORMAT_YUV420SP)) ||
        (0 == strcmp (format, CameraParameters::PIXEL_FORMAT_RGB565)) ||
        (0 == strcmp (format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB))) {
        ret = true;
    }
    return ret;
}

void stopPreview() {
    if ( hardwareActive ) {
        camera->stopPreview();

        destroyPreviewSurface();

        previewRunning  = false;
        reSizePreview = true;
    }
}

void initDefaults() {

    struct CameraInfo cameraInfo;

    camera->getCameraInfo(camera_index, &cameraInfo);
    if (cameraInfo.facing == CAMERA_FACING_FRONT) {
        rotation = cameraInfo.orientation;
    } else {  // back-facing
        rotation = cameraInfo.orientation;
    }

    antibanding_mode = getDefaultParameter("off", numAntibanding, antiband);
    focus_mode = getDefaultParameter("auto", numfocus, focus);
    fpsRangeIdx = getDefaultParameter("5000,30000", rangeCnt, fps_range_str);
    afTimeoutIdx = 0;
    previewSizeIDX = getDefaultParameterResol("VGA", numpreviewSize, preview_Array);
    captureSizeIDX = getDefaultParameterResol("12MP", numcaptureSize, capture_Array);
    frameRateIDX = getDefaultParameter("30000,30000", constCnt, fps_const_str);
    VcaptureSizeIDX = getDefaultParameterResol("HD", numVcaptureSize, Vcapture_Array);
    VbitRateIDX = 0;
    thumbSizeIDX = getDefaultParameterResol("VGA", numthumbnailSize, thumbnail_Array);
    compensation = 0.0;
    awb_mode = getDefaultParameter("auto", numawb, awb);
    effects_mode = getDefaultParameter("none", numEffects, effectss);
    scene_mode = getDefaultParameter("auto", numscene, scene);
    caf_mode = 0;

    shotConfigFlush = false;
    streamCapture = false;
    vstabtoggle = false;
    vnftoggle = false;
    AutoExposureLocktoggle = false;
    AutoWhiteBalanceLocktoggle = false;
    faceDetectToggle = false;
    metaDataToggle = false;
    expBracketIdx = BRACKETING_IDX_DEFAULT;
    flashIdx = getDefaultParameter("off", numflash, flash);
    previewRotation = 0;
    zoomIDX = 0;
    videoCodecIDX = 0;
    gbceIDX = 0;
    glbceIDX = 0;
    contrast = 100;
#ifdef TARGET_OMAP4
    ///Temporary fix until OMAP3 and OMAP4 3A values are synced
    brightness = 50;
    sharpness = 100;
#else
    brightness = 100;
    sharpness = 0;
#endif
    saturation = 100;
    iso_mode = getDefaultParameter("auto", numisoMode, isoMode);
    capture_mode = getDefaultParameter("high-quality", nummodevalues, modevalues);
    exposure_mode = getDefaultParameter("auto", numExposureMode, exposureMode);
    ippIDX = 0;
    ippIDX_old = ippIDX;
    jpegQuality = 85;
    bufferStarvationTest = 0;
    meter_mode = 0;
    previewFormat = getDefaultParameter("yuv420sp", numpreviewFormat, previewFormatArray);
    pictureFormat = getDefaultParameter("jpeg", numpictureFormat, pictureFormatArray);
    stereoCapLayoutIDX = 0;
    stereoLayoutIDX = 1;
    manualConv = 0;
    manualExp = manualExpMin;
    manualGain = manualGainMin;

    algoExternalGammaIDX = 0;
    algoNSF1IDX = 1;
    algoNSF2IDX = 1;
    algoSharpeningIDX = 1;
    algoThreeLinColorMapIDX = 1;
    algoGICIDX = 1;

    manualGammaModeIDX = 0;

    params.set(params.KEY_VIDEO_STABILIZATION, params.FALSE);
    params.set("vnf", params.FALSE);
    params.setPreviewSize(preview_Array[previewSizeIDX]->width, preview_Array[previewSizeIDX]->height);
    params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
    params.set(CameraParameters::KEY_ROTATION, rotation);
    params.set(KEY_SENSOR_ORIENTATION, previewRotation);
    params.set(KEY_COMPENSATION, (int) (compensation * 10));
    params.set(params.KEY_WHITE_BALANCE, awb[awb_mode]);
    params.set(KEY_MODE, (modevalues[capture_mode]));
    params.set(params.KEY_SCENE_MODE, scene[scene_mode]);
    params.set(KEY_CAF, caf_mode);
    params.set(KEY_ISO, isoMode[iso_mode]);
    params.set(KEY_GBCE, gbce[gbceIDX]);
    params.set(KEY_GLBCE, gbce[glbceIDX]);
    params.set(KEY_SHARPNESS, sharpness);
    params.set(KEY_CONTRAST, contrast);
    params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
    params.set(KEY_EXPOSURE, exposureMode[exposure_mode]);
    params.set(KEY_BRIGHTNESS, brightness);
    params.set(KEY_SATURATION, saturation);
    params.set(params.KEY_EFFECT, effectss[effects_mode]);
    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
    params.set(params.KEY_ANTIBANDING, antiband[antibanding_mode]);
    params.set(params.KEY_FOCUS_MODE, focus[focus_mode]);
    params.set(KEY_IPP, ipp_mode[ippIDX]);
    params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
    params.setPreviewFormat(previewFormatArray[previewFormat]);
    params.setPictureFormat(pictureFormatArray[pictureFormat]);
    params.set(KEY_BUFF_STARV, bufferStarvationTest);
    params.set(KEY_METERING_MODE, metering[meter_mode]);
    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, thumbnail_Array[thumbSizeIDX]->width);
    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, thumbnail_Array[thumbSizeIDX]->height);
    params.set(KEY_MANUAL_CONVERGENCE, manualConv);
    params.set(KEY_MANUAL_EXPOSURE, manualExp);
    params.set(KEY_MANUAL_GAIN_ISO, manualGain);
    params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
    params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
    params.set(KEY_S3D2D_PREVIEW_MODE, "off");
    params.set(KEY_EXIF_MODEL, MODEL);
    params.set(KEY_EXIF_MAKE, MAKE);

    setDefaultExpGainPreset(shotParams, expBracketIdx);
}

void setDefaultExpGainPreset(ShotParameters &params, int idx) {
    if ( ((int)ARRAY_SIZE(expBracketing) > idx) && (0 <= idx) ) {
        setExpGainPreset(params, expBracketing[idx].value, false, expBracketing[idx].param_type, shotConfigFlush);
    } else {
        printf("setDefaultExpGainPreset: Index (%d) is out of range 0 ~ %u\n", idx, ARRAY_SIZE(expBracketing) - 1);
    }
}

void setSingleExpGainPreset(ShotParameters &params, int idx, int exp, int gain) {
    String8 val;

    if (PARAM_EXP_BRACKET_PARAM_PAIR == expBracketing[idx].param_type) {
        val.append("(");
    }

    if (PARAM_EXP_BRACKET_VALUE_REL == expBracketing[idx].value_type) {
        val.appendFormat("%+d", exp);
    } else {
        val.appendFormat("%u", (unsigned int) exp);
    }

    if (PARAM_EXP_BRACKET_PARAM_PAIR == expBracketing[idx].param_type) {
        if (PARAM_EXP_BRACKET_VALUE_REL == expBracketing[idx].value_type) {
            val.appendFormat(",%+d)", gain);
        } else {
            val.appendFormat(",%u)", (unsigned int) gain);
        }
    }

    if (PARAM_EXP_BRACKET_APPLY_FORCED == expBracketing[idx].apply_type) {
        val.append("F");
    }

    setExpGainPreset(params, val, false, expBracketing[idx].param_type, false);
}

void setExpGainPreset(ShotParameters &params, const char *input, bool force, param_ExpBracketParamType_t type, bool flush) {
    const char *startPtr = NULL;
    size_t i = 0;

    if (NULL == input) {
        printf("setExpGainPreset: missing input string\n");
    } else if ( (force && (NULL == strpbrk(input, "()"))) ||
         (PARAM_EXP_BRACKET_PARAM_COMP == type) ) {
        // parse for the number of inputs (count the number of ',' + 1)
        startPtr = strchr(input, ',');
        while (startPtr != NULL) {
            i++;
            startPtr = strchr(startPtr + 1, ',');
        }
        i++;
        printf("relative EV input: \"%s\"\nnumber of relative EV values: %d (%s)\n",
               input, i, flush ? "reset" : "append");
        burst = i;
        burstCount = i;
        params.set(ShotParameters::KEY_BURST, burst);
        params.set(ShotParameters::KEY_EXP_COMPENSATION, input);
        params.remove(ShotParameters::KEY_EXP_GAIN_PAIRS);
        params.set(ShotParameters::KEY_FLUSH_CONFIG,
                       flush ? ShotParameters::TRUE : ShotParameters::FALSE);
    } else if ( force || (PARAM_EXP_BRACKET_PARAM_PAIR == type) ) {
        // parse for the number of inputs (count the number of '(')
        startPtr = strchr(input, '(');
        while (startPtr != NULL) {
            i++;
            startPtr = strchr(startPtr + 1, '(');
        }
        printf("absolute exposure,gain input: \"%s\"\nNumber of brackets: %d (%s)\n",
               input, i, flush ? "reset" : "append");
        burst = i;
        burstCount = i;
        params.set(ShotParameters::KEY_BURST, burst);
        params.set(ShotParameters::KEY_EXP_GAIN_PAIRS, input);
        params.remove(ShotParameters::KEY_EXP_COMPENSATION);
        params.set(ShotParameters::KEY_FLUSH_CONFIG,
                       flush ? ShotParameters::TRUE : ShotParameters::FALSE);
    } else {
        printf("no bracketing input: \"%s\"\n", input);
        params.remove(ShotParameters::KEY_EXP_GAIN_PAIRS);
        params.remove(ShotParameters::KEY_EXP_COMPENSATION);
        params.remove(ShotParameters::KEY_BURST);
        params.remove(ShotParameters::KEY_FLUSH_CONFIG);
    }
}

void calcNextSingleExpGainPreset(int idx, int &exp, int &gain) {
    if (PARAM_EXP_BRACKET_VALUE_ABS == expBracketing[idx].value_type) {
        // absolute
        if ( (0 == exp) && (0 == gain) ) {
            exp=100;
            gain = 150;
            printf("Streaming: Init default absolute exp./gain: %d,%d\n", exp, gain);
        }

        exp *= 2;
        if (1000000 < exp) {
            exp = 100;
            gain += 50;
            if(400 < gain) {
                gain = 50;
            }
        }
    } else {
        // relative
        exp += 50;
        if (200 < exp) {
            exp = -200;
            gain += 50;
            if(200 < gain) {
                gain = -200;
            }
        }
    }
}

void updateShotConfigFlushParam() {
    // Will update flush shot config parameter if already present
    // Otherwise, keep empty (will be set later in setExpGainPreset())
    if (NULL != shotParams.get(ShotParameters::KEY_FLUSH_CONFIG)) {
        shotParams.set(ShotParameters::KEY_FLUSH_CONFIG,
                       shotConfigFlush ? ShotParameters::TRUE : ShotParameters::FALSE);
    }
}

int menu_gps() {
    char ch;
    char coord_str[100];

    if (print_menu) {
        printf("\n\n== GPS MENU ============================\n\n");
        printf("   e. Latitude:       %.7lf\n", latitude);
        printf("   d. Longitude:      %.7lf\n", longitude);
        printf("   c. Altitude:       %.7lf\n", altitude);
        printf("\n");
        printf("   q. Return to main menu\n");
        printf("\n");
        printf("   Choice: ");
    }

    ch = getchar();
    printf("%c", ch);

    print_menu = 1;

    switch (ch) {

        case 'e':
            latitude += degree_by_step;

            if (latitude > 90.0) {
                latitude -= 180.0;
            }

            snprintf(coord_str, 7, "%.7lf", latitude);
            params.set(params.KEY_GPS_LATITUDE, coord_str);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'd':
            longitude += degree_by_step;

            if (longitude > 180.0) {
                longitude -= 360.0;
            }

            snprintf(coord_str, 7, "%.7lf", longitude);
            params.set(params.KEY_GPS_LONGITUDE, coord_str);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'c':
            altitude += 12345.67890123456789;

            if (altitude > 100000.0) {
                altitude -= 200000.0;
            }

            snprintf(coord_str, 100, "%.20lf", altitude);
            params.set(params.KEY_GPS_ALTITUDE, coord_str);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'q':
            return -1;

        default:
            print_menu = 0;
            break;
    }

    return 0;
}

int menu_algo() {
    char ch;

    if (print_menu) {
        printf("\n\n== ALGO ENABLE/DISABLE MENU ============\n\n");
        printf("   a.                   External Gamma: %s\n", algoExternalGamma[algoExternalGammaIDX]);
        printf("   s.                             NSF1: %s\n", algoNSF1[algoNSF1IDX]);
        printf("   d.                             NSF2: %s\n", algoNSF2[algoNSF2IDX]);
        printf("   f.                       Sharpening: %s\n", algoSharpening[algoSharpeningIDX]);
        printf("   g.                 Color Conversion: %s\n", algoThreeLinColorMap[algoThreeLinColorMapIDX]);
        printf("   h.      Green Inballance Correction: %s\n", algoGIC[algoGICIDX]);
        printf("   j.               Manual gamma table: %s\n", manualGammaModes[manualGammaModeIDX].desc);
        printf("\n");
        printf("   q. Return to main menu\n");
        printf("\n");
        printf("   Choice: ");
    }

    ch = getchar();
    printf("%c", ch);

    print_menu = 1;

    switch (ch) {

        case 'a':
        case 'A':
            algoExternalGammaIDX++;
            algoExternalGammaIDX %= ARRAY_SIZE(algoExternalGamma);
            params.set(KEY_ALGO_EXTERNAL_GAMMA, (algoExternalGamma[algoExternalGammaIDX]));

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 's':
        case 'S':
            algoNSF1IDX++;
            algoNSF1IDX %= ARRAY_SIZE(algoNSF1);
            params.set(KEY_ALGO_NSF1, (algoNSF1[algoNSF1IDX]));

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'd':
        case 'D':
            algoNSF2IDX++;
            algoNSF2IDX %= ARRAY_SIZE(algoNSF2);
            params.set(KEY_ALGO_NSF2, (algoNSF2[algoNSF2IDX]));

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'f':
        case 'F':
            algoSharpeningIDX++;
            algoSharpeningIDX %= ARRAY_SIZE(algoSharpening);
            params.set(KEY_ALGO_SHARPENING, (algoSharpening[algoSharpeningIDX]));

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'g':
        case 'G':
            algoThreeLinColorMapIDX++;
            algoThreeLinColorMapIDX %= ARRAY_SIZE(algoThreeLinColorMap);
            params.set(KEY_ALGO_THREELINCOLORMAP, (algoThreeLinColorMap[algoThreeLinColorMapIDX]));

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'h':
        case 'H':
            algoGICIDX++;
            algoGICIDX %= ARRAY_SIZE(algoGIC);
            params.set(KEY_ALGO_GIC, (algoGIC[algoGICIDX]));

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'j':
        case 'J':
            manualGammaModeIDX++;
            manualGammaModeIDX %= ARRAY_SIZE(manualGammaModes);
            if ( (NULL != manualGammaModes[manualGammaModeIDX].r) &&
                 (NULL != manualGammaModes[manualGammaModeIDX].g) &&
                 (NULL != manualGammaModes[manualGammaModeIDX].b) ) {
                String8 Val;
                Val.append(manualGammaModes[manualGammaModeIDX].r);
                Val.append(",");
                Val.append(manualGammaModes[manualGammaModeIDX].g);
                Val.append(",");
                Val.append(manualGammaModes[manualGammaModeIDX].b);
                params.set(KEY_GAMMA_TABLE, Val);
            } else {
                params.remove(KEY_GAMMA_TABLE);
            }

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'Q':
        case 'q':
            return -1;

        default:
            print_menu = 0;
            break;
    }

    return 0;
}

int functional_menu() {
    char ch;
    char area1[MAX_LINES][MAX_SYMBOLS+1];
    char area2[MAX_LINES][MAX_SYMBOLS+1];
    int j = 0;
    int k = 0;
    const char *valstr = NULL;
    struct CameraInfo cameraInfo;
    bool queueEmpty = true;

    memset(area1, '\0', MAX_LINES*(MAX_SYMBOLS+1));
    memset(area2, '\0', MAX_LINES*(MAX_SYMBOLS+1));

    if (print_menu) {

        printf("\n========================================= FUNCTIONAL TEST MENU =========================================\n");

        snprintf(area1[j++], MAX_SYMBOLS, "   START / STOP / GENERAL SERVICES");
        snprintf(area1[j++], MAX_SYMBOLS, "   -----------------------------");
        snprintf(area1[j++], MAX_SYMBOLS, "A  Select Camera %s", cameras[camera_index]);
        snprintf(area1[j++], MAX_SYMBOLS, "[. Resume Preview after capture");
        snprintf(area1[j++], MAX_SYMBOLS, "0. Reset to defaults");
        snprintf(area1[j++], MAX_SYMBOLS, "q. Quit");
        snprintf(area1[j++], MAX_SYMBOLS, "@. Disconnect and Reconnect to CameraService");
        snprintf(area1[j++], MAX_SYMBOLS, "/. Enable/Disable showfps: %s", ((showfps)? "Enabled":"Disabled"));
        snprintf(area1[j++], MAX_SYMBOLS, "a. GEO tagging settings menu");
        snprintf(area1[j++], MAX_SYMBOLS, "E. Camera Capability Dump");

        snprintf(area1[j++], MAX_SYMBOLS, "        PREVIEW SUB MENU");
        snprintf(area1[j++], MAX_SYMBOLS, "   -----------------------------");
        snprintf(area1[j++], MAX_SYMBOLS, "1. Start Preview");
        snprintf(area1[j++], MAX_SYMBOLS, "2. Stop Preview");
        snprintf(area1[j++], MAX_SYMBOLS, "~. Preview format %s", previewFormatArray[previewFormat]);
#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
        snprintf(area1[j++], MAX_SYMBOLS, "4. Preview size: %4d x %4d - %s",preview_Array[previewSizeIDX]->width,  preview_Array[previewSizeIDX]->height, preview_Array[previewSizeIDX]->name);
#else
        snprintf(area1[j++], MAX_SYMBOLS, "4. Preview size: %4d x %4d - %s",preview_Array[previewSizeIDX]->width, stereoMode ? preview_Array[previewSizeIDX]->height*2 : preview_Array[previewSizeIDX]->height, preview_Array[previewSizeIDX]->name);
#endif
        snprintf(area1[j++], MAX_SYMBOLS, "R. Preview framerate range: %s", rangeDescription[fpsRangeIdx]);
        snprintf(area1[j++], MAX_SYMBOLS, "&. Dump a preview frame");
        if (stereoMode) {
            snprintf(area1[j++], MAX_SYMBOLS, "_. Auto Convergence mode: %s", autoconvergencemode[AutoConvergenceModeIDX]);
            snprintf(area1[j++], MAX_SYMBOLS, "^. Manual Convergence Value: %d\n", manualConv);
            snprintf(area1[j++], MAX_SYMBOLS, "L. Stereo Preview Layout: %s\n", stereoLayout[stereoLayoutIDX]);
            snprintf(area1[j++], MAX_SYMBOLS, ".  Stereo Capture Layout: %s\n", stereoCapLayout[stereoCapLayoutIDX]);
        }
        snprintf(area1[j++], MAX_SYMBOLS, "{. 2D Preview in 3D Stereo Mode: %s", params.get(KEY_S3D2D_PREVIEW_MODE));

        snprintf(area1[j++], MAX_SYMBOLS, "     IMAGE CAPTURE SUB MENU");
        snprintf(area1[j++], MAX_SYMBOLS, "   -----------------------------");
        snprintf(area1[j++], MAX_SYMBOLS, "p. Take picture/Full Press");
        snprintf(area1[j++], MAX_SYMBOLS, "n. Flush shot config queue: %s", shotConfigFlush ? "On" : "Off");
        snprintf(area1[j++], MAX_SYMBOLS, "H. Exposure Bracketing: %s", expBracketing[expBracketIdx].desc);
        snprintf(area1[j++], MAX_SYMBOLS, "U. Temporal Bracketing:   %s", tempBracketing[tempBracketIdx]);
        snprintf(area1[j++], MAX_SYMBOLS, "W. Temporal Bracketing Range: [-%d;+%d]", tempBracketRange, tempBracketRange);
        snprintf(area1[j++], MAX_SYMBOLS, "$. Picture Format: %s", pictureFormatArray[pictureFormat]);
        snprintf(area1[j++], MAX_SYMBOLS, "3. Picture Rotation:       %3d degree", rotation );
        snprintf(area1[j++], MAX_SYMBOLS, "V. Preview Rotation:       %3d degree", previewRotation );
        snprintf(area1[j++], MAX_SYMBOLS, "5. Picture size:   %4d x %4d - %s",capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height,              capture_Array[captureSizeIDX]->name);
        snprintf(area1[j++], MAX_SYMBOLS, "i. ISO mode:       %s", isoMode[iso_mode]);
        snprintf(area1[j++], MAX_SYMBOLS, ",  Manual gain iso value  = %d\n", manualGain);
        snprintf(area1[j++], MAX_SYMBOLS, "u. Capture Mode:   %s", modevalues[capture_mode]);
        snprintf(area1[j++], MAX_SYMBOLS, "k. IPP Mode:       %s", ipp_mode[ippIDX]);
        snprintf(area1[j++], MAX_SYMBOLS, "K. GBCE: %s", gbce[gbceIDX]);
        snprintf(area1[j++], MAX_SYMBOLS, "O. GLBCE %s", gbce[glbceIDX]);
        snprintf(area1[j++], MAX_SYMBOLS, "o. Jpeg Quality:   %d", jpegQuality);
        snprintf(area1[j++], MAX_SYMBOLS, "#. Burst Images:  %3d", burst);
        snprintf(area1[j++], MAX_SYMBOLS, ":. Thumbnail Size:  %4d x %4d - %s",thumbnail_Array[thumbSizeIDX]->width, thumbnail_Array[thumbSizeIDX]->height, thumbnail_Array[thumbSizeIDX]->name);
        snprintf(area1[j++], MAX_SYMBOLS, "': Thumbnail Quality %d", thumbQuality);

        snprintf(area2[k++], MAX_SYMBOLS, "     VIDEO CAPTURE SUB MENU");
        snprintf(area2[k++], MAX_SYMBOLS, "   -----------------------------");
        snprintf(area2[k++], MAX_SYMBOLS, "6. Start Video Recording");
        snprintf(area2[k++], MAX_SYMBOLS, "2. Stop Recording");
        snprintf(area2[k++], MAX_SYMBOLS, "l. Video Capture resolution:   %4d x %4d - %s",Vcapture_Array[VcaptureSizeIDX]->width,Vcapture_Array[VcaptureSizeIDX]->height, Vcapture_Array[VcaptureSizeIDX]->name);
        snprintf(area2[k++], MAX_SYMBOLS, "]. Video Bit rate :  %s", VbitRate[VbitRateIDX].desc);
        snprintf(area2[k++], MAX_SYMBOLS, "9. Video Codec:    %s", videoCodecs[videoCodecIDX].desc);
        snprintf(area2[k++], MAX_SYMBOLS, "D. Audio Codec:    %s", audioCodecs[audioCodecIDX].desc);
        snprintf(area2[k++], MAX_SYMBOLS, "v. Output Format:  %s", outputFormat[outputFormatIDX].desc);
        snprintf(area2[k++], MAX_SYMBOLS, "r. Framerate:     %d", constFramerate[frameRateIDX]);
        snprintf(area2[k++], MAX_SYMBOLS, "*. Start Video Recording dump ( 1 raw frame )");
        snprintf(area2[k++], MAX_SYMBOLS, "B  VNF              %s", vnftoggle? "On" : "Off");
        snprintf(area2[k++], MAX_SYMBOLS, "C  VSTAB              %s", vstabtoggle? "On" : "Off");

        snprintf(area2[k++], MAX_SYMBOLS, "       3A SETTING SUB MENU");
        snprintf(area2[k++], MAX_SYMBOLS, "   -----------------------------");
        snprintf(area2[k++], MAX_SYMBOLS, "M. Measurement Data: %s", measurement[measurementIdx]);
        snprintf(area2[k++], MAX_SYMBOLS, "F. Toggle face detection: %s", faceDetectToggle ? "On" : "Off");
        snprintf(area2[k++], MAX_SYMBOLS, "T. Toggle metadata: %s", metaDataToggle ? "On" : "Off");
        snprintf(area2[k++], MAX_SYMBOLS, "G. Touch/Focus area AF");
        snprintf(area2[k++], MAX_SYMBOLS, "y. Metering area");
        snprintf(area2[k++], MAX_SYMBOLS, "Y. Metering area center");
        snprintf(area2[k++], MAX_SYMBOLS, "N. Metering area average");
        snprintf(area2[k++], MAX_SYMBOLS, "f. Auto Focus/Half Press");
        snprintf(area2[k++], MAX_SYMBOLS, "I. AF Timeout       %s", afTimeout[afTimeoutIdx]);
        snprintf(area2[k++], MAX_SYMBOLS, "J.Flash:              %s", flash[flashIdx]);
        snprintf(area2[k++], MAX_SYMBOLS, "7. EV offset:      %4.1f", compensation);
        snprintf(area2[k++], MAX_SYMBOLS, "8. AWB mode:       %s", awb[awb_mode]);
        snprintf(area2[k++], MAX_SYMBOLS, "z. Zoom            %s", zoom[zoomIDX].zoom_description);
        snprintf(area2[k++], MAX_SYMBOLS, "Z. Smooth Zoom     %s", zoom[zoomIDX].zoom_description);
        snprintf(area2[k++], MAX_SYMBOLS, "j. Exposure        %s", exposureMode[exposure_mode]);
        snprintf(area2[k++], MAX_SYMBOLS, "Q. manual exposure value  =  %d\n", manualExp);
        snprintf(area2[k++], MAX_SYMBOLS, "e. Effect:         %s", effectss[effects_mode]);
        snprintf(area2[k++], MAX_SYMBOLS, "w. Scene:          %s", scene[scene_mode]);
        snprintf(area2[k++], MAX_SYMBOLS, "s. Saturation:     %d", saturation);
        snprintf(area2[k++], MAX_SYMBOLS, "c. Contrast:       %d", contrast);
        snprintf(area2[k++], MAX_SYMBOLS, "h. Sharpness:      %d", sharpness);
        snprintf(area2[k++], MAX_SYMBOLS, "b. Brightness:     %d", brightness);
        snprintf(area2[k++], MAX_SYMBOLS, "x. Antibanding:    %s", antiband[antibanding_mode]);
        snprintf(area2[k++], MAX_SYMBOLS, "g. Focus mode:     %s", focus[focus_mode]);
        snprintf(area2[k++], MAX_SYMBOLS, "m. Metering mode:     %s" , metering[meter_mode]);
        snprintf(area2[k++], MAX_SYMBOLS, "<. Exposure Lock:     %s", AutoExposureLocktoggle ? "On" : "Off");
        snprintf(area2[k++], MAX_SYMBOLS, ">. WhiteBalance Lock:  %s",AutoWhiteBalanceLocktoggle ? "On": "Off");
        snprintf(area2[k++], MAX_SYMBOLS, "). Mechanical Misalignment Correction:  %s",misalignmentCorrection[enableMisalignmentCorrectionIdx]);
        snprintf(area2[k++], MAX_SYMBOLS, "d. Algo enable/disable functions menu");

        printf("\n");
        for (int i=0; (i<j || i < k) && i<MAX_LINES; i++) {
            printf("%-65s \t %-65s\n", area1[i], area2[i]);
        }
        printf("   Choice:");
    }

    ch = getchar();
    printf("%c", ch);

    print_menu = 1;

    switch (ch) {

    case '_':
        AutoConvergenceModeIDX++;
        AutoConvergenceModeIDX %= numAutoConvergence;
        params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
        if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], "manual") == 0) {
            params.set(KEY_MANUAL_CONVERGENCE, manualConv);
        } else {
            if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], "touch") == 0) {
                params.set(CameraParameters::KEY_METERING_AREAS, MeteringAreas);
            }
            manualConv = 0;
            params.set(KEY_MANUAL_CONVERGENCE, manualConv);
        }
        camera->setParameters(params.flatten());

        break;
    case '^':
        if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], "manual") == 0) {
            manualConv += manualConvStep;
            if( manualConv > manualConvMax) {
               manualConv = manualConvMin;
            }
            params.set(KEY_MANUAL_CONVERGENCE, manualConv);
            camera->setParameters(params.flatten());
        }
        break;
    case 'A':
        camera_index++;
        camera_index %= numCamera;
        firstTime = true;
        closeCamera();
        openCamera();
        initDefaults();


        break;
    case '[':
        if ( hardwareActive ) {
            camera->setParameters(params.flatten());
            camera->startPreview();
        }
        break;

    case '0':
        initDefaults();
        camera_index = 0;
        break;

        case '1':

            if ( startPreview() < 0 ) {
                printf("Error while starting preview\n");

                return -1;
            }

            break;

        case '2':
            if ( recordingMode ) {
                stopRecording();
                stopPreview();
                closeRecorder();
                camera->disconnect();
                camera.clear();
                camera = Camera::connect(camera_index);
                  if ( NULL == camera.get() ) {
                      sleep(1);
                      camera = Camera::connect(camera_index);
                      if ( NULL == camera.get() ) {
                          return -1;
                      }
                  }
                  camera->setListener(new CameraHandler());
                  camera->setParameters(params.flatten());
                  recordingMode = false;
            } else {
                stopPreview();
            }

            break;

        case '3':
            rotation += 90;
            rotation %= 360;
            params.set(CameraParameters::KEY_ROTATION, rotation);
            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'V':
            previewRotation += 90;
            previewRotation %= 360;
            params.set(KEY_SENSOR_ORIENTATION, previewRotation);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case '4':
            previewSizeIDX += 1;
            previewSizeIDX %= numpreviewSize;
            params.setPreviewSize(preview_Array[previewSizeIDX]->width, preview_Array[previewSizeIDX]->height);

            reSizePreview = true;

            if ( hardwareActive && previewRunning ) {
                camera->stopPreview();
                camera->setParameters(params.flatten());
                camera->startPreview();
            } else if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }

            break;

        case '5':
            captureSizeIDX += 1;
            captureSizeIDX %= numcaptureSize;
            printf("CaptureSizeIDX %d \n", captureSizeIDX);
            params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            requestBufferSourceReset();

            break;

        case 'l':

            VcaptureSizeIDX++;
            VcaptureSizeIDX %= numVcaptureSize;
            break;

        case 'L' :
            stereoLayoutIDX++;
            stereoLayoutIDX %= numLay;

            if (stereoMode) {
                firstTimeStereo = false;
                params.set(KEY_S3D_PRV_FRAME_LAYOUT, stereoLayout[stereoLayoutIDX]);
            }

            getSizeParametersFromCapabilities();

            if (hardwareActive && previewRunning) {
                stopPreview();
                camera->setParameters(params.flatten());
                startPreview();
            } else if (hardwareActive) {
                camera->setParameters(params.flatten());
            }

            break;

        case '.' :
            stereoCapLayoutIDX++;
            stereoCapLayoutIDX %= numCLay;

            if (stereoMode) {
                firstTimeStereo = false;
                params.set(KEY_S3D_CAP_FRAME_LAYOUT, stereoCapLayout[stereoCapLayoutIDX]);
            }

            getSizeParametersFromCapabilities();

            if (hardwareActive && previewRunning) {
                stopPreview();
                camera->setParameters(params.flatten());
                startPreview();
            } else if (hardwareActive) {
                camera->setParameters(params.flatten());
            }

            break;

        case ']':
            VbitRateIDX++;
            VbitRateIDX %= ARRAY_SIZE(VbitRate);
            break;


        case '6':

            if ( !recordingMode ) {

                recordingMode = true;

                if ( startPreview() < 0 ) {
                    printf("Error while starting preview\n");

                    return -1;
                }

                if ( openRecorder() < 0 ) {
                    printf("Error while openning video recorder\n");

                    return -1;
                }

                if ( configureRecorder() < 0 ) {
                    printf("Error while configuring video recorder\n");

                    return -1;
                }

                if ( startRecording() < 0 ) {
                    printf("Error while starting video recording\n");

                    return -1;
                }
            }

            break;

        case '7':

            if ( compensation > 2.0) {
                compensation = -2.0;
            } else {
                compensation += 0.1;
            }

            params.set(KEY_COMPENSATION, (int) (compensation * 10));

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case '8':
            awb_mode++;
            awb_mode %= numawb;
            params.set(params.KEY_WHITE_BALANCE, awb[awb_mode]);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case '9':
            videoCodecIDX++;
            videoCodecIDX %= ARRAY_SIZE(videoCodecs);
            break;
        case '~':
            previewFormat += 1;
            previewFormat %= numpreviewFormat;
            params.setPreviewFormat(previewFormatArray[previewFormat]);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;
        case '$':
            pictureFormat += 1;
            pictureFormat %= numpictureFormat;
            printf("pictureFormat %d\n", pictureFormat);
            printf("numpreviewFormat %d\n", numpictureFormat);
            params.setPictureFormat(pictureFormatArray[pictureFormat]);

            queueEmpty = true;
            if ( bufferSourceOutputThread.get() ) {
                if ( 0 < bufferSourceOutputThread->hasBuffer() ) {
                    queueEmpty = false;
                }
            }
            if ( hardwareActive && queueEmpty )
                camera->setParameters(params.flatten());

            break;

        case ':':
            thumbSizeIDX += 1;
            thumbSizeIDX %= numthumbnailSize;
            printf("ThumbnailSizeIDX %d \n", thumbSizeIDX);

            params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, thumbnail_Array[thumbSizeIDX]->width);
            params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,thumbnail_Array[thumbSizeIDX]->height);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case '\'':
            if ( thumbQuality >= 100) {
                thumbQuality = 0;
            } else {
                thumbQuality += 5;
            }

            params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality);
            if ( hardwareActive )
                camera->setParameters(params.flatten());
            break;

        case 'B' :
            if(strcmp(vnfstr, "true") == 0) {
                if(vnftoggle == false) {
                    trySetVideoNoiseFilter(true);
                    vnftoggle = true;
                } else {
                    trySetVideoNoiseFilter(false);
                    vnftoggle = false;
                }

            }else {
                trySetVideoNoiseFilter(false);
                vnftoggle = false;
                printf("VNF is not supported\n");
            }
            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'C' :
            if(strcmp(vstabstr, "true") == 0) {
                if(vstabtoggle == false) {
                    trySetVideoStabilization(true);
                    vstabtoggle = true;
                } else {
                    trySetVideoStabilization(false);
                    vstabtoggle = false;
                }

            } else {
                trySetVideoStabilization(false);
                vstabtoggle = false;
                printf("VSTAB is not supported\n");
            }
            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'E':
            if(hardwareActive)
                params.unflatten(camera->getParameters());
            printSupportedParams();
            break;

        case '*':
            if ( hardwareActive )
                camera->startRecording();
            break;

        case 'o':
            if ( jpegQuality >= 100) {
                jpegQuality = 0;
            } else {
                jpegQuality += 5;
            }

            params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
            if ( hardwareActive )
                camera->setParameters(params.flatten());
            break;

        case 'M':
            measurementIdx = (measurementIdx + 1)%ARRAY_SIZE(measurement);
            params.set(KEY_MEASUREMENT, measurement[measurementIdx]);
            if ( hardwareActive )
                camera->setParameters(params.flatten());
            break;

        case 'm':
            meter_mode = (meter_mode + 1)%ARRAY_SIZE(metering);
            params.set(KEY_METERING_MODE, metering[meter_mode]);
            if ( hardwareActive )
                camera->setParameters(params.flatten());
            break;

        case 'k':
            ippIDX += 1;
            ippIDX %= ARRAY_SIZE(ipp_mode);
            ippIDX_old = ippIDX;

            params.set(KEY_IPP, ipp_mode[ippIDX]);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            requestBufferSourceReset();

            break;

        case 'K':
            gbceIDX+= 1;
            gbceIDX %= ARRAY_SIZE(gbce);
            params.set(KEY_GBCE, gbce[gbceIDX]);

            if ( hardwareActive )
                camera->setParameters(params.flatten());
            break;

        case 'O':
            glbceIDX+= 1;
            glbceIDX %= ARRAY_SIZE(gbce);
            params.set(KEY_GLBCE, gbce[glbceIDX]);

            if ( hardwareActive )
                camera->setParameters(params.flatten());
            break;

        case 'F':
            faceDetectToggle = !faceDetectToggle;
            if ( hardwareActive ) {
                if (faceDetectToggle)
                    camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0);
                else
                    camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0);
            }
            break;

        case 'I':
            afTimeoutIdx++;
            afTimeoutIdx %= ARRAY_SIZE(afTimeout);
            params.set(KEY_AF_TIMEOUT, afTimeout[afTimeoutIdx]);
            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'T':
            metaDataToggle = !metaDataToggle;
            break;

        case '@':
            if ( hardwareActive ) {

                closeCamera();

                if ( 0 >= openCamera() ) {
                    printf( "Reconnected to CameraService \n");
                }
            }

            break;

        case '#':

            if ( burst >= MAX_BURST ) {
                burst = 0;
            } else {
                burst += BURST_INC;
            }
            burstCount = burst;
            params.set(KEY_TI_BURST, burst);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'J':
            flashIdx++;
            flashIdx %= numflash;
            params.set(CameraParameters::KEY_FLASH_MODE, (flash[flashIdx]));

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'u':
            capture_mode++;
            capture_mode %= nummodevalues;

            // HQ should always be in ldc-nsf
            // if not HQ, then return the ipp to its previous state
            if( !strcmp(modevalues[capture_mode], "high-quality") ) {
                ippIDX_old = ippIDX;
                ippIDX = 3;
                params.set(KEY_IPP, ipp_mode[ippIDX]);
                params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
                previewRotation = 0;
                params.set(KEY_SENSOR_ORIENTATION, previewRotation);
            } else if ( !strcmp(modevalues[capture_mode], "video-mode") ) {
                params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);
                camera->getCameraInfo(camera_index, &cameraInfo);
                previewRotation = ((360-cameraInfo.orientation)%360);
                if (previewRotation >= 0 || previewRotation <=360) {
                    params.set(KEY_SENSOR_ORIENTATION, previewRotation);
                }
            } else {
                ippIDX = ippIDX_old;
                params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
                previewRotation = 0;
                params.set(KEY_SENSOR_ORIENTATION, previewRotation);
            }

            params.set(KEY_MODE, (modevalues[capture_mode]));

            if ( hardwareActive ) {
                if (previewRunning) {
                    stopPreview();
                }
                camera->setParameters(params.flatten());
                // Get parameters from capabilities for the new capture mode
                params = camera->getParameters();
                getSizeParametersFromCapabilities();
                getParametersFromCapabilities();
                // Set framerate 30fps and 12MP capture resolution if available for the new capture mode.
                // If not available set framerate and capture mode under index 0 from fps_const_str and capture_Array.
                frameRateIDX = getDefaultParameter("30000,30000", constCnt, fps_const_str);
                captureSizeIDX = getDefaultParameterResol("12MP", numcaptureSize, capture_Array);
                params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
                params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
                camera->setParameters(params.flatten());
            }

            requestBufferSourceReset();

            break;

        case 'U':
            tempBracketIdx++;
            tempBracketIdx %= ARRAY_SIZE(tempBracketing);
            params.set(KEY_TEMP_BRACKETING, tempBracketing[tempBracketIdx]);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'H':
            expBracketIdx++;
            expBracketIdx %= ARRAY_SIZE(expBracketing);
            setDefaultExpGainPreset(shotParams, expBracketIdx);

            break;

        case 'n':
            if (shotConfigFlush)
                shotConfigFlush = false;
            else
                shotConfigFlush = true;

            updateShotConfigFlushParam();

            break;

        case '(':
        {
            char input[256];
            input[0] = ch;
            scanf("%254s", input+1);
            setExpGainPreset(shotParams, input, true, PARAM_EXP_BRACKET_PARAM_NONE, shotConfigFlush);
            break;
        }
        case 'W':
            tempBracketRange++;
            tempBracketRange %= TEMP_BRACKETING_MAX_RANGE;
            if ( 0 == tempBracketRange ) {
                tempBracketRange = 1;
            }

            params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange);
            params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'w':
            scene_mode++;
            scene_mode %= numscene;
            params.set(params.KEY_SCENE_MODE, scene[scene_mode]);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'i':
            iso_mode++;
            iso_mode %= numisoMode;
            params.set(KEY_ISO, isoMode[iso_mode]);
            if ( hardwareActive )
                camera->setParameters(params.flatten());
            break;


        case 'h':
#ifdef TARGET_OMAP4
            if ( sharpness >= 200)
#else
            if ( sharpness >= 100)
#endif
            {
                sharpness = 0;
            } else {
                sharpness += 10;
            }
            params.set(KEY_SHARPNESS, sharpness);
            if ( hardwareActive )
                camera->setParameters(params.flatten());
            break;

        case 'D':
        {
            audioCodecIDX++;
            audioCodecIDX %= ARRAY_SIZE(audioCodecs);
            break;
        }

        case 'v':
        {
            outputFormatIDX++;
            outputFormatIDX %= ARRAY_SIZE(outputFormat);
            break;
        }

        case 'z':
            if(strcmp(zoomstr, "true") == 0) {
                zoomIDX++;
                zoomIDX %= ARRAY_SIZE(zoom);
                params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);

                if ( hardwareActive )
                    camera->setParameters(params.flatten());
            }
            break;

        case 'Z':
            if(strcmp(smoothzoomstr, "true") == 0) {
                zoomIDX++;
                zoomIDX %= ARRAY_SIZE(zoom);

                if ( hardwareActive )
                    camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, zoom[zoomIDX].idx, 0);
            }
            break;

        case 'j':
            exposure_mode++;
            exposure_mode %= numExposureMode;
            params.set(KEY_EXPOSURE, exposureMode[exposure_mode]);
            if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
                params.set(KEY_MANUAL_EXPOSURE, manualExp);
                params.set(KEY_MANUAL_GAIN_ISO, manualGain);
                params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
                params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
            }
            else
            {
                manualExp = manualExpMin;
                params.set(KEY_MANUAL_EXPOSURE, manualExp);
                params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
                manualGain = manualGainMin;
                params.set(KEY_MANUAL_GAIN_ISO, manualGain);
                params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
            }

            if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }

            break;

        case 'Q':
            if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
                manualExp += manualExpStep;
                if( manualExp > manualExpMax) {
                    manualExp = manualExpMin;
                }
                params.set(KEY_MANUAL_EXPOSURE, manualExp);
                params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
                camera->setParameters(params.flatten());
            }
            break;

        case ',':
            if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
                manualGain += manualGainStep;
                if( manualGain > manualGainMax) {
                   manualGain = manualGainMin;
                }
                params.set(KEY_MANUAL_GAIN_ISO, manualGain);
                params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
                camera->setParameters(params.flatten());
            }
            break;

        case 'c':
            if( contrast >= 200){
                contrast = 0;
            } else {
                contrast += 10;
            }
            params.set(KEY_CONTRAST, contrast);
            if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }
            break;
        case 'b':
#ifdef TARGET_OMAP4
            if ( brightness >= 100)
#else
            if ( brightness >= 200)
#endif
            {
                brightness = 0;
            } else {
                brightness += 10;
            }

            params.set(KEY_BRIGHTNESS, brightness);

            if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }

            break;

        case 's':
            if ( saturation >= 200) {
                saturation = 0;
            } else {
                saturation += 10;
            }

            params.set(KEY_SATURATION, saturation);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'e':
            effects_mode++;
            effects_mode %= numEffects;
            printf("%d", numEffects);
            params.set(params.KEY_EFFECT, effectss[effects_mode]);
            printf("Effects_mode %d", effects_mode);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'r':
            frameRateIDX++;
            frameRateIDX %= constCnt;
            params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
            printf("fps_const_str[frameRateIDX] %s\n", fps_const_str[frameRateIDX]);

            if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }

            break;

        case 'R':
            fpsRangeIdx += 1;
            fpsRangeIdx %= rangeCnt;
            params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_range_str[fpsRangeIdx]);
            printf("fps_range_str[fpsRangeIdx] %s\n", fps_range_str[fpsRangeIdx]);

            if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }

            break;

        case 'x':
            antibanding_mode++;
            antibanding_mode %= numAntibanding;
            printf("%d", numAntibanding);
            params.set(params.KEY_ANTIBANDING, antiband[antibanding_mode]);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'g':
            focus_mode++;
            focus_mode %= numfocus;
            params.set(params.KEY_FOCUS_MODE, focus[focus_mode]);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'G':
            params.set(CameraParameters::KEY_FOCUS_AREAS, TEST_FOCUS_AREA);

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case 'y':
            params.set(CameraParameters::KEY_METERING_AREAS, TEST_METERING_AREA);

            if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }

            break;

        case 'Y':

            params.set(CameraParameters::KEY_METERING_AREAS, TEST_METERING_AREA_CENTER);

            if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }

            break;

        case 'N':

            params.set(CameraParameters::KEY_METERING_AREAS, TEST_METERING_AREA_AVERAGE);

            if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }

            break;

        case 'f':
            gettimeofday(&autofocus_start, 0);

            if ( hardwareActive )
                camera->autoFocus();

            break;

        case 'p':
        {
            int msgType = 0;

            if((0 == strcmp(modevalues[capture_mode], "video-mode")) &&
               (0 != strcmp(videosnapshotstr, "true"))) {
                printf("Video Snapshot is not supported\n");
            } else if ( hardwareActive ) {
                if(isRawPixelFormat(pictureFormatArray[pictureFormat])) {
                    createBufferOutputSource();
                    if (bufferSourceOutputThread.get()) {
                        bufferSourceOutputThread->setBuffer(shotParams);
                        bufferSourceOutputThread->setStreamCapture(streamCapture, expBracketIdx);
                    }
                } else {
                    msgType = CAMERA_MSG_COMPRESSED_IMAGE |
                              CAMERA_MSG_RAW_IMAGE;
#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
                    msgType |= CAMERA_MSG_RAW_BURST;
#endif
                }

                gettimeofday(&picture_start, 0);
                camera->setParameters(params.flatten());
                camera->takePictureWithParameters(msgType, shotParams.flatten());
            }
            break;
        }

        case 'S':
        {
            if (streamCapture) {
                streamCapture = false;
                setDefaultExpGainPreset(shotParams, expBracketIdx);
                // Stop streaming
                if (bufferSourceOutputThread.get()) {
                    bufferSourceOutputThread->setStreamCapture(streamCapture, expBracketIdx);
                }
            } else {
                streamCapture = true;
                setSingleExpGainPreset(shotParams, expBracketIdx, 0, 0);
                // Queue more frames initially
                shotParams.set(ShotParameters::KEY_BURST, BRACKETING_STREAM_BUFFERS);
            }
            break;
        }

        case 'P':
        {
            int msgType = CAMERA_MSG_COMPRESSED_IMAGE;
            ShotParameters reprocParams;

            gettimeofday(&picture_start, 0);
            createBufferInputSource();
            if (bufferSourceOutputThread.get() &&
                bufferSourceOutputThread->hasBuffer())
            {
                bufferSourceOutputThread->setStreamCapture(false, expBracketIdx);
                if (hardwareActive) camera->setParameters(params.flatten());

                if (bufferSourceInput.get()) {
                    buffer_info_t info = bufferSourceOutputThread->popBuffer();
                    bufferSourceInput->setInput(info, pictureFormatArray[pictureFormat], reprocParams);
                    if (hardwareActive) camera->reprocess(msgType, reprocParams.flatten());
                }
            }
            break;
        }

        case '&':
            printf("Enabling Preview Callback");
            dump_preview = 1;
            if ( hardwareActive )
            camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
            break;

        case '{':
            valstr = params.get(KEY_S3D2D_PREVIEW_MODE);
            if ( (NULL != valstr) && (0 == strcmp(valstr, "on")) )
                {
                params.set(KEY_S3D2D_PREVIEW_MODE, "off");
                }
            else
                {
                params.set(KEY_S3D2D_PREVIEW_MODE, "on");
                }
            if ( hardwareActive )
                camera->setParameters(params.flatten());
            break;

        case 'a':

            while (1) {
                if ( menu_gps() < 0)
                    break;
            };

            break;

        case 'q':
            stopPreview();
            deleteAllocatedMemory();

            return 0;

        case '/':
        {
            if (showfps)
            {
                property_set("debug.image.showfps", "0");
                showfps = false;
            }
            else
            {
                property_set("debug.image.showfps", "1");
                showfps = true;
            }
            break;
        }

        case '<':
            if(strcmp(AutoExposureLockstr, "true") == 0) {
                if(AutoExposureLocktoggle == false) {
                    trySetAutoExposureLock(true);
                    AutoExposureLocktoggle = true;
                } else {
                    trySetAutoExposureLock(false);
                    AutoExposureLocktoggle = false;
                    printf("ExposureLock is not supported\n");
                }
            }

            if ( hardwareActive )
                camera->setParameters(params.flatten());

            break;

        case '>':
            if(strcmp(AutoWhiteBalanceLockstr, "true") == 0) {
                if(AutoWhiteBalanceLocktoggle == false) {
                    trySetAutoWhiteBalanceLock(true);
                    AutoWhiteBalanceLocktoggle = true;
                } else {
                    trySetAutoWhiteBalanceLock(false);
                    AutoWhiteBalanceLocktoggle = false;
                    printf("ExposureLock is not supported\n");
                }
            }

            if ( hardwareActive ) {
                camera->setParameters(params.flatten());
            }

            break;

    case ')':
      enableMisalignmentCorrectionIdx++;
      enableMisalignmentCorrectionIdx %= ARRAY_SIZE(misalignmentCorrection);
      params.set(KEY_MECHANICAL_MISALIGNMENT_CORRECTION, misalignmentCorrection[enableMisalignmentCorrectionIdx]);
      if ( hardwareActive ) {
        camera->setParameters(params.flatten());
      }
      break;

    case 'd':
        while (1) {
            if ( menu_algo() < 0)
                break;
        }
        break;

    default:
      print_menu = 0;

      break;
    }

    return 1;
}

void print_usage() {
    printf(" USAGE: camera_test <options>\n");
    printf(" <options> (case insensitive)\n");
    printf("-----------\n");
    printf(" -f            -> Functional tests.\n");
    printf(" -a            -> API tests.\n");
    printf(" -e [<script>] -> Error scenario tests. If no script file is provided\n");
    printf("                  the test is run in interactive mode.\n");
    printf(" -s <script> -c <sensorID>  -> Stress / regression tests.\n");
    printf(" -l [<flags>]  -> Enable different kinds of logging capture. Multiple flags\n");
    printf("                  should be combined into a string. If flags are not provided\n");
    printf("                  no logs are captured.\n");
    printf("                   <flags>\n");
    printf("                  ---------\n");
    printf("                   l -> logcat [default]\n");
    printf("                   s -> syslink [default]\n");
    printf(" -o <path>     -> Output directory to store the test results. Image and video\n");
    printf("                  files are stored in corresponding sub-directories.\n");
    printf(" -p <platform> -> Target platform. Only for stress tests.\n");
    printf("                   <platform>\n");
    printf("                  ------------\n");
    printf("                   blaze or B    -> BLAZE\n");
    printf("                   tablet1 or T1 -> Blaze TABLET-1\n");
    printf("                   tablet2 or T2 -> Blaze TABLET-2 [default]\n\n");
    return;
}

int error_scenario() {
    char ch;
    status_t stat = NO_ERROR;

    if (print_menu) {
        printf("   0. Buffer need\n");
        printf("   1. Not enough memory\n");
        printf("   2. Media server crash\n");
        printf("   3. Overlay object request\n");
        printf("   4. Pass unsupported preview&picture format\n");
        printf("   5. Pass unsupported preview&picture resolution\n");
        printf("   6. Pass unsupported preview framerate\n");

        printf("   q. Quit\n");
        printf("   Choice: ");
    }

    print_menu = 1;
    ch = getchar();
    printf("%c\n", ch);

    switch (ch) {
        case '0': {
            printf("Case0:Buffer need\n");
            bufferStarvationTest = 1;
            params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation

            if ( !recordingMode ) {
                recordingMode = true;
                if ( startPreview() < 0 ) {
                    printf("Error while starting preview\n");

                    return -1;
                }

                if ( openRecorder() < 0 ) {
                    printf("Error while openning video recorder\n");

                    return -1;
                }

                if ( configureRecorder() < 0 ) {
                    printf("Error while configuring video recorder\n");

                    return -1;
                }

                if ( startRecording() < 0 ) {
                    printf("Error while starting video recording\n");

                    return -1;
                }

            }

            usleep(1000000);//1s

            stopPreview();

            if ( recordingMode ) {
                stopRecording();
                closeRecorder();

                recordingMode = false;
            }

            break;
        }

        case '1': {
            printf("Case1:Not enough memory\n");
            int* tMemoryEater = new int[999999999];

            if (!tMemoryEater) {
                printf("Not enough memory\n");
                return -1;
            } else {
                delete tMemoryEater;
            }

            break;
        }

        case '2': {
            printf("Case2:Media server crash\n");
            //camera = Camera::connect();

            if ( NULL == camera.get() ) {
                printf("Unable to connect to CameraService\n");
                return -1;
            }

            break;
        }

        case '3': {
            printf("Case3:Overlay object request\n");
            int err = 0;

            err = open("/dev/video5", O_RDWR);

            if (err < 0) {
                printf("Could not open the camera device5: %d\n",  err );
                return err;
            }

            if ( startPreview() < 0 ) {
                printf("Error while starting preview\n");
                return -1;
            }

            usleep(1000000);//1s

            stopPreview();

            close(err);
            break;
        }

        case '4': {

            if ( hardwareActive ) {

                params.setPictureFormat("invalid-format");
                params.setPreviewFormat("invalid-format");

                stat = camera->setParameters(params.flatten());

                if ( NO_ERROR != stat ) {
                    printf("Test passed!\n");
                } else {
                    printf("Test failed!\n");
                }

                initDefaults();
            }

            break;
        }

        case '5': {

            if ( hardwareActive ) {

                params.setPictureSize(-1, -1);
                params.setPreviewSize(-1, -1);

                stat = camera->setParameters(params.flatten());

                if ( NO_ERROR != stat ) {
                    printf("Test passed!\n");
                } else {
                    printf("Test failed!\n");
                }

                initDefaults();
            }

            break;
        }

        case '6': {

            if ( hardwareActive ) {

                params.setPreviewFrameRate(-1);

                stat = camera->setParameters(params.flatten());

                if ( NO_ERROR != stat ) {
                    printf("Test passed!\n");
                } else {
                    printf("Test failed!\n");
                }

                initDefaults();
            }


            break;
        }

        case 'q': {
            return -1;
        }

        default: {
            print_menu = 0;
            break;
        }
    }

    return 0;
}

int restartCamera() {

  printf("+++Restarting Camera After Error+++\n");
  stopPreview();
  closeCamera();

  if (recordingMode) {
    stopRecording();
    closeRecorder();

    recordingMode = false;
  }

  sleep(3); //Wait a bit before restarting

  restartCount++;

  if ( openCamera() < 0 )
  {
    printf("+++Camera Restarted Failed+++\n");
    system("echo camerahal_test > /sys/power/wake_unlock");
    return -1;
  }

  initDefaults();

  stopScript = false;

  printf("+++Camera Restarted Successfully+++\n");
  return 0;
}

int parseCommandLine(int argc, char *argv[], cmd_args_t *cmd_args) {
    if (argc < 2) {
        printf("Please enter at least 1 argument\n");
        return -2;
    }

    // Set defaults
    memset(cmd_args, 0, sizeof(*cmd_args));
    cmd_args->logging = LOGGING_LOGCAT | LOGGING_SYSLINK;
    cmd_args->platform_id = BLAZE_TABLET2;

    for (int a = 1; a < argc; a++) {
        const char * const arg = argv[a];
        if (arg[0] != '-') {
            printf("Error: Invalid argument \"%s\"\n", arg);
            return -2;
        }

        switch (arg[1]) {
            case 's':
                cmd_args->test_type = TEST_TYPE_REGRESSION;
                if (a < argc - 1) {
                    cmd_args->script_file_name = argv[++a];
                } else {
                    printf("Error: No script is specified for stress / regression test.\n");
                    return -2;
                }
                break;

            case 'f':
                cmd_args->test_type = TEST_TYPE_FUNCTIONAL;
                break;

            case 'a':
                cmd_args->test_type = TEST_TYPE_API;
                break;

            case 'e':
                cmd_args->test_type = TEST_TYPE_ERROR;
                if (a < argc - 1) {
                    cmd_args->script_file_name = argv[++a];
                }
                break;

            case 'l':
                cmd_args->logging = 0;

                if (a < argc - 1 && argv[a + 1][0] != '-') {
                    const char *flags = argv[++a];
                    while (*flags) {
                        char flag = *flags++;
                        switch (flag) {
                            case 'l':
                                cmd_args->logging |= LOGGING_LOGCAT;
                                break;

                            case 's':
                                cmd_args->logging |= LOGGING_SYSLINK;
                                break;

                            default:
                                printf("Error: Unknown logging type \"%c\"\n", flag);
                                return -2;
                        }
                    }
                }
                break;

            case 'p':
                if (a < argc - 1) {
                    const char *platform = argv[++a];
                    if( strcasecmp(platform,"blaze") == 0 || strcasecmp(platform,"B") == 0 ){
                        cmd_args->platform_id = BLAZE;
                    }
                    else if( (strcasecmp(platform,"tablet1") == 0) || (strcasecmp(platform,"T1") == 0) ) {
                        cmd_args->platform_id = BLAZE_TABLET1;
                    }
                    else if( (strcasecmp(platform,"tablet2") == 0) || (strcasecmp(platform,"T2") == 0) ) {
                        cmd_args->platform_id = BLAZE_TABLET2;
                    }
                    else {
                        printf("Error: Unknown argument for platform ID.\n");
                        return -2;
                    }
                } else {
                    printf("Error: No argument is specified for platform ID.\n");
                    return -2;
                }
                break;

            case 'o':
                if (a < argc - 1) {
                    cmd_args->output_path = argv[++a];
                } else {
                    printf("Error: No output path is specified.\n");
                    return -2;
                }
                break;

            case 'c':
                if (a < argc -1) {
                    camera_index = atoi(argv[++a]);
                } else {
                    printf("Error: No sensorID is specified.\n");
                    return -2;
                }
                break;

            default:
                printf("Error: Unknown option \"%s\"\n", argv[a]);
                return -2;
        }
    }

    return 0;
}

int setOutputDirPath(cmd_args_t *cmd_args, int restart_count) {
    if ((cmd_args->output_path != NULL) &&
            (strlen(cmd_args->output_path) < sizeof(output_dir_path))) {
        strcpy(output_dir_path, cmd_args->output_path);
    } else {
        strcpy(output_dir_path, SDCARD_PATH);

        if (cmd_args->script_file_name != NULL) {
            const char *config = cmd_args->script_file_name;
            char dir_name[40];
            size_t count = 0;
            char *p;

            // remove just the '.txt' part of the config
            while ((config[count] != '.') && ((count + 1) < sizeof(dir_name))) {
                count++;
            }

            strncpy(dir_name, config, count);

            dir_name[count] = NULL;
            p = dir_name;
            while (*p != '\0') {
                if (*p == '/') {
                    printf("SDCARD_PATH is not added to the output directory.\n");
                    // Needed when camera_test script is executed using the OTC
                    strcpy(output_dir_path, "");
                    break;
                }
            }

            strcat(output_dir_path, dir_name);
            if (camera_index == 1) {
                strcat(output_dir_path, SECONDARY_SENSOR);
            }else if (camera_index == 2) {
                strcat(output_dir_path, S3D_SENSOR);
            }
        }
    }

    if (restart_count && (strlen(output_dir_path) + 16) < sizeof(output_dir_path)) {
        char count[16];
        sprintf(count, "_%d", restart_count);
        strcat(output_dir_path, count);
    }

    if (access(output_dir_path, F_OK) == -1) {
        if (mkdir(output_dir_path, 0777) == -1) {
             printf("\nError: Output directory \"%s\" was not created\n", output_dir_path);
             return -1;
        }
    }

    sprintf(videos_dir_path, "%s/videos", output_dir_path);

    if (access(videos_dir_path, F_OK) == -1) {
        if (mkdir(videos_dir_path, 0777) == -1) {
             printf("\nError: Videos directory \"%s\" was not created\n", videos_dir_path);
             return -1;
        }
    }

    sprintf(images_dir_path, "%s/images", output_dir_path);

    if (access(images_dir_path, F_OK) == -1) {
        if (mkdir(images_dir_path, 0777) == -1) {
             printf("\nError: Images directory \"%s\" was not created\n", images_dir_path);
             return -1;
        }
    }

    return 0;
}

int startTest() {
    ProcessState::self()->startThreadPool();

    if (openCamera() < 0) {
        printf("Camera initialization failed\n");
        return -1;
    }

    initDefaults();

    return 0;
}

int runRegressionTest(cmd_args_t *cmd_args) {
    char *cmd;
    int pid;
    int res = 0;
    int restartTestCount = 0;

    platformID = cmd_args->platform_id;

    res = startTest();
    if (res != 0) {
        return res;
    }

    cmd = load_script(cmd_args->script_file_name);

    if (cmd != NULL) {
        start_logging(cmd_args->logging, pid);
        stressTest = true;

        while (1) {
            res = execute_functional_script(cmd);
            if (res >= 0) {
                break;
            }

            printf("CameraTest Restarting Camera...\n");

            free(cmd);
            cmd = NULL;

            iterationCount = 0;
            restartTestCount ++;
            if(restartTestCount > 3) {
                return res;
            }
            if ( (restartCamera() != 0)  || ((cmd = load_script(cmd_args->script_file_name)) == NULL) ) {
                printf("ERROR::CameraTest Restarting Camera...\n");
                res = -1;
                break;
            }

            res = setOutputDirPath(cmd_args, restartCount);
            if (res != 0) {
                break;
            }
        }

        free(cmd);
        stop_logging(cmd_args->logging, pid);
    }

    return res;
}

int runFunctionalTest() {
    int res = 0;
    res = startTest();
    if (res != 0) {
        return res;
    }

    print_menu = 1;

    while (1) {
        res = functional_menu();
        if (res <= 0) {
            break;
        }
    }

    return res;
}

int runApiTest() {
    printf("API level test cases coming soon ... \n");
    return 0;
}

int runErrorTest(cmd_args_t *cmd_args) {
    int res = startTest();
    if (res != 0) {
        return res;
    }

    if (cmd_args->script_file_name != NULL) {
        char *cmd;
        int pid;

        cmd = load_script(cmd_args->script_file_name);

        if (cmd != NULL) {
            start_logging(cmd_args->logging, pid);
            execute_error_script(cmd);
            free(cmd);
            stop_logging(cmd_args->logging, pid);
        }
    } else {
        print_menu = 1;

        while (1) {
            if (error_scenario() < 0) {
                break;
            }
        }
    }

    return 0;
}

int main(int argc, char *argv[]) {
    sp<ProcessState> proc(ProcessState::self());

    unsigned long long st, end, delay;
    timeval current_time;
    cmd_args_t cmd_args;
    int res;

    res = parseCommandLine(argc, argv, &cmd_args);
    if (res != 0) {
        print_usage();
        return res;
    }

    res = setOutputDirPath(&cmd_args, 0);
    if (res != 0) {
        return res;
    }

    gettimeofday(&current_time, 0);

    st = current_time.tv_sec * 1000000 + current_time.tv_usec;

    system("echo camerahal_test > /sys/power/wake_lock");

    switch (cmd_args.test_type) {
        case TEST_TYPE_REGRESSION:
            res = runRegressionTest(&cmd_args);
            break;

        case TEST_TYPE_FUNCTIONAL:
            res = runFunctionalTest();
            break;

        case TEST_TYPE_API:
            res = runApiTest();
            break;

        case TEST_TYPE_ERROR:
            res = runErrorTest(&cmd_args);
            break;
    }

    system("echo camerahal_test > /sys/power/wake_unlock");

    gettimeofday(&current_time, 0);
    end = current_time.tv_sec * 1000000 + current_time.tv_usec;
    delay = end - st;
    printf("Application closed after: %llu ms\n", delay);

    return res;
}