camera_test_script.cpp revision fd2c5e05707c33c8672f0e95f26837b4053eb74b 
1#include <stdlib.h>
2#include <unistd.h>
3#include <sys/types.h>
4#include <sys/stat.h>
5#include <fcntl.h>
6#include <time.h>
7#include <semaphore.h>
8#include <pthread.h>
9
10#include <camera/Camera.h>
11#include <camera/ICamera.h>
12#include <media/mediarecorder.h>
13
14#include <binder/IPCThreadState.h>
15#include <binder/ProcessState.h>
16#include <binder/IServiceManager.h>
17#include <cutils/properties.h>
18#include <camera/CameraParameters.h>
19#include <camera/ShotParameters.h>
20
21#include <sys/wait.h>
22
23#include "camera_test.h"
24#include "camera_test_surfacetexture.h"
25#ifdef ANDROID_API_JB_OR_LATER
26#include "camera_test_bufferqueue.h"
27#endif
28
29using namespace android;
30
31extern bool stopScript;
32extern bool hardwareActive;
33extern sp<Camera> camera;
34extern sp<BufferSourceThread> bufferSourceOutputThread;
35extern sp<BufferSourceInput> bufferSourceInput;
36extern CameraParameters params;
37extern ShotParameters shotParams;
38extern bool shotConfigFlush;
39extern bool recordingMode;
40extern int camera_index;
41extern int rotation;
42extern int previewRotation;
43extern const param_Array captureSize[];
44extern const param_Array VcaptureSize[];
45extern const outformat outputFormat[];
46extern const video_Codecs videoCodecs[];
47extern const audio_Codecs audioCodecs[];
48extern const V_bitRate VbitRate[];
49extern const Zoom zoom [];
50extern int previewSizeIDX;
51extern bool reSizePreview;
52extern bool previewRunning;
53extern int captureSizeIDX;
54extern float compensation;
55extern int videoCodecIDX;
56extern int outputFormatIDX;
57extern int audioCodecIDX;
58extern int VcaptureSizeIDX;
59extern int VbitRateIDX;
60extern int thumbSizeIDX;
61extern int thumbQuality;
62extern int jpegQuality;
63extern int dump_preview;
64extern int ippIDX_old;
65extern const char *capture[];
66extern int capture_mode;
67extern int ippIDX;
68extern const char *ipp_mode[];
69extern int tempBracketRange;
70extern int iso_mode;
71extern int sharpness;
72extern int contrast;
73extern int zoomIDX;
74extern int brightness;
75extern int saturation;
76extern int fpsRangeIdx;
77extern int numAntibanding;
78extern int numEffects;
79extern int numawb;
80extern int numExposureMode;
81extern int numscene;
82extern int numisoMode;
83extern int numflash;
84extern int numcaptureSize;
85extern int numVcaptureSize;
86extern int numpreviewSize;
87extern int numthumbnailSize;
88extern int numfocus;
89extern int numpreviewFormat;
90extern int numpictureFormat;
91extern int nummodevalues;
92extern int numLay;
93extern int numCLay;
94extern int constCnt;
95extern int rangeCnt;
96extern int * constFramerate;
97extern int frameRateIDX;
98extern int fpsRangeIdx;
99extern int stereoLayoutIDX;
100extern int stereoCapLayoutIDX;
101extern int expBracketIdx;
102int resol_index = 0;
103int a = 0;
104extern char * vstabstr;
105extern char * vnfstr;
106extern char * zoomstr;
107extern char * smoothzoomstr;
108extern char * videosnapshotstr;
109extern char ** antiband;
110extern char **effectss;
111extern bool firstTime;
112extern char **exposureMode;
113extern char **awb;
114extern char **scene;
115extern char ** isoMode;
116extern char ** modevalues;
117extern char **focus;
118extern char **flash;
119extern char **previewFormatArray;
120extern char **pictureFormatArray;
121extern char ** fps_const_str;
122extern char ** fps_range_str;
123extern char ** rangeDescription;
124extern param_Array ** capture_Array;
125extern param_Array ** Vcapture_Array;
126extern param_Array ** preview_Array;
127extern param_Array ** thumbnail_Array;
128extern timeval autofocus_start, picture_start;
129extern const char *cameras[];
130extern double latitude;
131extern double degree_by_step;
132extern double longitude;
133extern double altitude;
134extern char output_dir_path[];
135extern char images_dir_path[];
136extern int AutoConvergenceModeIDX;
137extern const char *autoconvergencemode[];
138extern int numCamera;
139extern bool stereoMode;
140extern char script_name[];
141extern int bufferStarvationTest;
142extern size_t length_previewSize;
143extern size_t length_thumbnailSize;
144extern size_t lenght_Vcapture_size;
145extern size_t length_outformat;
146extern size_t length_capture_Size;
147extern size_t length_video_Codecs;
148extern size_t length_audio_Codecs;
149extern size_t length_V_bitRate;
150extern size_t length_Zoom;
151extern size_t length_fps_ranges;
152extern size_t length_fpsConst_Ranges;
153extern size_t length_fpsConst_RangesSec;
154extern int platformID;
155extern char **stereoLayout;
156extern char **stereoCapLayout;
157extern void getSizeParametersFromCapabilities();
158extern int exposure_mode;
159int manE = 0;
160extern int manualExp ;
161extern int manualExpMin ;
162extern int manualExpMax ;
163int manG = 0;
164extern int manualGain ;
165extern int manualGainMin ;
166extern int manualGainMax ;
167int manC = 0;
168extern int manualConv ;
169extern int manualConvMin ;
170extern int manualConvMax ;
171extern bool faceDetectToggle;
172extern unsigned int burstCount;
173
174void trim_script_cmd(char *cmd) {
175    char *nl, *cr;
176
177    // first remove all carriage return symbols
178    while ( NULL != (cr = strchr(cmd, '\r'))) {
179        for (char *c = cr; '\0' != *c; c++) {
180            *c = *(c+1);
181        }
182    }
183
184    // then remove all single line feed symbols
185    while ( NULL != (nl = strchr(cmd, '\n'))) {
186        if (*nl == *(nl+1)) {
187            // two or more concatenated newlines:
188            // end of script found
189            break;
190        }
191        // clip the newline
192        for (char *c = nl; '\0' != *c; c++) {
193            *c = *(c+1);
194        }
195    }
196}
197
198int execute_functional_script(char *script) {
199    char *cmd, *ctx, *cycle_cmd, *temp_cmd;
200    char id;
201    unsigned int i;
202    int dly;
203    int cycleCounter = 1;
204    int tLen = 0;
205    unsigned int iteration = 0;
206    bool zoomtoggle = false;
207    bool smoothzoomtoggle = false;
208    status_t ret = NO_ERROR;
209    //int frameR = 20;
210    int frameRConst = 0;
211    int frameRRange = 0;
212    struct CameraInfo cameraInfo;
213
214    LOG_FUNCTION_NAME;
215
216    dump_mem_status();
217
218    cmd = strtok_r((char *) script, DELIMITER, &ctx);
219
220    while ( NULL != cmd && (stopScript == false)) {
221        trim_script_cmd(cmd);
222        id = cmd[0];
223        printf("Full Command: %s \n", cmd);
224        printf("Command: %c \n", cmd[0]);
225
226        switch (id) {
227
228            // Case for Suspend-Resume Feature
229            case '!': {
230                // STEP 1: Mount Debugfs
231                system("mkdir /debug");
232                system("mount -t debugfs debugfs /debug");
233
234                // STEP 2: Set up wake up Timer - wake up happens after 5 seconds
235                system("echo 10 > /debug/pm_debug/wakeup_timer_seconds");
236
237                // STEP 3: Make system ready for Suspend
238                system("echo camerahal_test > /sys/power/wake_unlock");
239                // Release wake lock held by test app
240                printf(" Wake lock released ");
241                system("cat /sys/power/wake_lock");
242                system("sendevent /dev/input/event0 1 60 1");
243                system("sendevent /dev/input/event0 1 60 0");
244                // Simulate F2 key press to make display OFF
245                printf(" F2 event simulation complete ");
246
247                //STEP 4: Wait for system Resume and then simuate F1 key
248                sleep(50);//50s  // This delay is not related to suspend resume timer
249                printf(" After 30 seconds of sleep");
250                system("sendevent /dev/input/event0 1 59 0");
251                system("sendevent /dev/input/event0 1 59 1");
252                // Simulate F1 key press to make display ON
253                system("echo camerahal_test > /sys/power/wake_lock");
254                // Acquire wake lock for test app
255
256                break;
257            }
258
259            case '[':
260                if ( hardwareActive )
261                    {
262
263                    camera->setParameters(params.flatten());
264
265                    printf("starting camera preview..");
266                    status_t ret = camera->startPreview();
267                    if(ret !=NO_ERROR)
268                        {
269                        printf("startPreview failed %d..", ret);
270                        }
271                    }
272                break;
273            case '+': {
274                cycleCounter = atoi(cmd + 1);
275                cycle_cmd = get_cycle_cmd(ctx);
276                tLen = strlen(cycle_cmd);
277                temp_cmd = new char[tLen+1];
278
279                for (int ind = 0; ind < cycleCounter; ind++) {
280                    strcpy(temp_cmd, cycle_cmd);
281                    if ( execute_functional_script(temp_cmd) != 0 )
282                      return -1;
283                    temp_cmd[0] = '\0';
284
285                    //patch for image capture
286                    //[
287                    if (ind < cycleCounter - 1) {
288                        if (hardwareActive == false) {
289                            if ( openCamera() < 0 ) {
290                                printf("Camera initialization failed\n");
291
292                                return -1;
293                            }
294
295                            initDefaults();
296                        }
297                    }
298
299                    //]
300                }
301
302                ctx += tLen + 1;
303
304                if (temp_cmd) {
305                    delete temp_cmd;
306                    temp_cmd = NULL;
307                }
308
309                if (cycle_cmd) {
310                    delete cycle_cmd;
311                    cycle_cmd = NULL;
312                }
313
314                break;
315            }
316
317            case '0':
318            {
319                initDefaults();
320                break;
321            }
322
323            case '1':
324
325                if ( startPreview() < 0 ) {
326                    printf("Error while starting preview\n");
327
328                    return -1;
329                }
330
331                break;
332
333            case '2':
334                if ( recordingMode ) {
335                    stopRecording();
336                    stopPreview();
337                    closeRecorder();
338                    camera->disconnect();
339                    camera.clear();
340                    camera = Camera::connect(camera_index);
341                      if ( NULL == camera.get() ) {
342                          sleep(1);
343                          camera = Camera::connect(camera_index);
344                          if ( NULL == camera.get() ) {
345                              return -1;
346                          }
347                      }
348                      camera->setListener(new CameraHandler());
349                      camera->setParameters(params.flatten());
350                      recordingMode = false;
351                } else {
352                    stopPreview();
353                }
354                if (bufferSourceOutputThread.get()) {
355                    bufferSourceOutputThread->requestExit();
356                    bufferSourceOutputThread.clear();
357                }
358
359                break;
360
361            case '3':
362                rotation = atoi(cmd + 1);
363                params.set(CameraParameters::KEY_ROTATION, rotation);
364
365                if ( hardwareActive )
366                    camera->setParameters(params.flatten());
367
368                break;
369
370            case 'V':
371                previewRotation = atoi(cmd + 1);
372                params.set(KEY_SENSOR_ORIENTATION, previewRotation);
373
374                if ( hardwareActive )
375                    camera->setParameters(params.flatten());
376
377                break;
378
379            case '4':
380                printf("Setting resolution...");
381
382                a = checkSupportedParamScriptResol(preview_Array, numpreviewSize, cmd, &resol_index);
383                if (a > -1) {
384                    params.setPreviewSize(preview_Array[resol_index]->width, preview_Array[resol_index]->height);
385                    previewSizeIDX = resol_index;
386                } else {
387                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
388                }
389                if ( hardwareActive && previewRunning ) {
390                    camera->stopPreview();
391                    camera->setParameters(params.flatten());
392                    camera->startPreview();
393                } else if ( hardwareActive ) {
394                    camera->setParameters(params.flatten());
395                }
396                break;
397
398            case '5':
399                if( strcmp((cmd + 1), "MAX_CAPTURE_SIZE") == 0) {
400                    resol_index = 0;
401                    for (int i=0; i<numcaptureSize; i++) {
402                        if ((capture_Array[resol_index]->width * capture_Array[resol_index]->height) < (capture_Array[i]->width * capture_Array[i]->height)) {
403                            resol_index = i;
404                        }
405                    }
406                    if ((0 < capture_Array[resol_index]->width) && (0 < capture_Array[resol_index]->height)) {
407                        params.setPictureSize(capture_Array[resol_index]->width, capture_Array[resol_index]->height);
408                        captureSizeIDX = resol_index;
409                        printf("Capture Size set: %dx%d\n", capture_Array[resol_index]->width, capture_Array[resol_index]->height);
410                    } else {
411                        printf("\nCapture size is 0!\n");
412                    }
413                } else {
414                    a = checkSupportedParamScriptResol(capture_Array, numcaptureSize, cmd, &resol_index);
415                    if (camera_index != 2) {
416                        if (a > -1) {
417                            params.setPictureSize(capture_Array[resol_index]->width, capture_Array[resol_index]->height);
418                            captureSizeIDX = resol_index;
419                        } else {
420                            printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
421                        }
422                    } else {
423                        int widthC, heightC;
424                        char *resC = NULL;
425                        resC = strtok(cmd + 1, "x");
426                        widthC = atoi(resC);
427                        resC = strtok(NULL, "x");
428                        heightC = atoi(resC);
429                        params.setPictureSize(widthC,heightC);
430                    a = checkSupportedParamScriptResol(capture_Array, numcaptureSize,
431                                                       widthC, heightC, &resol_index);
432                    if (a > -1) captureSizeIDX = resol_index;
433                    }
434
435                    if ( hardwareActive ) {
436                        camera->setParameters(params.flatten());
437                    }
438                }
439                break;
440
441            case '6':
442
443                if ( !recordingMode ) {
444
445                    recordingMode = true;
446
447                    if ( startPreview() < 0 ) {
448                        printf("Error while starting preview\n");
449
450                        return -1;
451                    }
452
453                    if ( openRecorder() < 0 ) {
454                        printf("Error while openning video recorder\n");
455
456                        return -1;
457                    }
458
459                    if ( configureRecorder() < 0 ) {
460                        printf("Error while configuring video recorder\n");
461
462                        return -1;
463                    }
464
465                    if ( startRecording() < 0 ) {
466                        printf("Error while starting video recording\n");
467
468                        return -1;
469                    }
470
471                }
472
473                break;
474
475            case '7':
476                compensation = atof(cmd + 1);
477                params.set(KEY_COMPENSATION, (int) (compensation * 10));
478
479                if ( hardwareActive )
480                    camera->setParameters(params.flatten());
481
482                break;
483
484            case '8':
485
486                a = checkSupportedParamScript(awb, numawb, cmd);
487                if (a > -1) {
488                    params.set(params.KEY_WHITE_BALANCE, (cmd + 1));
489                } else {
490                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
491                }
492
493                if ( hardwareActive )
494                    camera->setParameters(params.flatten());
495
496                break;
497
498            case '9':
499                for(i = 0; i < length_video_Codecs; i++)
500                {
501                    if( strcmp((cmd + 1), videoCodecs[i].desc) == 0)
502                    {
503                        videoCodecIDX = i;
504                        printf("Video Codec Selected: %s\n",
505                                videoCodecs[i].desc);
506                        break;
507                    }
508                }
509                break;
510
511            case 'v':
512                for(i = 0; i < length_outformat; i++)
513
514                {
515                    if( strcmp((cmd + 1), outputFormat[i].desc) == 0)
516                    {
517                        outputFormatIDX = i;
518                        printf("Video Codec Selected: %s\n",
519                                videoCodecs[i].desc);
520                        break;
521                    }
522                }
523            break;
524
525            case '~':
526
527                a = checkSupportedParamScript(previewFormatArray, numpreviewFormat, cmd);
528                if (a > -1) {
529                    params.setPreviewFormat(cmd + 1);
530                } else {
531                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
532                }
533
534                if ( hardwareActive )
535                    camera->setParameters(params.flatten());
536
537                break;
538
539            case '$':
540
541                a = checkSupportedParamScript(pictureFormatArray, numpictureFormat, cmd);
542                if (a > -1) {
543                    params.setPictureFormat(cmd + 1);
544                } else {
545                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
546                }
547
548                if ( hardwareActive )
549                    camera->setParameters(params.flatten());
550
551                break;
552            case '-':
553                for(i = 0; i < length_audio_Codecs; i++)
554                {
555                    if( strcmp((cmd + 1), audioCodecs[i].desc) == 0)
556                    {
557                        audioCodecIDX = i;
558                        printf("Selected Audio: %s\n", audioCodecs[i].desc);
559                        break;
560                    }
561                }
562                break;
563
564            case 'A':
565                camera_index=atoi(cmd+1);
566                camera_index %= numCamera;
567
568                printf("%s selected.\n", cameras[camera_index]);
569                firstTime = true;
570
571                if ( hardwareActive ) {
572                    stopPreview();
573                    closeCamera();
574                    openCamera();
575                } else {
576                    closeCamera();
577                    openCamera();
578                }
579                break;
580
581            case 'a':
582                char * temp_str;
583
584                temp_str = strtok(cmd+1,"!");
585                printf("Latitude %s \n",temp_str);
586                params.set(params.KEY_GPS_LATITUDE, temp_str);
587                temp_str=strtok(NULL,"!");
588                printf("Longitude %s \n",temp_str);
589                params.set(params.KEY_GPS_LONGITUDE, temp_str);
590                temp_str=strtok(NULL,"!");
591                printf("Altitude %s \n",temp_str);
592                params.set(params.KEY_GPS_ALTITUDE, temp_str);
593
594                if ( hardwareActive )
595                    camera->setParameters(params.flatten());
596                break;
597
598            case 'l':
599                a = checkSupportedParamScriptResol(Vcapture_Array, numVcaptureSize, cmd, &resol_index);
600                if (a > -1) {
601                    VcaptureSizeIDX = resol_index;
602                } else {
603                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
604                }
605                break;
606
607            case 'L':
608                if(stereoMode)
609                {
610                    a = checkSupportedParamScriptLayout(stereoLayout, numLay, cmd, &stereoLayoutIDX);
611                    if (a > -1) {
612                        params.set(KEY_S3D_PRV_FRAME_LAYOUT, cmd + 1);
613                    } else {
614                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
615                    }
616
617
618                    getSizeParametersFromCapabilities();
619                    if (hardwareActive && previewRunning) {
620                        stopPreview();
621                        camera->setParameters(params.flatten());
622                        startPreview();
623                    } else if (hardwareActive) {
624                        camera->setParameters(params.flatten());
625                    }
626                }
627                break;
628
629
630            case '.':
631                if(stereoMode)
632                {
633                    a = checkSupportedParamScriptLayout(stereoCapLayout, numCLay, cmd, &stereoCapLayoutIDX);
634                    if (a > -1) {
635                        params.set(KEY_S3D_CAP_FRAME_LAYOUT_VALUES, cmd + 1);
636                    } else {
637                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
638                    }
639
640
641                    getSizeParametersFromCapabilities();
642                    if (hardwareActive && previewRunning) {
643                        stopPreview();
644                        camera->setParameters(params.flatten());
645                        startPreview();
646                    } else if (hardwareActive) {
647                        camera->setParameters(params.flatten());
648                    }
649                }
650                break;
651
652            case ']':
653                for(i = 0; i < length_V_bitRate; i++)
654                {
655                    if( strcmp((cmd + 1), VbitRate[i].desc) == 0)
656                    {
657                        VbitRateIDX = i;
658                        printf("Video Bit Rate: %s\n", VbitRate[i].desc);
659                        break;
660                    }
661                }
662                break;
663            case ':':
664
665                a = checkSupportedParamScriptResol(thumbnail_Array, numthumbnailSize, cmd, &resol_index);
666                if (a > -1) {
667                    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, thumbnail_Array[resol_index]->width);
668                    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,thumbnail_Array[resol_index]->height);
669                    thumbSizeIDX = resol_index;
670                } else {
671                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
672                }
673
674                if ( hardwareActive ) {
675                    camera->setParameters(params.flatten());
676                }
677
678
679                break;
680
681            case '\'':
682                thumbQuality = atoi(cmd + 1);
683
684                params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality);
685                if ( hardwareActive )
686                    camera->setParameters(params.flatten());
687                break;
688
689            case '*':
690                if ( hardwareActive )
691                    camera->startRecording();
692                break;
693
694            case 't':
695                params.setPreviewFormat((cmd + 1));
696                if ( hardwareActive )
697                    camera->setParameters(params.flatten());
698                break;
699
700            case 'o':
701                jpegQuality = atoi(cmd + 1);
702                params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
703
704                if ( hardwareActive )
705                    camera->setParameters(params.flatten());
706
707                break;
708
709
710            case '&':
711                printf("Enabling Preview Callback");
712                dump_preview = 1;
713                camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
714                break;
715
716
717            case 'k':
718                ippIDX_old = atoi(cmd + 1);
719                params.set(KEY_IPP, atoi(cmd + 1));
720                if ( hardwareActive )
721                    camera->setParameters(params.flatten());
722
723                break;
724
725            case 'K':
726                params.set(KEY_GBCE, (cmd+1));
727                if ( hardwareActive )
728                    camera->setParameters(params.flatten());
729
730                break;
731
732            case 'F':
733                if ( hardwareActive ) {
734                    camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0);
735                    faceDetectToggle = true;
736                }
737
738                break;
739
740            case 'I':
741                params.set(KEY_AF_TIMEOUT, (cmd + 1));
742
743                if ( hardwareActive )
744                    camera->setParameters(params.flatten());
745
746                break;
747
748            case 'T':
749
750                if ( hardwareActive ) {
751                    camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0);
752                    faceDetectToggle = false;
753                }
754
755                break;
756
757            case 'O':
758                params.set(KEY_GLBCE, (cmd+1));
759                if ( hardwareActive )
760                    camera->setParameters(params.flatten());
761
762                break;
763
764            case 'u':
765                // HQ should always be in ldc-nsf
766                // if not HQ, then return the ipp to its previous state
767                if ( !strcmp((cmd + 1), "high-quality") ) {
768                    ippIDX_old = ippIDX;
769                    ippIDX = 3;
770                    params.set(KEY_IPP, ipp_mode[ippIDX]);
771                    params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
772                    previewRotation = 0;
773                    params.set(KEY_SENSOR_ORIENTATION, previewRotation);
774                } else if ( !strcmp((cmd + 1), "video-mode") ) {
775                    params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);
776                    camera->getCameraInfo(camera_index, &cameraInfo);
777                    previewRotation = ((360-cameraInfo.orientation)%360);
778                    if (previewRotation >= 0 || previewRotation <=360) {
779                        params.set(KEY_SENSOR_ORIENTATION, previewRotation);
780                    }
781                    printf("previewRotation: %d\n", previewRotation);
782                } else {
783                    ippIDX = ippIDX_old;
784                    params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
785                    previewRotation = 0;
786                    params.set(KEY_SENSOR_ORIENTATION, previewRotation);
787                }
788                a = checkSupportedParamScript(modevalues, nummodevalues, cmd);
789                if (a > -1) {
790                    params.set(KEY_MODE, (cmd + 1));
791                } else {
792                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
793                }
794
795                if ( hardwareActive ) {
796                    if (previewRunning) {
797                        stopPreview();
798                    }
799                    camera->setParameters(params.flatten());
800                    // Get parameters from capabilities for the new capture mode
801                    params = camera->getParameters();
802                    getSizeParametersFromCapabilities();
803                    getParametersFromCapabilities();
804                    // Set framerate 30fps and 12MP capture resolution if available for the new capture mode.
805                    // If not available set framerate and capture mode under index 0 from fps_const_str and capture_Array.
806                    frameRateIDX = getDefaultParameter("30000,30000", constCnt, fps_const_str);
807                    captureSizeIDX = getDefaultParameterResol("12MP", numcaptureSize, capture_Array);
808                    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
809                    params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
810                    camera->setParameters(params.flatten());
811                }
812
813                break;
814
815            case 'U':
816
817                params.set(KEY_TEMP_BRACKETING, (cmd + 1));
818
819                if ( hardwareActive )
820                    camera->setParameters(params.flatten());
821
822                break;
823
824            case 'H':
825
826                setDefaultExpGainPreset(shotParams, atoi(cmd + 1));
827                break;
828
829
830            case 'n':
831
832            switch (*(cmd + 1)) {
833                case 0:
834                shotConfigFlush = false;
835                    break;
836                case 1:
837                shotConfigFlush = true;
838                    break;
839                default:
840                printf ("Mangling flush shot config command: \"%s\"\n", (cmd + 1));
841                    break;
842            }
843
844            updateShotConfigFlushParam();
845
846            break;
847
848            case '?':
849
850                setExpGainPreset(shotParams, cmd + 1, true, PARAM_EXP_BRACKET_PARAM_NONE, shotConfigFlush);
851
852                break;
853
854            case 'W':
855
856                tempBracketRange = atoi(cmd + 1);
857                tempBracketRange %= TEMP_BRACKETING_MAX_RANGE;
858                if ( 0 == tempBracketRange ) {
859                    tempBracketRange = 1;
860                }
861
862                params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange);
863                params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange);
864
865                if ( hardwareActive )
866                    camera->setParameters(params.flatten());
867
868            break;
869
870            case '#':
871
872                params.set(KEY_TI_BURST, atoi(cmd + 1));
873                burstCount = atoi(cmd + 1);
874
875                if ( hardwareActive )
876                    camera->setParameters(params.flatten());
877
878                break;
879
880            case 'J':
881
882                a = checkSupportedParamScript(flash, numflash, cmd);
883                if (a > -1) {
884                    params.set(CameraParameters::KEY_FLASH_MODE, (cmd + 1));
885                } else {
886                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
887                }
888
889                if ( hardwareActive )
890                    camera->setParameters(params.flatten());
891
892                break;
893
894            case 'w':
895
896                a = checkSupportedParamScript(scene, numscene, cmd);
897                if (a > -1) {
898                    params.set(params.KEY_SCENE_MODE, (cmd + 1));
899                } else {
900                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
901                }
902                if ( hardwareActive )
903                    camera->setParameters(params.flatten());
904
905                break;
906
907            case 'B' :
908                if(strcmp(vnfstr, "true") == 0) {
909                    if (strcmp(cmd + 1, "1") == 0) {
910                        trySetVideoNoiseFilter(true);
911                    }
912                    else if (strcmp(cmd + 1, "0") == 0){
913                        trySetVideoNoiseFilter(false);
914                    }
915                } else {
916                    trySetVideoNoiseFilter(false);
917                    printf("\n VNF is not supported \n\n");
918                }
919
920                if ( hardwareActive ) {
921                    camera->setParameters(params.flatten());
922                }
923                break;
924
925
926            case 'C' :
927
928                if (strcmp(vstabstr, "true") == 0) {
929                    if (strcmp(cmd + 1, "1") == 0) {
930                        trySetVideoStabilization(true);
931                    } else if (strcmp(cmd + 1, "0") == 0) {
932                        trySetVideoStabilization(false);
933                    } else {
934                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
935                    }
936                } else {
937                    printf("\nNot supported parameter vstab from sensor %d\n\n", camera_index);
938                }
939
940                if ( hardwareActive ) {
941                    camera->setParameters(params.flatten());
942                }
943                break;
944
945            case 'D':
946                if ( hardwareActive )
947                    camera->stopRecording();
948                break;
949
950            case 'E':
951                if(hardwareActive)
952                    params.unflatten(camera->getParameters());
953                printSupportedParams();
954                break;
955
956            case 'i':
957                iso_mode = atoi(cmd + 1);
958                if (iso_mode < numisoMode) {
959                    params.set(KEY_ISO, isoMode[iso_mode]);
960                } else {
961                    printf("\nNot supported parameter %s for iso mode from sensor %d\n\n", cmd + 1, camera_index);
962                }
963
964                if ( hardwareActive )
965                    camera->setParameters(params.flatten());
966
967                break;
968
969            case 'h':
970                sharpness = atoi(cmd + 1);
971                params.set(KEY_SHARPNESS, sharpness);
972
973                if ( hardwareActive )
974                    camera->setParameters(params.flatten());
975
976                break;
977
978            case '@':
979                if ( hardwareActive ) {
980
981                    closeCamera();
982
983                    if ( 0 >= openCamera() ) {
984                        printf( "Reconnected to CameraService \n");
985                    }
986                }
987
988                break;
989
990            case 'c':
991                contrast = atoi(cmd + 1);
992                params.set(KEY_CONTRAST, contrast);
993
994                if ( hardwareActive ) {
995                    camera->setParameters(params.flatten());
996                }
997
998                break;
999
1000            case 'z':
1001                zoomtoggle = false;
1002
1003                if(strcmp(zoomstr, "true") == 0) {
1004                    for(i = 0; i < length_Zoom; i++) {
1005                        if( strcmp((cmd + 1), zoom[i].zoom_description) == 0) {
1006                            zoomIDX = i;
1007                            zoomtoggle = true;
1008                            break;
1009                        }
1010                    }
1011
1012                    if (!zoomtoggle) {
1013                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1014                    }
1015
1016
1017                    params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
1018
1019                    if ( hardwareActive ) {
1020                        camera->setParameters(params.flatten());
1021                    }
1022                }
1023
1024            case 'Z':
1025                smoothzoomtoggle = false;
1026
1027                if(strcmp(smoothzoomstr, "true") == 0) {
1028                    for(i = 0; i < length_Zoom; i++) {
1029                        if( strcmp((cmd + 1), zoom[i].zoom_description) == 0) {
1030                            zoomIDX = i;
1031                            smoothzoomtoggle = true;
1032                            break;
1033                        }
1034                    }
1035
1036                    if (!smoothzoomtoggle) {
1037                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1038                    }
1039
1040                    if ( hardwareActive ) {
1041                        camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, zoom[zoomIDX].idx, 0);
1042                    }
1043                }
1044                break;
1045
1046            case 'j':
1047
1048                a = checkSupportedParamScript(exposureMode, numExposureMode, cmd);
1049                if (a > -1) {
1050                    params.set(KEY_EXPOSURE, (cmd + 1));
1051                } else {
1052                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1053                }
1054
1055                if ( hardwareActive )
1056                    camera->setParameters(params.flatten());
1057
1058                break;
1059
1060            case 'b':
1061                brightness = atoi(cmd + 1);
1062                params.set(KEY_BRIGHTNESS, brightness);
1063
1064                if ( hardwareActive )
1065                    camera->setParameters(params.flatten());
1066
1067                break;
1068
1069            case 's':
1070                saturation = atoi(cmd + 1);
1071                params.set(KEY_SATURATION, saturation);
1072
1073                if ( hardwareActive )
1074                    camera->setParameters(params.flatten());
1075
1076                break;
1077
1078            case 'e':
1079                a = checkSupportedParamScript(effectss, numEffects, cmd);
1080                if (a > -1) {
1081                    params.set(params.KEY_EFFECT, (cmd + 1));
1082                } else {
1083                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1084                }
1085
1086                if ( hardwareActive )
1087                    camera->setParameters(params.flatten());
1088
1089                break;
1090
1091            case 'r':
1092                if (strcmp((cmd + 1), "MAX_FRAMERATE") == 0) {
1093                    frameRConst = 0;
1094                    for (int i=0; i<constCnt; i++) {
1095                        if (constFramerate[frameRConst] < constFramerate[i]) {
1096                            frameRConst = i;
1097                        }
1098                    }
1099                    if (0 < constFramerate[frameRConst]) {
1100                        params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRConst]);
1101                        frameRateIDX = frameRConst;
1102                        printf("Framerate set: %d fps\n", constFramerate[frameRConst]);
1103                    } else {
1104                        printf("\nFramerate is 0!\n");
1105                    }
1106                } else {
1107                    a = checkSupportedParamScriptfpsConst(constFramerate, constCnt, cmd, &frameRConst);
1108                    if (a > -1) {
1109                        params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRConst]);
1110                        frameRateIDX = frameRConst;
1111                    } else {
1112                        printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1113                    }
1114                }
1115                if ( hardwareActive && previewRunning ) {
1116                    camera->stopPreview();
1117                    camera->setParameters(params.flatten());
1118                    camera->startPreview();
1119                } else if ( hardwareActive ) {
1120                    camera->setParameters(params.flatten());
1121                }
1122                break;
1123
1124            case 'R':
1125                a = checkSupportedParamScriptfpsRange(rangeDescription, rangeCnt, cmd, &frameRRange);
1126                if (a > -1) {
1127                    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_range_str[frameRRange]);
1128                    fpsRangeIdx = frameRRange;
1129                } else {
1130                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1131                }
1132                break;
1133
1134            case 'x':
1135                a = checkSupportedParamScript(antiband, numAntibanding, cmd);
1136                if (a > -1) {
1137                params.set(params.KEY_ANTIBANDING, (cmd + 1));
1138                } else {
1139                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1140                }
1141
1142                if ( hardwareActive )
1143                    camera->setParameters(params.flatten());
1144                break;
1145
1146            case 'g':
1147                a = checkSupportedParamScript(focus, numfocus, cmd);
1148                if (a > -1) {
1149                    params.set(params.KEY_FOCUS_MODE, (cmd + 1));
1150                } else {
1151                    printf("\nNot supported parameter %s from sensor %d\n\n", cmd + 1, camera_index);
1152                }
1153
1154                if ( hardwareActive )
1155                    camera->setParameters(params.flatten());
1156                break;
1157
1158            case 'G':
1159
1160                params.set(CameraParameters::KEY_FOCUS_AREAS, (cmd + 1));
1161
1162                if ( hardwareActive )
1163                    camera->setParameters(params.flatten());
1164
1165                break;
1166
1167            case 'y':
1168
1169                params.set(CameraParameters::KEY_METERING_AREAS, (cmd + 1));
1170
1171                if ( hardwareActive ) {
1172                    camera->setParameters(params.flatten());
1173                }
1174
1175                break;
1176
1177            case 'f':
1178                gettimeofday(&autofocus_start, 0);
1179
1180                if ( hardwareActive )
1181                    camera->autoFocus();
1182
1183                break;
1184
1185            case 'p':
1186            {
1187                 int msgType = 0;
1188                 const char *format = params.getPictureFormat();
1189
1190                if((NULL != format) && isRawPixelFormat(format)) {
1191                    createBufferOutputSource();
1192                    if (bufferSourceOutputThread.get()) {
1193                        bufferSourceOutputThread->setBuffer();
1194                    }
1195                } else if(strcmp(modevalues[capture_mode], "video-mode") == 0) {
1196                    msgType = CAMERA_MSG_COMPRESSED_IMAGE |
1197                              CAMERA_MSG_RAW_IMAGE;
1198#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
1199                    msgType |= CAMERA_MSG_RAW_BURST;
1200#endif
1201                } else {
1202                    msgType = CAMERA_MSG_POSTVIEW_FRAME |
1203                              CAMERA_MSG_RAW_IMAGE_NOTIFY |
1204                              CAMERA_MSG_COMPRESSED_IMAGE |
1205                              CAMERA_MSG_SHUTTER;
1206#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
1207                    msgType |= CAMERA_MSG_RAW_BURST;
1208#endif
1209                }
1210
1211                if((0 == strcmp(modevalues[capture_mode], "video-mode")) &&
1212                   (0 != strcmp(videosnapshotstr, "true"))) {
1213                    printf("Video Snapshot is not supported\n");
1214                } else {
1215                    gettimeofday(&picture_start, 0);
1216                    if ( hardwareActive ) {
1217                        ret = camera->setParameters(params.flatten());
1218                        if ( ret != NO_ERROR ) {
1219                            printf("Error returned while setting parameters");
1220                            break;
1221                        }
1222                        ret = camera->takePictureWithParameters(msgType, shotParams.flatten());
1223                        if ( ret != NO_ERROR ) {
1224                            printf("Error returned while taking a picture");
1225                            break;
1226                        }
1227                    }
1228                }
1229                break;
1230            }
1231
1232            case 'S':
1233            {
1234                createBufferOutputSource();
1235                if (bufferSourceOutputThread.get()) {
1236                    if (bufferSourceOutputThread->toggleStreamCapture(expBracketIdx)) {
1237                        expBracketIdx = BRACKETING_IDX_STREAM;
1238                        setSingleExpGainPreset(shotParams, expBracketIdx, 0, 0);
1239                        // Queue more frames initially
1240                        shotParams.set(ShotParameters::KEY_BURST, BRACKETING_STREAM_BUFFERS);
1241                    } else {
1242                        expBracketIdx = BRACKETING_IDX_DEFAULT;
1243                        setDefaultExpGainPreset(shotParams, expBracketIdx);
1244                    }
1245                }
1246                break;
1247            }
1248
1249            case 'P':
1250            {
1251                int msgType = CAMERA_MSG_COMPRESSED_IMAGE;
1252                gettimeofday(&picture_start, 0);
1253                if (!bufferSourceInput.get()) {
1254#ifdef ANDROID_API_JB_OR_LATER
1255                    bufferSourceInput = new BQ_BufferSourceInput(1234, camera);
1256#else
1257                    bufferSourceInput = new ST_BufferSourceInput(1234, camera);
1258#endif
1259                    bufferSourceInput->init();
1260                }
1261
1262                if (bufferSourceOutputThread.get() &&
1263                    bufferSourceOutputThread->hasBuffer())
1264                {
1265                    if (hardwareActive) camera->setParameters(params.flatten());
1266
1267                    if (bufferSourceInput.get()) {
1268                        buffer_info_t info = bufferSourceOutputThread->popBuffer();
1269                        bufferSourceInput->setInput(info, params.getPictureFormat());
1270                        if (hardwareActive) camera->reprocess(msgType, String8());
1271                    }
1272                }
1273                break;
1274            }
1275
1276            case 'd':
1277                dly = atoi(cmd + 1);
1278                sleep(dly);
1279                break;
1280
1281            case 'q':
1282                dump_mem_status();
1283                stopPreview();
1284
1285                if ( recordingMode ) {
1286                    stopRecording();
1287                    closeRecorder();
1288
1289                    recordingMode = false;
1290                }
1291                goto exit;
1292
1293            case '\n':
1294                printf("Iteration: %d \n", iteration);
1295                iteration++;
1296                break;
1297
1298            case '{':
1299                if ( atoi(cmd + 1) > 0 )
1300                    params.set(KEY_S3D2D_PREVIEW_MODE, "on");
1301                else
1302                    params.set(KEY_S3D2D_PREVIEW_MODE, "off");
1303                if ( hardwareActive )
1304                    camera->setParameters(params.flatten());
1305                break;
1306
1307            case 'M':
1308                params.set(KEY_MEASUREMENT, (cmd + 1));
1309                if ( hardwareActive )
1310                    camera->setParameters(params.flatten());
1311                break;
1312            case 'm':
1313            {
1314                params.set(KEY_METERING_MODE, (cmd + 1));
1315                if ( hardwareActive )
1316                {
1317                    camera->setParameters(params.flatten());
1318                }
1319                break;
1320            }
1321            case '<':
1322            {
1323                char coord_str[8];
1324                latitude += degree_by_step;
1325                if (latitude > 90.0)
1326                {
1327                    latitude -= 180.0;
1328                }
1329                snprintf(coord_str, 7, "%.7lf", latitude);
1330                params.set(params.KEY_GPS_LATITUDE, coord_str);
1331                if ( hardwareActive )
1332                {
1333                    camera->setParameters(params.flatten());
1334                }
1335                break;
1336            }
1337
1338            case '=':
1339            {
1340                char coord_str[8];
1341                longitude += degree_by_step;
1342                if (longitude > 180.0)
1343                {
1344                    longitude -= 360.0;
1345                }
1346                snprintf(coord_str, 7, "%.7lf", longitude);
1347                params.set(params.KEY_GPS_LONGITUDE, coord_str);
1348                if ( hardwareActive )
1349                {
1350                    camera->setParameters(params.flatten());
1351                }
1352                break;
1353            }
1354
1355            case '>':
1356            {
1357                char coord_str[8];
1358                altitude += 12345.67890123456789;
1359                if (altitude > 100000.0)
1360                {
1361                    altitude -= 200000.0;
1362                }
1363                snprintf(coord_str, 7, "%.7lf", altitude);
1364                params.set(params.KEY_GPS_ALTITUDE, coord_str);
1365                if ( hardwareActive )
1366                {
1367                    camera->setParameters(params.flatten());
1368                }
1369                break;
1370            }
1371
1372            case 'X':
1373            {
1374                char rem_str[384];
1375                printf("Deleting images from %s \n", images_dir_path);
1376                if (!sprintf(rem_str, "rm %s/*.jpg", images_dir_path)) {
1377                    printf("Sprintf Error");
1378                }
1379                if (system(rem_str)) {
1380                    printf("Images were not deleted\n");
1381                }
1382                break;
1383            }
1384
1385            case '_':
1386            {
1387                AutoConvergenceModeIDX = atoi(cmd + 1);
1388                if ( AutoConvergenceModeIDX < 0 || AutoConvergenceModeIDX > 4 )
1389                    AutoConvergenceModeIDX = 0;
1390                params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
1391                if (AutoConvergenceModeIDX != 4) {
1392                    params.set(KEY_MANUAL_CONVERGENCE, manualConv);
1393                }
1394                if (hardwareActive) {
1395                    camera->setParameters(params.flatten());
1396                }
1397                break;
1398            }
1399
1400            case '^':
1401                if (strcmp(autoconvergencemode[AutoConvergenceModeIDX], "manual") == 0) {
1402                    manC = atoi(cmd + 1);
1403                    if(manC >= manualConvMin  &&  manC <= manualConvMax)
1404                    {
1405                        params.set(KEY_MANUAL_CONVERGENCE, manC);
1406                    }
1407                    else if(manC < manualConvMin)
1408                    {
1409                        printf(" wrong parameter for manual convergence \n");
1410                        params.set(KEY_MANUAL_CONVERGENCE, manualConvMin);
1411                    }
1412                    else
1413                    {
1414                        printf(" wrong parameter for manual convergence \n");
1415                        params.set(KEY_MANUAL_CONVERGENCE, manualConvMax);
1416                    }
1417                    if ( hardwareActive )
1418                        camera->setParameters(params.flatten());
1419                }
1420                break;
1421
1422
1423            case 'Q':
1424                if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
1425                    manE = atoi(cmd + 1);
1426                    if(manE >= manualExpMin  &&  manE <= manualExpMax)
1427                    {
1428                        params.set(KEY_MANUAL_EXPOSURE, manE);
1429                        params.set(KEY_MANUAL_EXPOSURE_RIGHT, manE);
1430                    }
1431                    else if(manE < manualExpMin)
1432                    {
1433                        printf(" wrong parameter for manual exposure \n");
1434                        params.set(KEY_MANUAL_EXPOSURE, manualExpMin);
1435                        params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExpMin);
1436                    }
1437                    else
1438                    {
1439                        printf(" wrong parameter for manual exposure \n");
1440                        params.set(KEY_MANUAL_EXPOSURE, manualExpMax);
1441                        params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExpMax);
1442                    }
1443
1444                    if ( hardwareActive )
1445                    camera->setParameters(params.flatten());
1446                }
1447                break;
1448
1449            case ',':
1450                if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
1451                    manG = atoi(cmd + 1);
1452                    if(manG >= manualGainMin  &&  manG <= manualGainMax)
1453                    {
1454                        params.set(KEY_MANUAL_GAIN_ISO, manG);
1455                        params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manG);
1456                    }
1457                    else if(manG < manualGainMin)
1458                    {
1459                        printf(" wrong parameter for manual gain \n");
1460                        params.set(KEY_MANUAL_GAIN_ISO, manualGainMin);
1461                        params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGainMin);
1462                    }
1463                    else
1464                    {
1465                        printf(" wrong parameter for manual gain \n");
1466                        params.set(KEY_MANUAL_GAIN_ISO, manualGainMax);
1467                        params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGainMax);
1468                    }
1469
1470                    if ( hardwareActive )
1471                    camera->setParameters(params.flatten());
1472                }
1473                break;
1474
1475            default:
1476                printf("Unrecognized command!\n");
1477                break;
1478        }
1479
1480        cmd = strtok_r(NULL, DELIMITER, &ctx);
1481    }
1482
1483exit:
1484    if (stopScript == true)
1485      {
1486        return -1;
1487      }
1488    else
1489      {
1490        return 0;
1491      }
1492}
1493
1494
1495int checkSupportedParamScript(char **array, int size, char *param) {
1496    for (int i=0; i<size; i++) {
1497        if (strcmp((param + 1), array[i]) == 0) {
1498            return 0;
1499        }
1500    }
1501    return -1;
1502}
1503
1504int checkSupportedParamScriptLayout(char **array, int size, char *param, int *index) {
1505    for (int i=0; i<size; i++) {
1506        if (strcmp((param + 1), array[i]) == 0) {
1507            *index = i;
1508            return 0;
1509        }
1510    }
1511    return -1;
1512}
1513
1514int checkSupportedParamScriptResol(param_Array **array, int size, char *param, int *num) {
1515    for (int i=0; i<size; i++) {
1516        if (strcmp((param + 1), array[i]->name) == 0) {
1517            *num = i;
1518            return 0;
1519        }
1520    }
1521    return -1;
1522}
1523
1524int checkSupportedParamScriptResol(param_Array **array, int size,
1525                                   int width, int height, int *num) {
1526    for (int i=0; i<size; i++) {
1527        if ((width == array[i]->width) && (height == array[i]->height)) {
1528            *num = i;
1529            return 0;
1530        }
1531    }
1532    return -1;
1533}
1534
1535int checkSupportedParamScriptfpsConst(int *array, int size, char *param, int *num) {
1536    for (int i=0; i<size; i++) {
1537        if (atoi(param + 1) == array[i]) {
1538            *num = i;
1539            return 0;
1540        }
1541    }
1542    return -1;
1543}
1544
1545int checkSupportedParamScriptfpsRange(char **array, int size, char *param, int *num) {
1546    for (int i=0; i<size; i++) {
1547        if (strcmp(param + 1, array[i]) == 0) {
1548            *num = i;
1549            return 0;
1550        }
1551    }
1552    return -1;
1553}
1554
1555char * get_cycle_cmd(const char *aSrc) {
1556    unsigned ind = 0;
1557    char *cycle_cmd = new char[256];
1558
1559    while ((*aSrc != '+') && (*aSrc != '\0')) {
1560        cycle_cmd[ind++] = *aSrc++;
1561    }
1562    cycle_cmd[ind] = '\0';
1563
1564    return cycle_cmd;
1565}
1566
1567status_t dump_mem_status() {
1568  system(MEDIASERVER_DUMP);
1569  return system(MEMORY_DUMP);
1570}
1571
1572char *load_script(const char *config) {
1573    FILE *infile;
1574    size_t fileSize;
1575    char *script;
1576    size_t nRead = 0;
1577
1578    infile = fopen(config, "r");
1579
1580    strcpy(script_name,config);
1581
1582    printf("\n SCRIPT : <%s> is currently being executed \n", script_name);
1583
1584    printf("\n DIRECTORY CREATED FOR TEST RESULT IMAGES IN MMC CARD : %s \n", output_dir_path);
1585
1586    if( (NULL == infile)){
1587        printf("Error while opening script file %s!\n", config);
1588        return NULL;
1589    }
1590
1591    fseek(infile, 0, SEEK_END);
1592    fileSize = ftell(infile);
1593    fseek(infile, 0, SEEK_SET);
1594
1595    script = (char *) malloc(fileSize + 1);
1596
1597    if ( NULL == script ) {
1598        printf("Unable to allocate buffer for the script\n");
1599
1600        return NULL;
1601    }
1602
1603    memset(script, 0, fileSize + 1);
1604
1605    if ((nRead = fread(script, 1, fileSize, infile)) != fileSize) {
1606        printf("Error while reading script file!\n");
1607
1608        free(script);
1609        fclose(infile);
1610        return NULL;
1611    }
1612
1613    fclose(infile);
1614
1615    return script;
1616}
1617
1618int start_logging(int flags, int &pid) {
1619    int status = 0;
1620
1621    if (flags == 0) {
1622        pid = -1;
1623        return 0;
1624    }
1625
1626    pid = fork();
1627    if (pid == 0)
1628    {
1629        char *command_list[] = {"sh", "-c", NULL, NULL};
1630        char log_cmd[1024];
1631        // child process to run logging
1632
1633        // set group id of this process to itself
1634        // we will use this group id to kill the
1635        // application logging
1636        setpgid(getpid(), getpid());
1637
1638        /* Start logcat */
1639        if (flags & LOGGING_LOGCAT) {
1640            if (!sprintf(log_cmd,"logcat > %s/log.txt &", output_dir_path)) {
1641                printf(" Sprintf Error");
1642            }
1643        }
1644
1645        /* Start Syslink Trace */
1646        if (flags & LOGGING_SYSLINK) {
1647            if (!sprintf(log_cmd,"%s /system/bin/syslink_trace_daemon.out -l %s/syslink_trace.txt -f &", log_cmd, output_dir_path)) {
1648                printf(" Sprintf Error");
1649            }
1650        }
1651
1652        command_list[2] = (char *)log_cmd;
1653        execvp("/system/bin/sh", command_list);
1654    } if(pid < 0)
1655    {
1656        printf("failed to fork logcat\n");
1657        return -1;
1658    }
1659
1660    //wait for logging to start
1661    if(waitpid(pid, &status, 0) != pid)
1662    {
1663        printf("waitpid failed in log fork\n");
1664        return -1;
1665    }else
1666        printf("logging started... status=%d\n", status);
1667
1668    return 0;
1669}
1670
1671int stop_logging(int flags, int &pid)
1672{
1673    if (pid > 0) {
1674        if (killpg(pid, SIGKILL)) {
1675            printf("Exit command failed");
1676            return -1;
1677        } else {
1678            printf("\nlogging for script %s is complete\n", script_name);
1679
1680            if (flags & LOGGING_LOGCAT) {
1681                printf("   logcat saved @ location: %s\n", output_dir_path);
1682            }
1683
1684            if (flags & LOGGING_SYSLINK) {
1685                printf("   syslink_trace is saved @ location: %s\n\n", output_dir_path);
1686            }
1687        }
1688    }
1689    return 0;
1690}
1691
1692int execute_error_script(char *script) {
1693    char *cmd, *ctx;
1694    char id;
1695    status_t stat = NO_ERROR;
1696
1697    LOG_FUNCTION_NAME;
1698
1699    cmd = strtok_r((char *) script, DELIMITER, &ctx);
1700
1701    while ( NULL != cmd ) {
1702        id = cmd[0];
1703
1704        switch (id) {
1705
1706            case '0': {
1707                bufferStarvationTest = 1;
1708                params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation
1709
1710                if ( !recordingMode ) {
1711
1712                    recordingMode = true;
1713
1714                    if ( startPreview() < 0 ) {
1715                        printf("Error while starting preview\n");
1716
1717                        return -1;
1718                    }
1719
1720                    if ( openRecorder() < 0 ) {
1721                        printf("Error while openning video recorder\n");
1722
1723                        return -1;
1724                    }
1725
1726                    if ( configureRecorder() < 0 ) {
1727                        printf("Error while configuring video recorder\n");
1728
1729                        return -1;
1730                    }
1731
1732                    if ( startRecording() < 0 ) {
1733                        printf("Error while starting video recording\n");
1734
1735                        return -1;
1736                    }
1737
1738                }
1739
1740                usleep(1000000);//1s
1741
1742                stopPreview();
1743
1744                if ( recordingMode ) {
1745                    stopRecording();
1746                    closeRecorder();
1747
1748                    recordingMode = false;
1749                }
1750
1751                break;
1752            }
1753
1754            case '1': {
1755                int* tMemoryEater = new int[999999999];
1756
1757                if (!tMemoryEater) {
1758                    printf("Not enough memory\n");
1759                    return -1;
1760                } else {
1761                    delete tMemoryEater;
1762                }
1763
1764                break;
1765            }
1766
1767            case '2': {
1768                //camera = Camera::connect();
1769
1770                if ( NULL == camera.get() ) {
1771                    printf("Unable to connect to CameraService\n");
1772                    return -1;
1773                }
1774
1775                break;
1776            }
1777
1778            case '3': {
1779                int err = 0;
1780
1781                err = open("/dev/video5", O_RDWR);
1782
1783                if (err < 0) {
1784                    printf("Could not open the camera device5: %d\n",  err );
1785                    return err;
1786                }
1787
1788                if ( startPreview() < 0 ) {
1789                    printf("Error while starting preview\n");
1790                    return -1;
1791                }
1792
1793                usleep(1000000);//1s
1794
1795                stopPreview();
1796
1797                close(err);
1798                break;
1799            }
1800
1801            case '4': {
1802
1803                if ( hardwareActive ) {
1804
1805                    params.setPictureFormat("invalid-format");
1806                    params.setPreviewFormat("invalid-format");
1807
1808                    stat = camera->setParameters(params.flatten());
1809
1810                    if ( NO_ERROR != stat ) {
1811                        printf("Test passed!\n");
1812                    } else {
1813                        printf("Test failed!\n");
1814                    }
1815
1816                    initDefaults();
1817                }
1818
1819                break;
1820            }
1821
1822            case '5': {
1823
1824                if ( hardwareActive ) {
1825
1826                    params.setPictureSize(-1, -1);
1827                    params.setPreviewSize(-1, -1);
1828
1829                    stat = camera->setParameters(params.flatten());
1830
1831                    if ( NO_ERROR != stat ) {
1832                        printf("Test passed!\n");
1833                    } else {
1834                        printf("Test failed!\n");
1835                    }
1836
1837                    initDefaults();
1838                }
1839
1840                break;
1841            }
1842
1843            case '6': {
1844
1845                if ( hardwareActive ) {
1846
1847                    params.setPreviewFrameRate(-1);
1848
1849                    stat = camera->setParameters(params.flatten());
1850
1851                    if ( NO_ERROR != stat ) {
1852                        printf("Test passed!\n");
1853                    } else {
1854                        printf("Test failed!\n");
1855                    }
1856
1857                    initDefaults();
1858                }
1859
1860
1861                break;
1862            }
1863
1864            case 'q': {
1865                goto exit;
1866
1867                break;
1868            }
1869
1870            default: {
1871                printf("Unrecognized command!\n");
1872
1873                break;
1874            }
1875        }
1876
1877        cmd = strtok_r(NULL, DELIMITER, &ctx);
1878    }
1879
1880exit:
1881
1882    return 0;
1883}
1884
1885
1886
1887