#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 <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 <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;

extern bool stopScript;
extern bool hardwareActive;
extern sp<Camera> camera;
extern sp<BufferSourceThread> bufferSourceOutputThread;
extern sp<BufferSourceInput> bufferSourceInput;
extern CameraParameters params;
extern ShotParameters shotParams;
extern bool shotConfigFlush;
extern bool streamCapture;
extern bool recordingMode;
extern int camera_index;
extern int rotation;
extern int previewRotation;
extern const param_Array captureSize[];
extern const param_Array VcaptureSize[];
extern const outformat outputFormat[];
extern const video_Codecs videoCodecs[];
extern const audio_Codecs audioCodecs[];
extern const V_bitRate VbitRate[];
extern const Zoom zoom [];
extern int previewSizeIDX;
extern bool reSizePreview;
extern bool previewRunning;
extern int captureSizeIDX;
extern float compensation;
extern int videoCodecIDX;
extern int outputFormatIDX;
extern int audioCodecIDX;
extern int VcaptureSizeIDX;
extern int VbitRateIDX;
extern int thumbSizeIDX;
extern int thumbQuality;
extern int jpegQuality;
extern int dump_preview;
extern int ippIDX_old;
extern const char *capture[];
extern int capture_mode;
extern int ippIDX;
extern const char *ipp_mode[];
extern int tempBracketRange;
extern int iso_mode;
extern int sharpness;
extern int contrast;
extern int zoomIDX;
extern int brightness;
extern int saturation;
extern int fpsRangeIdx;
extern int numAntibanding;
extern int numEffects;
extern int numawb;
extern int numExposureMode;
extern int numscene;
extern int numisoMode;
extern int numflash;
extern int numcaptureSize;
extern int numVcaptureSize;
extern int numpreviewSize;
extern int numthumbnailSize;
extern int numfocus;
extern int numpreviewFormat;
extern int numpictureFormat;
extern int nummodevalues;
extern int numLay;
extern int numCLay;
extern int constCnt;
extern int rangeCnt;
extern int * constFramerate;
extern int frameRateIDX;
extern int fpsRangeIdx;
extern int stereoLayoutIDX;
extern int stereoCapLayoutIDX;
extern int expBracketIdx;
int resol_index = 0;
int a = 0;
extern char * vstabstr;
extern char * vnfstr;
extern char * zoomstr;
extern char * smoothzoomstr;
extern char * videosnapshotstr;
extern char ** antiband;
extern char **effectss;
extern bool firstTime;
extern char **exposureMode;
extern char **awb;
extern char **scene;
extern char ** isoMode;
extern char ** modevalues;
extern char **focus;
extern char **flash;
extern char **previewFormatArray;
extern char **pictureFormatArray;
extern char ** fps_const_str;
extern char ** fps_range_str;
extern char ** rangeDescription;
extern param_Array ** capture_Array;
extern param_Array ** Vcapture_Array;
extern param_Array ** preview_Array;
extern param_Array ** thumbnail_Array;
extern timeval autofocus_start, picture_start;
extern const char *cameras[];
extern double latitude;
extern double degree_by_step;
extern double longitude;
extern double altitude;
extern char output_dir_path[];
extern char images_dir_path[];
extern int AutoConvergenceModeIDX;
extern const char *autoconvergencemode[];
extern int numCamera;
extern bool stereoMode;
extern char script_name[];
extern int bufferStarvationTest;
extern size_t length_previewSize;
extern size_t length_thumbnailSize;
extern size_t lenght_Vcapture_size;
extern size_t length_outformat;
extern size_t length_capture_Size;
extern size_t length_video_Codecs;
extern size_t length_audio_Codecs;
extern size_t length_V_bitRate;
extern size_t length_Zoom;
extern size_t length_fps_ranges;
extern size_t length_fpsConst_Ranges;
extern size_t length_fpsConst_RangesSec;
extern int platformID;
extern char **stereoLayout;
extern char **stereoCapLayout;
extern void getSizeParametersFromCapabilities();
extern int exposure_mode;
int manE = 0;
extern int manualExp ;
extern int manualExpMin ;
extern int manualExpMax ;
int manG = 0;
extern int manualGain ;
extern int manualGainMin ;
extern int manualGainMax ;
int manC = 0;
extern int manualConv ;
extern int manualConvMin ;
extern int manualConvMax ;
extern bool faceDetectToggle;
extern unsigned int burstCount;
extern int iterationCount;
extern bool iterationPrint;

/** Buffer source reset */
extern bool bufferSourceInputReset;
extern bool bufferSourceOutputReset;

void trim_script_cmd(char *cmd) {
    char *nl, *cr;

    // first remove all carriage return symbols
    while ( NULL != (cr = strchr(cmd, '\r'))) {
        for (char *c = cr; '\0' != *c; c++) {
            *c = *(c+1);
        }
    }
    if (iterationPrint) {
        printf("\n==============\n");
        printf("IterationCount: %d", iterationCount);
        printf("\n==============\n");
        iterationPrint = false;
    }
    // Iteration Counter
    while ( NULL != (nl = strchr(cmd, '\n')) || NULL != (nl = strchr(cmd, '\r\n'))) {
            iterationPrint = true;
            iterationCount ++;
            break;
            }

    // then remove all single line feed symbols
    while ( NULL != (nl = strchr(cmd, '\n'))) {
        if (*nl == *(nl+1)) {
            // two or more concatenated newlines:
            // end of script found
            break;
        }
        // clip the newline
        for (char *c = nl; '\0' != *c; c++) {
            *c = *(c+1);
        }
    }
}

int execute_functional_script(char *script) {
    char *cmd, *ctx, *cycle_cmd, *temp_cmd;
    char id;
    unsigned int i;
    int dly;
    int cycleCounter = 1;
    int tLen = 0;
    unsigned int iteration = 0;
    bool zoomtoggle = false;
    bool smoothzoomtoggle = false;
    status_t ret = NO_ERROR;
    //int frameR = 20;
    int frameRConst = 0;
    int frameRRange = 0;
    struct CameraInfo cameraInfo;
    bool queueEmpty = true;

    LOG_FUNCTION_NAME;

    dump_mem_status();

    cmd = strtok_r((char *) script, DELIMITER, &ctx);

    while ( NULL != cmd && (stopScript == false)) {
        trim_script_cmd(cmd);
        id = cmd[0];
        printf("Full Command: %s \n", cmd);
        printf("Command: %c \n", cmd[0]);

        switch (id) {

            // Case for Suspend-Resume Feature
            case '!': {
                // STEP 1: Mount Debugfs
                system("mkdir /debug");
                system("mount -t debugfs debugfs /debug");

                // STEP 2: Set up wake up Timer - wake up happens after 5 seconds
                system("echo 10 > /debug/pm_debug/wakeup_timer_seconds");

                // STEP 3: Make system ready for Suspend
                system("echo camerahal_test > /sys/power/wake_unlock");
                // Release wake lock held by test app
                printf(" Wake lock released ");
                system("cat /sys/power/wake_lock");
                system("sendevent /dev/input/event0 1 60 1");
                system("sendevent /dev/input/event0 1 60 0");
                // Simulate F2 key press to make display OFF
                printf(" F2 event simulation complete ");

                //STEP 4: Wait for system Resume and then simuate F1 key
                sleep(50);//50s  // This delay is not related to suspend resume timer
                printf(" After 30 seconds of sleep");
                system("sendevent /dev/input/event0 1 59 0");
                system("sendevent /dev/input/event0 1 59 1");
                // Simulate F1 key press to make display ON
                system("echo camerahal_test > /sys/power/wake_lock");
                // Acquire wake lock for test app

                break;
            }

            case '[':
                if ( hardwareActive )
                    {

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

                    printf("starting camera preview..");
                    status_t ret = camera->startPreview();
                    if(ret !=NO_ERROR)
                        {
                        printf("startPreview failed %d..", ret);
                        }
                    }
                break;
            case '+': {
                cycleCounter = atoi(cmd + 1);
                cycle_cmd = get_cycle_cmd(ctx);
                tLen = strlen(cycle_cmd);
                temp_cmd = new char[tLen+1];

                for (int ind = 0; ind < cycleCounter; ind++) {
                    strcpy(temp_cmd, cycle_cmd);
                    if ( execute_functional_script(temp_cmd) != 0 )
                      return -1;
                    temp_cmd[0] = '\0';

                    //patch for image capture
                    //[
                    if (ind < cycleCounter - 1) {
                        if (hardwareActive == false) {
                            if ( openCamera() < 0 ) {
                                printf("Camera initialization failed\n");

                                return -1;
                            }

                            initDefaults();
                        }
                    }

                    //]
                }

                ctx += tLen + 1;

                if (temp_cmd) {
                    delete temp_cmd;
                    temp_cmd = NULL;
                }

                if (cycle_cmd) {
                    delete cycle_cmd;
                    cycle_cmd = NULL;
                }

                break;
            }

            case '0':
            {
                initDefaults();
                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 = atoi(cmd + 1);
                params.set(CameraParameters::KEY_ROTATION, rotation);

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

                break;

            case 'V':
                previewRotation = atoi(cmd + 1);
                params.set(KEY_SENSOR_ORIENTATION, previewRotation);

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

                break;

            case '4':
                printf("Setting resolution...");

                a = checkSupportedParamScriptResol(preview_Array, numpreviewSize, cmd, &resol_index);
                if (a > -1) {
                    params.setPreviewSize(preview_Array[resol_index]->width, preview_Array[resol_index]->height);
                    previewSizeIDX = resol_index;
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }
                if ( hardwareActive && previewRunning ) {
                    camera->stopPreview();
                    camera->setParameters(params.flatten());
                    camera->startPreview();
                } else if ( hardwareActive ) {
                    camera->setParameters(params.flatten());
                }
                break;

            case '5':
                if( strcmp((cmd + 1), "MAX_CAPTURE_SIZE") == 0) {
                    resol_index = 0;
                    for (int i=0; i<numcaptureSize; i++) {
                        if ((capture_Array[resol_index]->width * capture_Array[resol_index]->height) < (capture_Array[i]->width * capture_Array[i]->height)) {
                            resol_index = i;
                        }
                    }
                    if ((0 < capture_Array[resol_index]->width) && (0 < capture_Array[resol_index]->height)) {
                        params.setPictureSize(capture_Array[resol_index]->width, capture_Array[resol_index]->height);
                        captureSizeIDX = resol_index;
                        printf("Capture Size set: %dx%d\n", capture_Array[resol_index]->width, capture_Array[resol_index]->height);
                    } else {
                        printf("\nCapture size is 0!\n");
                    }
                } else {
                    a = checkSupportedParamScriptResol(capture_Array, numcaptureSize, cmd, &resol_index);
                    if (camera_index != 2) {
                        if (a > -1) {
                            params.setPictureSize(capture_Array[resol_index]->width, capture_Array[resol_index]->height);
                            captureSizeIDX = resol_index;
                        } else {
                            printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                        }
                    } else {
                        int widthC, heightC;
                        char *resC = NULL;
                        resC = strtok(cmd + 1, "x");
                        widthC = atoi(resC);
                        resC = strtok(NULL, "x");
                        heightC = atoi(resC);
                        params.setPictureSize(widthC,heightC);
                    a = checkSupportedParamScriptResol(capture_Array, numcaptureSize,
                                                       widthC, heightC, &resol_index);
                    if (a > -1) captureSizeIDX = resol_index;
                    }

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

                requestBufferSourceReset();

                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':
                compensation = atof(cmd + 1);
                params.set(KEY_COMPENSATION, (int) (compensation * 10));

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

                break;

            case '8':

                a = checkSupportedParamScript(awb, numawb, cmd);
                if (a > -1) {
                    params.set(params.KEY_WHITE_BALANCE, (cmd + 1));
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

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

                break;

            case '9':
                for(i = 0; i < length_video_Codecs; i++)
                {
                    if( strcmp((cmd + 1), videoCodecs[i].desc) == 0)
                    {
                        videoCodecIDX = i;
                        printf("Video Codec Selected: %s\n",
                                videoCodecs[i].desc);
                        break;
                    }
                }
                break;

            case 'v':
                for(i = 0; i < length_outformat; i++)

                {
                    if( strcmp((cmd + 1), outputFormat[i].desc) == 0)
                    {
                        outputFormatIDX = i;
                        printf("Video Codec Selected: %s\n",
                                videoCodecs[i].desc);
                        break;
                    }
                }
            break;

            case '~':

                a = checkSupportedParamScript(previewFormatArray, numpreviewFormat, cmd);
                if (a > -1) {
                    params.setPreviewFormat(cmd + 1);
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

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

                break;

            case '$':

                a = checkSupportedParamScript(pictureFormatArray, numpictureFormat, cmd);
                if (a > -1) {
                    params.setPictureFormat(cmd + 1);
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

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

                break;
            case '-':
                for(i = 0; i < length_audio_Codecs; i++)
                {
                    if( strcmp((cmd + 1), audioCodecs[i].desc) == 0)
                    {
                        audioCodecIDX = i;
                        printf("Selected Audio: %s\n", audioCodecs[i].desc);
                        break;
                    }
                }
                break;

            case 'A':
                camera_index=atoi(cmd+1);
                camera_index %= numCamera;

                printf("%s selected.\n", cameras[camera_index]);
                firstTime = true;

                if ( hardwareActive ) {
                    stopPreview();
                    closeCamera();
                    openCamera();
                } else {
                    closeCamera();
                    openCamera();
                }
                break;

            case 'a':
                char * temp_str;

                temp_str = strtok(cmd+1,"!");
                printf("Latitude %s \n",temp_str);
                params.set(params.KEY_GPS_LATITUDE, temp_str);
                temp_str=strtok(NULL,"!");
                printf("Longitude %s \n",temp_str);
                params.set(params.KEY_GPS_LONGITUDE, temp_str);
                temp_str=strtok(NULL,"!");
                printf("Altitude %s \n",temp_str);
                params.set(params.KEY_GPS_ALTITUDE, temp_str);

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

            case 'l':
                a = checkSupportedParamScriptResol(Vcapture_Array, numVcaptureSize, cmd, &resol_index);
                if (a > -1) {
                    VcaptureSizeIDX = resol_index;
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }
                break;

            case 'L':
                if(stereoMode)
                {
                    a = checkSupportedParamScriptLayout(stereoLayout, numLay, cmd, &stereoLayoutIDX);
                    if (a > -1) {
                        params.set(KEY_S3D_PRV_FRAME_LAYOUT, cmd + 1);
                    } else {
                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                    }


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


            case '.':
                if(stereoMode)
                {
                    a = checkSupportedParamScriptLayout(stereoCapLayout, numCLay, cmd, &stereoCapLayoutIDX);
                    if (a > -1) {
                        params.set(KEY_S3D_CAP_FRAME_LAYOUT_VALUES, cmd + 1);
                    } else {
                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                    }


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

            case ']':
                for(i = 0; i < length_V_bitRate; i++)
                {
                    if( strcmp((cmd + 1), VbitRate[i].desc) == 0)
                    {
                        VbitRateIDX = i;
                        printf("Video Bit Rate: %s\n", VbitRate[i].desc);
                        break;
                    }
                }
                break;
            case ':':

                a = checkSupportedParamScriptResol(thumbnail_Array, numthumbnailSize, cmd, &resol_index);
                if (a > -1) {
                    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, thumbnail_Array[resol_index]->width);
                    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,thumbnail_Array[resol_index]->height);
                    thumbSizeIDX = resol_index;
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

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


                break;

            case '\'':
                thumbQuality = atoi(cmd + 1);

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

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

            case 't':
                params.setPreviewFormat((cmd + 1));
                if ( hardwareActive )
                    camera->setParameters(params.flatten());
                break;

            case 'o':
                jpegQuality = atoi(cmd + 1);
                params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);

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

                break;


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


            case 'k':
                ippIDX_old = atoi(cmd + 1);
                params.set(KEY_IPP, atoi(cmd + 1));
                if ( hardwareActive )
                    camera->setParameters(params.flatten());

                requestBufferSourceReset();

                break;

            case 'K':
                params.set(KEY_GBCE, (cmd+1));
                if ( hardwareActive )
                    camera->setParameters(params.flatten());

                break;

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

                break;

            case 'I':
                params.set(KEY_AF_TIMEOUT, (cmd + 1));

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

                break;

            case 'T':

                if ( hardwareActive ) {
                    camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0);
                    faceDetectToggle = false;
                }

                break;

            case 'O':
                params.set(KEY_GLBCE, (cmd+1));
                if ( hardwareActive )
                    camera->setParameters(params.flatten());

                break;

            case 'u':
                // HQ should always be in ldc-nsf
                // if not HQ, then return the ipp to its previous state
                if ( !strcmp((cmd + 1), "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((cmd + 1), "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);
                    }
                    printf("previewRotation: %d\n", previewRotation);
                } else {
                    ippIDX = ippIDX_old;
                    params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
                    previewRotation = 0;
                    params.set(KEY_SENSOR_ORIENTATION, previewRotation);
                }
                a = checkSupportedParamScript(modevalues, nummodevalues, cmd);
                if (a > -1) {
                    params.set(KEY_MODE, (cmd + 1));
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

                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':

                params.set(KEY_TEMP_BRACKETING, (cmd + 1));

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

                break;

            case 'H':

                setDefaultExpGainPreset(shotParams, atoi(cmd + 1));
                break;


            case 'n':

            switch (*(cmd + 1)) {
                case 0:
                shotConfigFlush = false;
                    break;
                case 1:
                shotConfigFlush = true;
                    break;
                default:
                printf ("Mangling flush shot config command: \"%s\"\n", (cmd + 1));
                    break;
            }

            updateShotConfigFlushParam();

            break;

            case '?':

                setExpGainPreset(shotParams, cmd + 1, true, PARAM_EXP_BRACKET_PARAM_NONE, shotConfigFlush);

                break;

            case 'W':

                tempBracketRange = atoi(cmd + 1);
                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 '#':

                params.set(KEY_TI_BURST, atoi(cmd + 1));
                burstCount = atoi(cmd + 1);

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

                break;

            case 'J':

                a = checkSupportedParamScript(flash, numflash, cmd);
                if (a > -1) {
                    params.set(CameraParameters::KEY_FLASH_MODE, (cmd + 1));
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

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

                break;

            case 'w':

                a = checkSupportedParamScript(scene, numscene, cmd);
                if (a > -1) {
                    params.set(params.KEY_SCENE_MODE, (cmd + 1));
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }
                if ( hardwareActive )
                    camera->setParameters(params.flatten());

                break;

            case 'B' :
                if(strcmp(vnfstr, "true") == 0) {
                    if (strcmp(cmd + 1, "1") == 0) {
                        trySetVideoNoiseFilter(true);
                    }
                    else if (strcmp(cmd + 1, "0") == 0){
                        trySetVideoNoiseFilter(false);
                    }
                } else {
                    trySetVideoNoiseFilter(false);
                    printf("\n VNF is not supported \n\n");
                }

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


            case 'C' :

                if (strcmp(vstabstr, "true") == 0) {
                    if (strcmp(cmd + 1, "1") == 0) {
                        trySetVideoStabilization(true);
                    } else if (strcmp(cmd + 1, "0") == 0) {
                        trySetVideoStabilization(false);
                    } else {
                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                    }
                } else {
                    printf("\nNot supported parameter vstab from sensor %d\n\n", camera_index);
                }

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

            case 'D':
                if ( hardwareActive )
                    camera->stopRecording();
                break;

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

            case 'i':
                iso_mode = atoi(cmd + 1);
                if (iso_mode < numisoMode) {
                    params.set(KEY_ISO, isoMode[iso_mode]);
                } else {
                    printf("\nNot supported parameter %s for iso mode from sensor %d\n\n", cmd + 1, camera_index);
                }

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

                break;

            case 'h':
                sharpness = atoi(cmd + 1);
                params.set(KEY_SHARPNESS, sharpness);

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

                break;

            case '@':
                if ( hardwareActive ) {

                    closeCamera();

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

                break;

            case 'c':
                contrast = atoi(cmd + 1);
                params.set(KEY_CONTRAST, contrast);

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

                break;

            case 'z':
                zoomtoggle = false;

                if(strcmp(zoomstr, "true") == 0) {
                    for(i = 0; i < length_Zoom; i++) {
                        if( strcmp((cmd + 1), zoom[i].zoom_description) == 0) {
                            zoomIDX = i;
                            zoomtoggle = true;
                            break;
                        }
                    }

                    if (!zoomtoggle) {
                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                    }


                    params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);

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

            case 'Z':
                smoothzoomtoggle = false;

                if(strcmp(smoothzoomstr, "true") == 0) {
                    for(i = 0; i < length_Zoom; i++) {
                        if( strcmp((cmd + 1), zoom[i].zoom_description) == 0) {
                            zoomIDX = i;
                            smoothzoomtoggle = true;
                            break;
                        }
                    }

                    if (!smoothzoomtoggle) {
                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                    }

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

            case 'j':

                a = checkSupportedParamScript(exposureMode, numExposureMode, cmd);
                if (a > -1) {
                    params.set(KEY_EXPOSURE, (cmd + 1));
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

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

                break;

            case 'b':
                brightness = atoi(cmd + 1);
                params.set(KEY_BRIGHTNESS, brightness);

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

                break;

            case 's':
                saturation = atoi(cmd + 1);
                params.set(KEY_SATURATION, saturation);

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

                break;

            case 'e':
                a = checkSupportedParamScript(effectss, numEffects, cmd);
                if (a > -1) {
                    params.set(params.KEY_EFFECT, (cmd + 1));
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

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

                break;

            case 'r':
                if (strcmp((cmd + 1), "MAX_FRAMERATE") == 0) {
                    frameRConst = 0;
                    for (int i=0; i<constCnt; i++) {
                        if (constFramerate[frameRConst] < constFramerate[i]) {
                            frameRConst = i;
                        }
                    }
                    if (0 < constFramerate[frameRConst]) {
                        params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRConst]);
                        frameRateIDX = frameRConst;
                        printf("Framerate set: %d fps\n", constFramerate[frameRConst]);
                    } else {
                        printf("\nFramerate is 0!\n");
                    }
                } else {
                    a = checkSupportedParamScriptfpsConst(constFramerate, constCnt, cmd, &frameRConst);
                    if (a > -1) {
                        params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRConst]);
                        frameRateIDX = frameRConst;
                    } else {
                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                    }
                }
                if ( hardwareActive && previewRunning ) {
                    camera->stopPreview();
                    camera->setParameters(params.flatten());
                    camera->startPreview();
                } else if ( hardwareActive ) {
                    camera->setParameters(params.flatten());
                }
                break;

            case 'R':
                a = checkSupportedParamScriptfpsRange(rangeDescription, rangeCnt, cmd, &frameRRange);
                if (a > -1) {
                    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_range_str[frameRRange]);
                    fpsRangeIdx = frameRRange;
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }
                break;

            case 'x':
                a = checkSupportedParamScript(antiband, numAntibanding, cmd);
                if (a > -1) {
                params.set(params.KEY_ANTIBANDING, (cmd + 1));
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

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

            case 'g':
                a = checkSupportedParamScript(focus, numfocus, cmd);
                if (a > -1) {
                    params.set(params.KEY_FOCUS_MODE, (cmd + 1));
                } else {
                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
                }

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

            case 'G':

                params.set(CameraParameters::KEY_FOCUS_AREAS, (cmd + 1));

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

                break;

            case 'y':

                params.set(CameraParameters::KEY_METERING_AREAS, (cmd + 1));

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

                break;

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

                if ( hardwareActive )
                    camera->autoFocus();

                break;

            case 'p':
            {
                int msgType = 0;
                const char *format = params.getPictureFormat();

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

                    gettimeofday(&picture_start, 0);
                    ret = camera->setParameters(params.flatten());
                    if ( ret != NO_ERROR ) {
                        printf("Error returned while setting parameters");
                        break;
                    }
                    ret = camera->takePictureWithParameters(msgType, shotParams.flatten());
                    if ( ret != NO_ERROR ) {
                        printf("Error returned while taking a picture");
                        break;
                    }
                }
                break;
            }

            case 'S':
            {
                if (streamCapture) {
                    streamCapture = false;
                    expBracketIdx = BRACKETING_IDX_DEFAULT;
                    setDefaultExpGainPreset(shotParams, expBracketIdx);
                    // Stop streaming
                    if (bufferSourceOutputThread.get()) {
                        bufferSourceOutputThread->setStreamCapture(streamCapture, expBracketIdx);
                    }
                } else {
                    streamCapture = true;
                    expBracketIdx = BRACKETING_IDX_STREAM;
                    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, params.getPictureFormat(), reprocParams);
                        if (hardwareActive) camera->reprocess(msgType, String8());
                    }
                }
                break;
            }

            case 'd':
                dly = atoi(cmd + 1);
                sleep(dly);
                break;

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

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

                    recordingMode = false;
                }
                goto exit;

            case '\n':
                printf("Iteration: %d \n", iteration);
                iteration++;
                break;

            case '{':
                if ( atoi(cmd + 1) > 0 )
                    params.set(KEY_S3D2D_PREVIEW_MODE, "on");
                else
                    params.set(KEY_S3D2D_PREVIEW_MODE, "off");
                if ( hardwareActive )
                    camera->setParameters(params.flatten());
                break;

            case 'M':
                params.set(KEY_MEASUREMENT, (cmd + 1));
                if ( hardwareActive )
                    camera->setParameters(params.flatten());
                break;
            case 'm':
            {
                params.set(KEY_METERING_MODE, (cmd + 1));
                if ( hardwareActive )
                {
                    camera->setParameters(params.flatten());
                }
                break;
            }
            case '<':
            {
                char coord_str[8];
                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 '=':
            {
                char coord_str[8];
                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 '>':
            {
                char coord_str[8];
                altitude += 12345.67890123456789;
                if (altitude > 100000.0)
                {
                    altitude -= 200000.0;
                }
                snprintf(coord_str, 7, "%.7lf", altitude);
                params.set(params.KEY_GPS_ALTITUDE, coord_str);
                if ( hardwareActive )
                {
                    camera->setParameters(params.flatten());
                }
                break;
            }

            case 'X':
            {
                char rem_str[384];
                printf("Deleting images from %s \n", images_dir_path);
                if (!sprintf(rem_str, "rm %s/*.jpg", images_dir_path)) {
                    printf("Sprintf Error");
                }
                if (system(rem_str)) {
                    printf("Images were not deleted\n");
                }
                break;
            }

            case '_':
            {
                AutoConvergenceModeIDX = atoi(cmd + 1);
                if ( AutoConvergenceModeIDX < 0 || AutoConvergenceModeIDX > 4 )
                    AutoConvergenceModeIDX = 0;
                params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
                if (AutoConvergenceModeIDX != 4) {
                    params.set(KEY_MANUAL_CONVERGENCE, manualConv);
                }
                if (hardwareActive) {
                    camera->setParameters(params.flatten());
                }
                break;
            }

            case '^':
                if (strcmp(autoconvergencemode[AutoConvergenceModeIDX], "manual") == 0) {
                    manC = atoi(cmd + 1);
                    if(manC >= manualConvMin  &&  manC <= manualConvMax)
                    {
                        params.set(KEY_MANUAL_CONVERGENCE, manC);
                    }
                    else if(manC < manualConvMin)
                    {
                        printf(" wrong parameter for manual convergence \n");
                        params.set(KEY_MANUAL_CONVERGENCE, manualConvMin);
                    }
                    else
                    {
                        printf(" wrong parameter for manual convergence \n");
                        params.set(KEY_MANUAL_CONVERGENCE, manualConvMax);
                    }
                    if ( hardwareActive )
                        camera->setParameters(params.flatten());
                }
                break;


            case 'Q':
                if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
                    manE = atoi(cmd + 1);
                    if(manE >= manualExpMin  &&  manE <= manualExpMax)
                    {
                        params.set(KEY_MANUAL_EXPOSURE, manE);
                        params.set(KEY_MANUAL_EXPOSURE_RIGHT, manE);
                    }
                    else if(manE < manualExpMin)
                    {
                        printf(" wrong parameter for manual exposure \n");
                        params.set(KEY_MANUAL_EXPOSURE, manualExpMin);
                        params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExpMin);
                    }
                    else
                    {
                        printf(" wrong parameter for manual exposure \n");
                        params.set(KEY_MANUAL_EXPOSURE, manualExpMax);
                        params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExpMax);
                    }

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

            case ',':
                if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
                    manG = atoi(cmd + 1);
                    if(manG >= manualGainMin  &&  manG <= manualGainMax)
                    {
                        params.set(KEY_MANUAL_GAIN_ISO, manG);
                        params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manG);
                    }
                    else if(manG < manualGainMin)
                    {
                        printf(" wrong parameter for manual gain \n");
                        params.set(KEY_MANUAL_GAIN_ISO, manualGainMin);
                        params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGainMin);
                    }
                    else
                    {
                        printf(" wrong parameter for manual gain \n");
                        params.set(KEY_MANUAL_GAIN_ISO, manualGainMax);
                        params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGainMax);
                    }

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

            default:
                printf("Unrecognized command!\n");
                break;
        }

        cmd = strtok_r(NULL, DELIMITER, &ctx);
    }

exit:
    if (stopScript == true)
      {
        return -1;
      }
    else
      {
        return 0;
      }
}


int checkSupportedParamScript(char **array, int size, char *param) {
    for (int i=0; i<size; i++) {
        if (strcmp((param + 1), array[i]) == 0) {
            return 0;
        }
    }
    return -1;
}

int checkSupportedParamScriptLayout(char **array, int size, char *param, int *index) {
    for (int i=0; i<size; i++) {
        if (strcmp((param + 1), array[i]) == 0) {
            *index = i;
            return 0;
        }
    }
    return -1;
}

int checkSupportedParamScriptResol(param_Array **array, int size, char *param, int *num) {
    for (int i=0; i<size; i++) {
        if (strcmp((param + 1), array[i]->name) == 0) {
            *num = i;
            return 0;
        }
    }
    return -1;
}

int checkSupportedParamScriptResol(param_Array **array, int size,
                                   int width, int height, int *num) {
    for (int i=0; i<size; i++) {
        if ((width == array[i]->width) && (height == array[i]->height)) {
            *num = i;
            return 0;
        }
    }
    return -1;
}

int checkSupportedParamScriptfpsConst(int *array, int size, char *param, int *num) {
    for (int i=0; i<size; i++) {
        if (atoi(param + 1) == array[i]) {
            *num = i;
            return 0;
        }
    }
    return -1;
}

int checkSupportedParamScriptfpsRange(char **array, int size, char *param, int *num) {
    for (int i=0; i<size; i++) {
        if (strcmp(param + 1, array[i]) == 0) {
            *num = i;
            return 0;
        }
    }
    return -1;
}

char * get_cycle_cmd(const char *aSrc) {
    unsigned ind = 0;
    char *cycle_cmd = new char[256];

    while ((*aSrc != '+') && (*aSrc != '\0')) {
        cycle_cmd[ind++] = *aSrc++;
    }
    cycle_cmd[ind] = '\0';

    return cycle_cmd;
}

status_t dump_mem_status() {
  system(MEDIASERVER_DUMP);
  return system(MEMORY_DUMP);
}

char *load_script(const char *config) {
    FILE *infile;
    size_t fileSize;
    char *script;
    size_t nRead = 0;

    infile = fopen(config, "r");

    strcpy(script_name,config);

    printf("\n SCRIPT : <%s> is currently being executed \n", script_name);

    printf("\n DIRECTORY CREATED FOR TEST RESULT IMAGES IN MMC CARD : %s \n", output_dir_path);

    if( (NULL == infile)){
        printf("Error while opening script file %s!\n", config);
        return NULL;
    }

    fseek(infile, 0, SEEK_END);
    fileSize = ftell(infile);
    fseek(infile, 0, SEEK_SET);

    script = (char *) malloc(fileSize + 1);

    if ( NULL == script ) {
        printf("Unable to allocate buffer for the script\n");

        return NULL;
    }

    memset(script, 0, fileSize + 1);

    if ((nRead = fread(script, 1, fileSize, infile)) != fileSize) {
        printf("Error while reading script file!\n");

        free(script);
        fclose(infile);
        return NULL;
    }

    fclose(infile);

    return script;
}

int start_logging(int flags, int &pid) {
    int status = 0;

    if (flags == 0) {
        pid = -1;
        return 0;
    }

    pid = fork();
    if (pid == 0)
    {
        char *command_list[] = {"sh", "-c", NULL, NULL};
        char log_cmd[1024];
        // child process to run logging

        // set group id of this process to itself
        // we will use this group id to kill the
        // application logging
        setpgid(getpid(), getpid());

        /* Start logcat */
        if (flags & LOGGING_LOGCAT) {
            if (!sprintf(log_cmd,"logcat > %s/log.txt &", output_dir_path)) {
                printf(" Sprintf Error");
            }
        }

        /* Start Syslink Trace */
        if (flags & LOGGING_SYSLINK) {
            if (!sprintf(log_cmd,"%s /system/bin/syslink_trace_daemon.out -l %s/syslink_trace.txt -f &", log_cmd, output_dir_path)) {
                printf(" Sprintf Error");
            }
        }

        command_list[2] = (char *)log_cmd;
        execvp("/system/bin/sh", command_list);
    } if(pid < 0)
    {
        printf("failed to fork logcat\n");
        return -1;
    }

    //wait for logging to start
    if(waitpid(pid, &status, 0) != pid)
    {
        printf("waitpid failed in log fork\n");
        return -1;
    }else
        printf("logging started... status=%d\n", status);

    return 0;
}

int stop_logging(int flags, int &pid)
{
    if (pid > 0) {
        if (killpg(pid, SIGKILL)) {
            printf("Exit command failed");
            return -1;
        } else {
            printf("\nlogging for script %s is complete\n", script_name);

            if (flags & LOGGING_LOGCAT) {
                printf("   logcat saved @ location: %s\n", output_dir_path);
            }

            if (flags & LOGGING_SYSLINK) {
                printf("   syslink_trace is saved @ location: %s\n\n", output_dir_path);
            }
        }
    }
    return 0;
}

int execute_error_script(char *script) {
    char *cmd, *ctx;
    char id;
    status_t stat = NO_ERROR;

    LOG_FUNCTION_NAME;

    cmd = strtok_r((char *) script, DELIMITER, &ctx);

    while ( NULL != cmd ) {
        id = cmd[0];

        switch (id) {

            case '0': {
                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': {
                int* tMemoryEater = new int[999999999];

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

                break;
            }

            case '2': {
                //camera = Camera::connect();

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

                break;
            }

            case '3': {
                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': {
                goto exit;

                break;
            }

            default: {
                printf("Unrecognized command!\n");

                break;
            }
        }

        cmd = strtok_r(NULL, DELIMITER, &ctx);
    }

exit:

    return 0;
}