camera_test_script.cpp revision ab9ef43721796d6ee4b35ab4614be0210a189fe4 
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
20#include <sys/wait.h>
21
22#include "camera_test.h"
23
24using namespace android;
25
26extern bool stopScript;
27extern bool hardwareActive;
28extern sp<Camera> camera;
29extern CameraParameters params;
30extern bool recordingMode;
31extern int camera_index;
32extern int rotation;
33extern const preview_size previewSize [];
34extern const Vcapture_size VcaptureSize [];
35extern const capture_Size captureSize[];
36extern const outformat outputFormat[];
37extern const video_Codecs videoCodecs[];
38extern const audio_Codecs audioCodecs[];
39extern const V_bitRate VbitRate[];
40extern const fps_ranges fpsRanges[];
41extern const fpsConst_Ranges fpsConstRanges[];
42extern const fpsConst_RangesSec fpsConstRangesSec[];
43extern const Zoom zoom [];
44extern int previewSizeIDX;
45extern bool reSizePreview;
46extern bool previewRunning;
47extern int captureSizeIDX;
48extern float compensation;
49extern int videoCodecIDX;
50extern int outputFormatIDX;
51extern int audioCodecIDX;
52extern int VcaptureSizeIDX;
53extern int VbitRateIDX;
54extern int thumbSizeIDX;
55extern int thumbQuality;
56extern int jpegQuality;
57extern int dump_preview;
58extern int ippIDX_old;
59extern const char *capture[];
60extern int capture_mode;
61extern int ippIDX;
62extern const char *ipp_mode[];
63extern int tempBracketRange;
64extern int iso_mode;
65extern int sharpness;
66extern int contrast;
67extern int zoomIDX;
68extern int brightness;
69extern int saturation;
70extern int fpsRangeIdx;
71extern timeval autofocus_start, picture_start;
72extern const char *cameras[];
73extern double latitude;
74extern double degree_by_step;
75extern double longitude;
76extern double altitude;
77extern char dir_path[80];
78extern int AutoConvergenceModeIDX;
79extern const char *autoconvergencemode[];
80extern const char *manualconvergencevalues[];
81extern const int ManualConvergenceDefaultValueIDX;
82extern size_t length_cam;
83extern char script_name[];
84extern int restartCount;
85extern bool bLogSysLinkTrace;
86extern int bufferStarvationTest;
87extern size_t length_previewSize;
88extern size_t lenght_Vcapture_size;
89extern size_t length_outformat;
90extern size_t length_capture_Size;
91extern size_t length_video_Codecs;
92extern size_t length_audio_Codecs;
93extern size_t length_V_bitRate;
94extern size_t length_Zoom;
95extern size_t length_fps_ranges;
96extern size_t length_fpsConst_Ranges;
97extern size_t length_fpsConst_RangesSec;
98
99
100int execute_functional_script(char *script) {
101    char *cmd, *ctx, *cycle_cmd, *temp_cmd;
102    char id;
103    unsigned int i;
104    int dly;
105    int cycleCounter = 1;
106    int tLen = 0;
107    unsigned int iteration = 0;
108    status_t ret = NO_ERROR;
109    int frameR = 20;
110    int frameRateIndex = 0;
111
112    LOG_FUNCTION_NAME;
113
114    dump_mem_status();
115
116    cmd = strtok_r((char *) script, DELIMITER, &ctx);
117
118    while ( NULL != cmd && (stopScript == false)) {
119        id = cmd[0];
120        printf("Full Command: %s \n", cmd);
121        printf("Command: %c \n", cmd[0]);
122
123        switch (id) {
124
125            // Case for Suspend-Resume Feature
126            case '!': {
127                // STEP 1: Mount Debugfs
128                system("mkdir /debug");
129                system("mount -t debugfs debugfs /debug");
130
131                // STEP 2: Set up wake up Timer - wake up happens after 5 seconds
132                system("echo 10 > /debug/pm_debug/wakeup_timer_seconds");
133
134                // STEP 3: Make system ready for Suspend
135                system("echo camerahal_test > /sys/power/wake_unlock");
136                // Release wake lock held by test app
137                printf(" Wake lock released ");
138                system("cat /sys/power/wake_lock");
139                system("sendevent /dev/input/event0 1 60 1");
140                system("sendevent /dev/input/event0 1 60 0");
141                // Simulate F2 key press to make display OFF
142                printf(" F2 event simulation complete ");
143
144                //STEP 4: Wait for system Resume and then simuate F1 key
145                sleep(50);//50s  // This delay is not related to suspend resume timer
146                printf(" After 30 seconds of sleep");
147                system("sendevent /dev/input/event0 1 59 0");
148                system("sendevent /dev/input/event0 1 59 1");
149                // Simulate F1 key press to make display ON
150                system("echo camerahal_test > /sys/power/wake_lock");
151                // Acquire wake lock for test app
152
153                break;
154            }
155
156            case '[':
157                if ( hardwareActive )
158                    {
159
160                    camera->setParameters(params.flatten());
161
162                    printf("starting camera preview..");
163                    status_t ret = camera->startPreview();
164                    if(ret !=NO_ERROR)
165                        {
166                        printf("startPreview failed %d..", ret);
167                        }
168                    }
169                break;
170            case '+': {
171                cycleCounter = atoi(cmd + 1);
172                cycle_cmd = get_cycle_cmd(ctx);
173                tLen = strlen(cycle_cmd);
174                temp_cmd = new char[tLen+1];
175
176                for (int ind = 0; ind < cycleCounter; ind++) {
177                    strcpy(temp_cmd, cycle_cmd);
178                    if ( execute_functional_script(temp_cmd) != 0 )
179                      return -1;
180                    temp_cmd[0] = '\0';
181
182                    //patch for image capture
183                    //[
184                    if (ind < cycleCounter - 1) {
185                        if (hardwareActive == false) {
186                            if ( openCamera() < 0 ) {
187                                printf("Camera initialization failed\n");
188
189                                return -1;
190                            }
191
192                            initDefaults();
193                        }
194                    }
195
196                    //]
197                }
198
199                ctx += tLen + 1;
200
201                if (temp_cmd) {
202                    delete temp_cmd;
203                    temp_cmd = NULL;
204                }
205
206                if (cycle_cmd) {
207                    delete cycle_cmd;
208                    cycle_cmd = NULL;
209                }
210
211                break;
212            }
213
214            case '0':
215            {
216                initDefaults();
217                break;
218            }
219
220            case '1':
221
222                if ( startPreview() < 0 ) {
223                    printf("Error while starting preview\n");
224
225                    return -1;
226                }
227
228                break;
229
230            case '2':
231                stopPreview();
232
233                if ( recordingMode ) {
234
235                    camera->disconnect();
236                    camera.clear();
237                    stopRecording();
238                    closeRecorder();
239
240                    camera = Camera::connect(camera_index, false, false);
241                      if ( NULL == camera.get() ) {
242                          sleep(1);
243                          camera = Camera::connect(camera_index, false, false);
244
245                          if ( NULL == camera.get() ) {
246                              return -1;
247                          }
248                      }
249                      camera->setListener(new CameraHandler());
250                      camera->setParameters(params.flatten());
251
252                      recordingMode = false;
253                }
254
255                break;
256
257            case '3':
258                rotation = atoi(cmd + 1);
259                params.set(CameraParameters::KEY_ROTATION, rotation);
260
261                if ( hardwareActive )
262                    camera->setParameters(params.flatten());
263
264                break;
265
266            case '4':
267            {
268                printf("Setting resolution...");
269                int width, height;
270                for(i = 0; i < length_previewSize ; i++)
271                {
272                    if( strcmp((cmd + 1), previewSize[i].desc) == 0)
273                    {
274                        width = previewSize[i].width;
275                        height = previewSize[i].height;
276                        previewSizeIDX = i;
277                        break;
278                    }
279                }
280
281                if (i == length_previewSize )   //if the resolution is not in the supported ones
282                {
283                    char *res = NULL;
284                    res = strtok(cmd + 1, "x");
285                    width = atoi(res);
286                    res = strtok(NULL, "x");
287                    height = atoi(res);
288                }
289
290                if ( NULL != params.get(KEY_STEREO_CAMERA) ) {
291                    if ( strcmp(params.get(KEY_STEREO_CAMERA), "true") == 0 ) {
292                        height *=2;
293                    }
294                }
295
296                printf("Resolution: %d x %d\n", width, height);
297                params.setPreviewSize(width, height);
298                reSizePreview = true;
299
300                if ( hardwareActive && previewRunning ) {
301                    camera->stopPreview();
302                    camera->setParameters(params.flatten());
303                    camera->startPreview();
304                } else if ( hardwareActive ) {
305                    camera->setParameters(params.flatten());
306                }
307
308                break;
309            }
310            case '5':
311
312                for (i = 0; i < length_capture_Size; i++) {
313                    if ( strcmp((cmd + 1), captureSize[i].name) == 0)
314                        break;
315                }
316
317                if (  i < length_capture_Size ) {
318                    params.setPictureSize(captureSize[i].width, captureSize[i].height);
319                    captureSizeIDX = i;
320                }
321
322                if ( hardwareActive )
323                    camera->setParameters(params.flatten());
324
325                break;
326
327            case '6':
328
329                if ( !recordingMode ) {
330
331                    recordingMode = true;
332
333                    if ( startPreview() < 0 ) {
334                        printf("Error while starting preview\n");
335
336                        return -1;
337                    }
338
339                    if ( openRecorder() < 0 ) {
340                        printf("Error while openning video recorder\n");
341
342                        return -1;
343                    }
344
345                    if ( configureRecorder() < 0 ) {
346                        printf("Error while configuring video recorder\n");
347
348                        return -1;
349                    }
350
351                    if ( startRecording() < 0 ) {
352                        printf("Error while starting video recording\n");
353
354                        return -1;
355                    }
356
357                }
358
359                break;
360
361            case '7':
362                compensation = atof(cmd + 1);
363                params.set(KEY_COMPENSATION, (int) (compensation * 10));
364
365                if ( hardwareActive )
366                    camera->setParameters(params.flatten());
367
368                break;
369
370            case '8':
371                params.set(params.KEY_WHITE_BALANCE, (cmd + 1));
372
373                if ( hardwareActive )
374                    camera->setParameters(params.flatten());
375
376                break;
377
378            case '9':
379                for(i = 0; i < length_video_Codecs; i++)
380                {
381                    if( strcmp((cmd + 1), videoCodecs[i].desc) == 0)
382                    {
383                        videoCodecIDX = i;
384                        printf("Video Codec Selected: %s\n",
385                                videoCodecs[i].desc);
386                        break;
387                    }
388                }
389                break;
390
391            case 'v':
392                for(i = 0; i < length_outformat; i++)
393
394                {
395                    if( strcmp((cmd + 1), outputFormat[i].desc) == 0)
396                    {
397                        outputFormatIDX = i;
398                        printf("Video Codec Selected: %s\n",
399                                videoCodecs[i].desc);
400                        break;
401                    }
402                }
403            break;
404
405            case '~':
406                params.setPreviewFormat(cmd + 1);
407                if ( hardwareActive )
408                    camera->setParameters(params.flatten());
409
410                break;
411
412            case '$':
413                params.setPictureFormat(cmd + 1);
414                if ( hardwareActive )
415                    camera->setParameters(params.flatten());
416
417                break;
418            case '-':
419                for(i = 0; i < length_audio_Codecs; i++)
420                {
421                    if( strcmp((cmd + 1), audioCodecs[i].desc) == 0)
422                    {
423                        audioCodecIDX = i;
424                        printf("Selected Audio: %s\n", audioCodecs[i].desc);
425                        break;
426                    }
427                }
428                break;
429
430            case 'A':
431                camera_index=atoi(cmd+1);
432           //     camera_index %= ARRAY_SIZE(cameras);
433                camera_index %= length_cam;
434                if ( camera_index == 2)
435                    params.set(KEY_STEREO_CAMERA, "true");
436                else
437                    params.set(KEY_STEREO_CAMERA, "false");
438
439                printf("%s selected.\n", cameras[camera_index]);
440
441                if ( hardwareActive ) {
442                    stopPreview();
443                    closeCamera();
444                    openCamera();
445                } else {
446                    closeCamera();
447                    openCamera();
448                }
449
450                if (camera_index == 0) params.setPreviewFrameRate(30);
451                  else params.setPreviewFrameRate(27);
452
453
454                break;
455
456            case 'a':
457                char * temp_str;
458
459                temp_str = strtok(cmd+1,"!");
460                printf("Latitude %s \n",temp_str);
461                params.set(params.KEY_GPS_LATITUDE, temp_str);
462                temp_str=strtok(NULL,"!");
463                printf("Longitude %s \n",temp_str);
464                params.set(params.KEY_GPS_LONGITUDE, temp_str);
465                temp_str=strtok(NULL,"!");
466                printf("Altitude %s \n",temp_str);
467                params.set(params.KEY_GPS_ALTITUDE, temp_str);
468
469                if ( hardwareActive )
470                    camera->setParameters(params.flatten());
471                break;
472
473            case 'l':
474            case 'L':
475                for(i = 0; i < lenght_Vcapture_size; i++)
476                {
477                    if( strcmp((cmd + 1), VcaptureSize[i].desc) == 0)
478                    {
479                        VcaptureSizeIDX = i;
480                        printf("Video Capture Size: %s\n", VcaptureSize[i].desc);
481                        break;
482                    }
483                }
484                break;
485            case ']':
486                for(i = 0; i < length_V_bitRate; i++)
487                {
488                    if( strcmp((cmd + 1), VbitRate[i].desc) == 0)
489                    {
490                        VbitRateIDX = i;
491                        printf("Video Bit Rate: %s\n", VbitRate[i].desc);
492                        break;
493                    }
494                }
495                break;
496            case ':':
497                int width, height;
498                for(i = 0; i < length_previewSize ; i++)
499                {
500                    if( strcmp((cmd + 1), previewSize[i].desc) == 0)
501                    {
502                        width = previewSize[i].width;
503                        height = previewSize[i].height;
504                        thumbSizeIDX = i;
505                        break;
506                    }
507                }
508
509                if (i == length_previewSize )   //if the resolution is not in the supported ones
510                {
511                    char *res = NULL;
512                    res = strtok(cmd + 1, "x");
513                    width = atoi(res);
514                    res = strtok(NULL, "x");
515                    height = atoi(res);
516                }
517
518                params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
519                params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
520
521                if ( hardwareActive )
522                    camera->setParameters(params.flatten());
523
524                break;
525
526            case '\'':
527                thumbQuality = atoi(cmd + 1);
528
529                params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality);
530                if ( hardwareActive )
531                    camera->setParameters(params.flatten());
532                break;
533
534            case '*':
535                if ( hardwareActive )
536                    camera->startRecording();
537                break;
538
539            case 't':
540                params.setPreviewFormat((cmd + 1));
541                if ( hardwareActive )
542                    camera->setParameters(params.flatten());
543                break;
544
545            case 'o':
546                jpegQuality = atoi(cmd + 1);
547                params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
548
549                if ( hardwareActive )
550                    camera->setParameters(params.flatten());
551
552                break;
553
554
555            case '&':
556                printf("Enabling Preview Callback");
557                dump_preview = 1;
558                camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
559                break;
560
561
562            case 'k':
563                ippIDX_old = atoi(cmd + 1);
564                params.set(KEY_IPP, atoi(cmd + 1));
565                if ( hardwareActive )
566                    camera->setParameters(params.flatten());
567
568                break;
569
570            case 'K':
571                params.set(KEY_GBCE, (cmd+1));
572                if ( hardwareActive )
573                    camera->setParameters(params.flatten());
574
575                break;
576
577            case 'F':
578                if ( hardwareActive )
579                    camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0);
580
581                break;
582
583            case 'T':
584
585                if ( hardwareActive )
586                    camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0);
587
588            case 'O':
589                params.set(KEY_GLBCE, (cmd+1));
590                if ( hardwareActive )
591                    camera->setParameters(params.flatten());
592
593                break;
594
595            case 'u':
596                // HQ should always be in ldc-nsf
597                // if not HQ, then return the ipp to its previous state
598                if( !strcmp(capture[capture_mode], "high-quality") ) {
599                    ippIDX_old = ippIDX;
600                    ippIDX = 3;
601                    params.set(KEY_IPP, ipp_mode[ippIDX]);
602                } else {
603                    ippIDX = ippIDX_old;
604                }
605
606                params.set(KEY_MODE, (cmd + 1));
607                if ( hardwareActive )
608                    camera->setParameters(params.flatten());
609
610                break;
611
612            case 'U':
613
614                params.set(KEY_TEMP_BRACKETING, (cmd + 1));
615
616                if ( hardwareActive )
617                    camera->setParameters(params.flatten());
618
619                break;
620
621            case 'W':
622
623                tempBracketRange = atoi(cmd + 1);
624                tempBracketRange %= TEMP_BRACKETING_MAX_RANGE;
625                if ( 0 == tempBracketRange ) {
626                    tempBracketRange = 1;
627                }
628
629                params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange);
630                params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange);
631
632                if ( hardwareActive )
633                    camera->setParameters(params.flatten());
634
635            break;
636
637            case '#':
638
639                params.set(KEY_BURST, atoi(cmd + 1));
640
641                if ( hardwareActive )
642                    camera->setParameters(params.flatten());
643
644                break;
645
646            case 'J':
647                params.set(CameraParameters::KEY_FLASH_MODE, (cmd+1));
648
649                if ( hardwareActive )
650                    camera->setParameters(params.flatten());
651
652                break;
653
654            case 'w':
655                params.set(params.KEY_SCENE_MODE, (cmd + 1));
656
657                if ( hardwareActive )
658                    camera->setParameters(params.flatten());
659
660                break;
661
662            case 'B' :
663                params.set(KEY_VNF, (cmd + 1));
664
665                if ( hardwareActive )
666                    camera->setParameters(params.flatten());
667
668
669            case 'C' :
670                params.set(KEY_VSTAB, (cmd + 1));
671
672                if ( hardwareActive )
673                    camera->setParameters(params.flatten());
674                break;
675
676            case 'D':
677                if ( hardwareActive )
678                    camera->stopRecording();
679                break;
680
681            case 'E':
682                if(hardwareActive)
683                    params.unflatten(camera->getParameters());
684                printSupportedParams();
685                break;
686
687            case 'i':
688                iso_mode = atoi(cmd + 1);
689                params.set(KEY_ISO, iso_mode);
690
691                if ( hardwareActive )
692                    camera->setParameters(params.flatten());
693
694                break;
695
696            case 'h':
697                sharpness = atoi(cmd + 1);
698                params.set(KEY_SHARPNESS, sharpness);
699
700                if ( hardwareActive )
701                    camera->setParameters(params.flatten());
702
703                break;
704
705            case '@':
706                if ( hardwareActive ) {
707
708                    closeCamera();
709
710                    if ( 0 >= openCamera() ) {
711                        printf( "Reconnected to CameraService \n");
712                    }
713                }
714
715                break;
716
717            case 'c':
718                contrast = atoi(cmd + 1);
719                params.set(KEY_CONTRAST, contrast);
720
721                if ( hardwareActive ) {
722                    camera->setParameters(params.flatten());
723                }
724
725                break;
726
727            case 'z':
728            case 'Z':
729
730#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
731                params.set(CameraParameters::KEY_ZOOM, atoi(cmd + 1));
732#else
733
734                for(i = 0; i < length_Zoom; i++)
735                {
736                    if( strcmp((cmd + 1), zoom[i].zoom_description) == 0)
737                    {
738                        zoomIDX = i;
739                        break;
740                    }
741                }
742
743                params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
744#endif
745
746                if ( hardwareActive )
747                    camera->setParameters(params.flatten());
748
749                break;
750
751            case 'j':
752                params.set(KEY_EXPOSURE, (cmd + 1));
753
754                if ( hardwareActive )
755                    camera->setParameters(params.flatten());
756
757                break;
758
759            case 'b':
760                brightness = atoi(cmd + 1);
761                params.set(KEY_BRIGHTNESS, brightness);
762
763                if ( hardwareActive )
764                    camera->setParameters(params.flatten());
765
766                break;
767
768            case 's':
769                saturation = atoi(cmd + 1);
770                params.set(KEY_SATURATION, saturation);
771
772                if ( hardwareActive )
773                    camera->setParameters(params.flatten());
774
775                break;
776
777            case 'e':
778                params.set(params.KEY_EFFECT, (cmd + 1));
779
780                if ( hardwareActive )
781                    camera->setParameters(params.flatten());
782
783                break;
784
785            case 'r':
786
787                frameR = atoi(cmd + 1);
788
789
790                if (camera_index == 0) {
791                    for (i = 0; i < length_fpsConst_Ranges; i++) {
792                        if (frameR == fpsConstRanges[i].constFramerate)
793                            frameRateIndex = i;
794
795                    }
796                } else {
797                    for (i = 0; i < length_fpsConst_RangesSec; i++) {
798                        if (frameR == fpsConstRangesSec[i].constFramerate)
799                            frameRateIndex = i;
800                    }
801                }
802
803
804                if (camera_index == 0)
805                    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRanges[frameRateIndex].range);
806                else
807                    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRangesSec[frameRateIndex].range);
808
809
810                if ( hardwareActive && previewRunning ) {
811                    camera->stopPreview();
812                    camera->setParameters(params.flatten());
813                    camera->startPreview();
814                } else if ( hardwareActive ) {
815                    camera->setParameters(params.flatten());
816                }
817
818                break;
819
820            case 'R':
821                for(i = 0; i < length_fps_ranges; i++)
822                {
823                    if( strcmp((cmd + 1), fpsRanges[i].rangeDescription) == 0)
824                    {
825                        fpsRangeIdx = i;
826                        printf("Selected Framerate range: %s\n", fpsRanges[i].rangeDescription);
827                        if ( hardwareActive ) {
828                            params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsRanges[i].range);
829                            params.remove(CameraParameters::KEY_PREVIEW_FRAME_RATE);
830                            camera->setParameters(params.flatten());
831                        }
832                        break;
833                    }
834                }
835                break;
836
837            case 'x':
838                params.set(params.KEY_ANTIBANDING, (cmd + 1));
839
840                if ( hardwareActive )
841                    camera->setParameters(params.flatten());
842
843                break;
844
845            case 'g':
846                params.set(params.KEY_FOCUS_MODE, (cmd + 1));
847
848                if ( hardwareActive )
849                    camera->setParameters(params.flatten());
850
851                break;
852
853            case 'G':
854
855                params.set(CameraParameters::KEY_FOCUS_AREAS, (cmd + 1));
856
857                if ( hardwareActive )
858                    camera->setParameters(params.flatten());
859
860                params.remove(CameraParameters::KEY_FOCUS_AREAS);
861
862            case 'f':
863                gettimeofday(&autofocus_start, 0);
864
865                if ( hardwareActive )
866                    camera->autoFocus();
867
868                break;
869
870            case 'p':
871                gettimeofday(&picture_start, 0);
872
873                if ( hardwareActive )
874                    ret = camera->takePicture(CAMERA_MSG_COMPRESSED_IMAGE|CAMERA_MSG_RAW_IMAGE);
875
876                if ( ret != NO_ERROR )
877                    printf("Error returned while taking a picture");
878                break;
879
880            case 'd':
881                dly = atoi(cmd + 1);
882                sleep(dly);
883                break;
884
885            case 'q':
886                dump_mem_status();
887                stopPreview();
888
889                if ( recordingMode ) {
890                    stopRecording();
891                    closeRecorder();
892
893                    recordingMode = false;
894                }
895                goto exit;
896
897            case '\n':
898                printf("Iteration: %d \n", iteration);
899                iteration++;
900                break;
901
902            case '{':
903                if ( atoi(cmd + 1) > 0 )
904                    params.set(KEY_S3D2D_PREVIEW_MODE, "on");
905                else
906                    params.set(KEY_S3D2D_PREVIEW_MODE, "off");
907                if ( hardwareActive )
908                    camera->setParameters(params.flatten());
909                break;
910
911            case 'M':
912                params.set(KEY_MEASUREMENT, (cmd + 1));
913                if ( hardwareActive )
914                    camera->setParameters(params.flatten());
915                break;
916            case 'm':
917            {
918                params.set(KEY_METERING_MODE, (cmd + 1));
919                if ( hardwareActive )
920                {
921                    camera->setParameters(params.flatten());
922                }
923                break;
924            }
925            case '<':
926            {
927                char coord_str[8];
928                latitude += degree_by_step;
929                if (latitude > 90.0)
930                {
931                    latitude -= 180.0;
932                }
933                snprintf(coord_str, 7, "%.7lf", latitude);
934                params.set(params.KEY_GPS_LATITUDE, coord_str);
935                if ( hardwareActive )
936                {
937                    camera->setParameters(params.flatten());
938                }
939                break;
940            }
941
942            case '=':
943            {
944                char coord_str[8];
945                longitude += degree_by_step;
946                if (longitude > 180.0)
947                {
948                    longitude -= 360.0;
949                }
950                snprintf(coord_str, 7, "%.7lf", longitude);
951                params.set(params.KEY_GPS_LONGITUDE, coord_str);
952                if ( hardwareActive )
953                {
954                    camera->setParameters(params.flatten());
955                }
956                break;
957            }
958
959            case '>':
960            {
961                char coord_str[8];
962                altitude += 12345.67890123456789;
963                if (altitude > 100000.0)
964                {
965                    altitude -= 200000.0;
966                }
967                snprintf(coord_str, 7, "%.7lf", altitude);
968                params.set(params.KEY_GPS_ALTITUDE, coord_str);
969                if ( hardwareActive )
970                {
971                    camera->setParameters(params.flatten());
972                }
973                break;
974            }
975
976            case 'X':
977            {
978                char rem_str[50];
979                printf("Deleting images from %s \n", dir_path);
980                if(!sprintf(rem_str,"rm %s/*.jpg",dir_path))
981                    printf("Sprintf Error");
982                if(system(rem_str))
983                    printf("Images were not deleted\n");
984                break;
985            }
986
987            case '_':
988            {
989                AutoConvergenceModeIDX = atoi(cmd + 1);
990                if ( AutoConvergenceModeIDX < 0 || AutoConvergenceModeIDX > 4 )
991                    AutoConvergenceModeIDX = 0;
992                params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
993                if ( AutoConvergenceModeIDX != 4 )
994                    params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceDefaultValueIDX]);
995                if ( hardwareActive )
996                    camera->setParameters(params.flatten());
997                break;
998            }
999
1000            case '^':
1001            {
1002                char strtmpval[7];
1003                if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) {
1004                    sprintf(strtmpval,"%d", atoi(cmd + 1));
1005                    params.set(KEY_MANUALCONVERGENCE_VALUES, strtmpval);
1006                    if ( hardwareActive )
1007                        camera->setParameters(params.flatten());
1008                }
1009                break;
1010            }
1011
1012            default:
1013                printf("Unrecognized command!\n");
1014                break;
1015        }
1016
1017        cmd = strtok_r(NULL, DELIMITER, &ctx);
1018    }
1019
1020exit:
1021    if (stopScript == true)
1022      {
1023        return -1;
1024      }
1025    else
1026      {
1027        return 0;
1028      }
1029}
1030
1031
1032char * get_cycle_cmd(const char *aSrc) {
1033    unsigned ind = 0;
1034    char *cycle_cmd = new char[256];
1035
1036    while ((*aSrc != '+') && (*aSrc != '\0')) {
1037        cycle_cmd[ind++] = *aSrc++;
1038    }
1039    cycle_cmd[ind] = '\0';
1040
1041    return cycle_cmd;
1042}
1043
1044status_t dump_mem_status() {
1045  system(MEDIASERVER_DUMP);
1046  return system(MEMORY_DUMP);
1047}
1048
1049char *load_script(char *config) {
1050    FILE *infile;
1051    size_t fileSize;
1052    char *script;
1053    size_t nRead = 0;
1054    char dir_name[40];
1055    size_t count;
1056    char rCount [5];
1057
1058    count = 0;
1059
1060    infile = fopen(config, "r");
1061
1062    strcpy(script_name,config);
1063
1064    // remove just the '.txt' part of the config
1065    while((config[count] != '.') && (count < sizeof(dir_name)/sizeof(dir_name[0])))
1066        count++;
1067
1068    printf("\n SCRIPT : <%s> is currently being executed \n",script_name);
1069    if(strncpy(dir_name,config,count) == NULL)
1070        printf("Strcpy error");
1071
1072    dir_name[count]=NULL;
1073
1074    if(strcat(dir_path,dir_name) == NULL)
1075        printf("Strcat error");
1076
1077    if(restartCount)
1078    {
1079      sprintf(rCount,"_%d",restartCount);
1080      if(strcat(dir_path, rCount) == NULL)
1081        printf("Strcat error RestartCount");
1082    }
1083
1084    printf("\n COMPLETE FOLDER PATH : %s \n",dir_path);
1085    if(mkdir(dir_path,0777) == -1) {
1086        printf("\n Directory %s was not created \n",dir_path);
1087    } else {
1088        printf("\n Directory %s was created \n",dir_path);
1089    }
1090    printf("\n DIRECTORY CREATED FOR TEST RESULT IMAGES IN MMC CARD : %s \n",dir_name);
1091
1092    if( (NULL == infile)){
1093        printf("Error while opening script file %s!\n", config);
1094        return NULL;
1095    }
1096
1097    fseek(infile, 0, SEEK_END);
1098    fileSize = ftell(infile);
1099    fseek(infile, 0, SEEK_SET);
1100
1101    script = (char *) malloc(fileSize);
1102
1103    if ( NULL == script ) {
1104        printf("Unable to allocate buffer for the script\n");
1105
1106        return NULL;
1107    }
1108
1109    if ((nRead = fread(script, 1, fileSize, infile)) != fileSize) {
1110        printf("Error while reading script file!\n");
1111
1112        free(script);
1113        fclose(infile);
1114        return NULL;
1115    }
1116
1117    fclose(infile);
1118
1119    return script;
1120}
1121
1122int start_logging(char *config, int &pid) {
1123    char dir_name[40];
1124    size_t count = 0;
1125    int status = 0;
1126
1127    // remove just the '.txt' part of the config
1128    while((config[count] != '.') && (count < sizeof(dir_name)/sizeof(dir_name[0])))
1129        count++;
1130
1131    if(strncpy(dir_name,config,count) == NULL)
1132        printf("Strcpy error");
1133
1134    dir_name[count]=NULL;
1135
1136    pid = fork();
1137    if (pid == 0)
1138    {
1139        char *command_list[] = {"sh", "-c", NULL, NULL};
1140        char log_cmd[120];
1141        // child process to run logging
1142
1143        // set group id of this process to itself
1144        // we will use this group id to kill the
1145        // application logging
1146        setpgid(getpid(), getpid());
1147
1148        /* Start logcat */
1149        if(!sprintf(log_cmd,"logcat > /sdcard/%s/log.txt &",dir_name))
1150            printf(" Sprintf Error");
1151
1152        /* Start Syslink Trace */
1153        if(bLogSysLinkTrace) {
1154            if(!sprintf(log_cmd,"%s /system/bin/syslink_trace_daemon.out -l /sdcard/%s/syslink_trace.txt -f &",log_cmd, dir_name))
1155                printf(" Sprintf Error");
1156        }
1157
1158        command_list[2] = (char *)log_cmd;
1159        execvp("/system/bin/sh", command_list);
1160    } if(pid < 0)
1161    {
1162        printf("failed to fork logcat\n");
1163        return -1;
1164    }
1165
1166    //wait for logging to start
1167    if(waitpid(pid, &status, 0) != pid)
1168    {
1169        printf("waitpid failed in log fork\n");
1170        return -1;
1171    }else
1172        printf("logging started... status=%d\n", status);
1173
1174    return 0;
1175}
1176
1177int stop_logging(int &pid)
1178{
1179    if(pid > 0)
1180    {
1181        if(killpg(pid, SIGKILL))
1182        {
1183            printf("Exit command failed");
1184            return -1;
1185        } else {
1186            printf("\nlogging for script %s is complete\n   logcat saved @ location: %s\n",script_name,dir_path);
1187            if (bLogSysLinkTrace)
1188                printf("   syslink_trace is saved @ location: %s\n\n",dir_path);
1189        }
1190    }
1191    return 0;
1192}
1193
1194int execute_error_script(char *script) {
1195    char *cmd, *ctx;
1196    char id;
1197    status_t stat = NO_ERROR;
1198
1199    LOG_FUNCTION_NAME;
1200
1201    cmd = strtok_r((char *) script, DELIMITER, &ctx);
1202
1203    while ( NULL != cmd ) {
1204        id = cmd[0];
1205
1206        switch (id) {
1207
1208            case '0': {
1209                bufferStarvationTest = 1;
1210                params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation
1211
1212                if ( !recordingMode ) {
1213
1214                    recordingMode = true;
1215
1216                    if ( startPreview() < 0 ) {
1217                        printf("Error while starting preview\n");
1218
1219                        return -1;
1220                    }
1221
1222                    if ( openRecorder() < 0 ) {
1223                        printf("Error while openning video recorder\n");
1224
1225                        return -1;
1226                    }
1227
1228                    if ( configureRecorder() < 0 ) {
1229                        printf("Error while configuring video recorder\n");
1230
1231                        return -1;
1232                    }
1233
1234                    if ( startRecording() < 0 ) {
1235                        printf("Error while starting video recording\n");
1236
1237                        return -1;
1238                    }
1239
1240                }
1241
1242                usleep(1000000);//1s
1243
1244                stopPreview();
1245
1246                if ( recordingMode ) {
1247                    stopRecording();
1248                    closeRecorder();
1249
1250                    recordingMode = false;
1251                }
1252
1253                break;
1254            }
1255
1256            case '1': {
1257                int* tMemoryEater = new int[999999999];
1258
1259                if (!tMemoryEater) {
1260                    printf("Not enough memory\n");
1261                    return -1;
1262                } else {
1263                    delete tMemoryEater;
1264                }
1265
1266                break;
1267            }
1268
1269            case '2': {
1270                //camera = Camera::connect();
1271
1272                if ( NULL == camera.get() ) {
1273                    printf("Unable to connect to CameraService\n");
1274                    return -1;
1275                }
1276
1277                break;
1278            }
1279
1280            case '3': {
1281                int err = 0;
1282
1283                err = open("/dev/video5", O_RDWR);
1284
1285                if (err < 0) {
1286                    printf("Could not open the camera device5: %d\n",  err );
1287                    return err;
1288                }
1289
1290                if ( startPreview() < 0 ) {
1291                    printf("Error while starting preview\n");
1292                    return -1;
1293                }
1294
1295                usleep(1000000);//1s
1296
1297                stopPreview();
1298
1299                close(err);
1300                break;
1301            }
1302
1303            case '4': {
1304
1305                if ( hardwareActive ) {
1306
1307                    params.setPictureFormat("invalid-format");
1308                    params.setPreviewFormat("invalid-format");
1309
1310                    stat = camera->setParameters(params.flatten());
1311
1312                    if ( NO_ERROR != stat ) {
1313                        printf("Test passed!\n");
1314                    } else {
1315                        printf("Test failed!\n");
1316                    }
1317
1318                    initDefaults();
1319                }
1320
1321                break;
1322            }
1323
1324            case '5': {
1325
1326                if ( hardwareActive ) {
1327
1328                    params.setPictureSize(-1, -1);
1329                    params.setPreviewSize(-1, -1);
1330
1331                    stat = camera->setParameters(params.flatten());
1332
1333                    if ( NO_ERROR != stat ) {
1334                        printf("Test passed!\n");
1335                    } else {
1336                        printf("Test failed!\n");
1337                    }
1338
1339                    initDefaults();
1340                }
1341
1342                break;
1343            }
1344
1345            case '6': {
1346
1347                if ( hardwareActive ) {
1348
1349                    params.setPreviewFrameRate(-1);
1350
1351                    stat = camera->setParameters(params.flatten());
1352
1353                    if ( NO_ERROR != stat ) {
1354                        printf("Test passed!\n");
1355                    } else {
1356                        printf("Test failed!\n");
1357                    }
1358
1359                    initDefaults();
1360                }
1361
1362
1363                break;
1364            }
1365
1366            case 'q': {
1367                goto exit;
1368
1369                break;
1370            }
1371
1372            default: {
1373                printf("Unrecognized command!\n");
1374
1375                break;
1376            }
1377        }
1378
1379        cmd = strtok_r(NULL, DELIMITER, &ctx);
1380    }
1381
1382exit:
1383
1384    return 0;
1385}
1386
1387
1388
1389