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