camera_test_script.cpp revision d7c79eb9444ac2c3933dcf42350bcb0a01ac66c7 
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 'F':
581                if ( hardwareActive )
582                    camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0);
583
584                break;
585
586            case 'T':
587
588                if ( hardwareActive )
589                    camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0);
590
591                break;
592
593            case 'u':
594                // HQ should always be in ldc-nsf
595                // if not HQ, then return the ipp to its previous state
596                if( !strcmp(capture[capture_mode], "high-quality") ) {
597                    ippIDX_old = ippIDX;
598                    ippIDX = 3;
599                    params.set(KEY_IPP, ipp_mode[ippIDX]);
600                } else {
601                    ippIDX = ippIDX_old;
602                }
603
604                params.set(KEY_MODE, (cmd + 1));
605                if ( hardwareActive )
606                    camera->setParameters(params.flatten());
607
608                break;
609
610            case 'U':
611
612                params.set(KEY_TEMP_BRACKETING, (cmd + 1));
613
614                if ( hardwareActive )
615                    camera->setParameters(params.flatten());
616
617                break;
618
619            case 'W':
620
621                tempBracketRange = atoi(cmd + 1);
622                tempBracketRange %= TEMP_BRACKETING_MAX_RANGE;
623                if ( 0 == tempBracketRange ) {
624                    tempBracketRange = 1;
625                }
626
627                params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange);
628                params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange);
629
630                if ( hardwareActive )
631                    camera->setParameters(params.flatten());
632
633            break;
634
635            case '#':
636
637                params.set(KEY_BURST, atoi(cmd + 1));
638
639                if ( hardwareActive )
640                    camera->setParameters(params.flatten());
641
642                break;
643
644            case 'J':
645                params.set(CameraParameters::KEY_FLASH_MODE, (cmd+1));
646
647                if ( hardwareActive )
648                    camera->setParameters(params.flatten());
649
650                break;
651
652            case 'w':
653                params.set(params.KEY_SCENE_MODE, (cmd + 1));
654
655                if ( hardwareActive )
656                    camera->setParameters(params.flatten());
657
658                break;
659
660            case 'B' :
661                params.set(KEY_VNF, (cmd + 1));
662
663                if ( hardwareActive )
664                    camera->setParameters(params.flatten());
665
666
667            case 'C' :
668                params.set(KEY_VSTAB, (cmd + 1));
669
670                if ( hardwareActive )
671                    camera->setParameters(params.flatten());
672                break;
673
674            case 'D':
675                if ( hardwareActive )
676                    camera->stopRecording();
677                break;
678
679            case 'E':
680                if(hardwareActive)
681                    params.unflatten(camera->getParameters());
682                printSupportedParams();
683                break;
684
685            case 'i':
686                iso_mode = atoi(cmd + 1);
687                params.set(KEY_ISO, iso_mode);
688
689                if ( hardwareActive )
690                    camera->setParameters(params.flatten());
691
692                break;
693
694            case 'h':
695                sharpness = atoi(cmd + 1);
696                params.set(KEY_SHARPNESS, sharpness);
697
698                if ( hardwareActive )
699                    camera->setParameters(params.flatten());
700
701                break;
702
703            case '@':
704                if ( hardwareActive ) {
705
706                    closeCamera();
707
708                    if ( 0 >= openCamera() ) {
709                        printf( "Reconnected to CameraService \n");
710                    }
711                }
712
713                break;
714
715            case 'c':
716                contrast = atoi(cmd + 1);
717                params.set(KEY_CONTRAST, contrast);
718
719                if ( hardwareActive ) {
720                    camera->setParameters(params.flatten());
721                }
722
723                break;
724
725            case 'z':
726            case 'Z':
727
728#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
729                params.set(CameraParameters::KEY_ZOOM, atoi(cmd + 1));
730#else
731
732                for(i = 0; i < length_Zoom; i++)
733                {
734                    if( strcmp((cmd + 1), zoom[i].zoom_description) == 0)
735                    {
736                        zoomIDX = i;
737                        break;
738                    }
739                }
740
741                params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
742#endif
743
744                if ( hardwareActive )
745                    camera->setParameters(params.flatten());
746
747                break;
748
749            case 'j':
750                params.set(KEY_EXPOSURE, (cmd + 1));
751
752                if ( hardwareActive )
753                    camera->setParameters(params.flatten());
754
755                break;
756
757            case 'b':
758                brightness = atoi(cmd + 1);
759                params.set(KEY_BRIGHTNESS, brightness);
760
761                if ( hardwareActive )
762                    camera->setParameters(params.flatten());
763
764                break;
765
766            case 's':
767                saturation = atoi(cmd + 1);
768                params.set(KEY_SATURATION, saturation);
769
770                if ( hardwareActive )
771                    camera->setParameters(params.flatten());
772
773                break;
774
775            case 'e':
776                params.set(params.KEY_EFFECT, (cmd + 1));
777
778                if ( hardwareActive )
779                    camera->setParameters(params.flatten());
780
781                break;
782
783            case 'r':
784
785                frameR = atoi(cmd + 1);
786
787
788                if (camera_index == 0) {
789                    for (i = 0; i < length_fpsConst_Ranges; i++) {
790                        if (frameR == fpsConstRanges[i].constFramerate)
791                            frameRateIndex = i;
792
793                    }
794                } else {
795                    for (i = 0; i < length_fpsConst_RangesSec; i++) {
796                        if (frameR == fpsConstRangesSec[i].constFramerate)
797                            frameRateIndex = i;
798                    }
799                }
800
801
802                if (camera_index == 0)
803                    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRanges[frameRateIndex].range);
804                else
805                    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRangesSec[frameRateIndex].range);
806
807
808                if ( hardwareActive && previewRunning ) {
809                    camera->stopPreview();
810                    camera->setParameters(params.flatten());
811                    camera->startPreview();
812                } else if ( hardwareActive ) {
813                    camera->setParameters(params.flatten());
814                }
815
816                break;
817
818            case 'R':
819                for(i = 0; i < length_fps_ranges; i++)
820                {
821                    if( strcmp((cmd + 1), fpsRanges[i].rangeDescription) == 0)
822                    {
823                        fpsRangeIdx = i;
824                        printf("Selected Framerate range: %s\n", fpsRanges[i].rangeDescription);
825                        if ( hardwareActive ) {
826                            params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsRanges[i].range);
827                            params.remove(CameraParameters::KEY_PREVIEW_FRAME_RATE);
828                            camera->setParameters(params.flatten());
829                        }
830                        break;
831                    }
832                }
833                break;
834
835            case 'x':
836                params.set(params.KEY_ANTIBANDING, (cmd + 1));
837
838                if ( hardwareActive )
839                    camera->setParameters(params.flatten());
840
841                break;
842
843            case 'g':
844                params.set(params.KEY_FOCUS_MODE, (cmd + 1));
845
846                if ( hardwareActive )
847                    camera->setParameters(params.flatten());
848
849                break;
850
851            case 'G':
852
853                params.set(CameraParameters::KEY_FOCUS_AREAS, (cmd + 1));
854
855                if ( hardwareActive )
856                    camera->setParameters(params.flatten());
857
858                params.remove(CameraParameters::KEY_FOCUS_AREAS);
859
860            case 'f':
861                gettimeofday(&autofocus_start, 0);
862
863                if ( hardwareActive )
864                    camera->autoFocus();
865
866                break;
867
868            case 'p':
869                gettimeofday(&picture_start, 0);
870
871                if ( hardwareActive )
872                    ret = camera->takePicture(CAMERA_MSG_COMPRESSED_IMAGE|CAMERA_MSG_RAW_IMAGE);
873
874                if ( ret != NO_ERROR )
875                    printf("Error returned while taking a picture");
876                break;
877
878            case 'd':
879                dly = atoi(cmd + 1);
880                sleep(dly);
881                break;
882
883            case 'q':
884                dump_mem_status();
885                stopPreview();
886
887                if ( recordingMode ) {
888                    stopRecording();
889                    closeRecorder();
890
891                    recordingMode = false;
892                }
893                goto exit;
894
895            case '\n':
896                printf("Iteration: %d \n", iteration);
897                iteration++;
898                break;
899
900            case '{':
901                if ( atoi(cmd + 1) > 0 )
902                    params.set(KEY_S3D2D_PREVIEW_MODE, "on");
903                else
904                    params.set(KEY_S3D2D_PREVIEW_MODE, "off");
905                if ( hardwareActive )
906                    camera->setParameters(params.flatten());
907                break;
908
909            case 'M':
910                params.set(KEY_MEASUREMENT, (cmd + 1));
911                if ( hardwareActive )
912                    camera->setParameters(params.flatten());
913                break;
914            case 'm':
915            {
916                params.set(KEY_METERING_MODE, (cmd + 1));
917                if ( hardwareActive )
918                {
919                    camera->setParameters(params.flatten());
920                }
921                break;
922            }
923            case '<':
924            {
925                char coord_str[8];
926                latitude += degree_by_step;
927                if (latitude > 90.0)
928                {
929                    latitude -= 180.0;
930                }
931                snprintf(coord_str, 7, "%.7lf", latitude);
932                params.set(params.KEY_GPS_LATITUDE, coord_str);
933                if ( hardwareActive )
934                {
935                    camera->setParameters(params.flatten());
936                }
937                break;
938            }
939
940            case '=':
941            {
942                char coord_str[8];
943                longitude += degree_by_step;
944                if (longitude > 180.0)
945                {
946                    longitude -= 360.0;
947                }
948                snprintf(coord_str, 7, "%.7lf", longitude);
949                params.set(params.KEY_GPS_LONGITUDE, coord_str);
950                if ( hardwareActive )
951                {
952                    camera->setParameters(params.flatten());
953                }
954                break;
955            }
956
957            case '>':
958            {
959                char coord_str[8];
960                altitude += 12345.67890123456789;
961                if (altitude > 100000.0)
962                {
963                    altitude -= 200000.0;
964                }
965                snprintf(coord_str, 7, "%.7lf", altitude);
966                params.set(params.KEY_GPS_ALTITUDE, coord_str);
967                if ( hardwareActive )
968                {
969                    camera->setParameters(params.flatten());
970                }
971                break;
972            }
973
974            case 'X':
975            {
976                char rem_str[50];
977                printf("Deleting images from %s \n", dir_path);
978                if(!sprintf(rem_str,"rm %s/*.jpg",dir_path))
979                    printf("Sprintf Error");
980                if(system(rem_str))
981                    printf("Images were not deleted\n");
982                break;
983            }
984
985            case '_':
986            {
987                AutoConvergenceModeIDX = atoi(cmd + 1);
988                if ( AutoConvergenceModeIDX < 0 || AutoConvergenceModeIDX > 4 )
989                    AutoConvergenceModeIDX = 0;
990                params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
991                if ( AutoConvergenceModeIDX != 4 )
992                    params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceDefaultValueIDX]);
993                if ( hardwareActive )
994                    camera->setParameters(params.flatten());
995                break;
996            }
997
998            case '^':
999            {
1000                char strtmpval[7];
1001                if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) {
1002                    sprintf(strtmpval,"%d", atoi(cmd + 1));
1003                    params.set(KEY_MANUALCONVERGENCE_VALUES, strtmpval);
1004                    if ( hardwareActive )
1005                        camera->setParameters(params.flatten());
1006                }
1007                break;
1008            }
1009
1010            default:
1011                printf("Unrecognized command!\n");
1012                break;
1013        }
1014
1015        cmd = strtok_r(NULL, DELIMITER, &ctx);
1016    }
1017
1018exit:
1019    if (stopScript == true)
1020      {
1021        return -1;
1022      }
1023    else
1024      {
1025        return 0;
1026      }
1027}
1028
1029
1030char * get_cycle_cmd(const char *aSrc) {
1031    unsigned ind = 0;
1032    char *cycle_cmd = new char[256];
1033
1034    while ((*aSrc != '+') && (*aSrc != '\0')) {
1035        cycle_cmd[ind++] = *aSrc++;
1036    }
1037    cycle_cmd[ind] = '\0';
1038
1039    return cycle_cmd;
1040}
1041
1042status_t dump_mem_status() {
1043  system(MEDIASERVER_DUMP);
1044  return system(MEMORY_DUMP);
1045}
1046
1047char *load_script(char *config) {
1048    FILE *infile;
1049    size_t fileSize;
1050    char *script;
1051    size_t nRead = 0;
1052    char dir_name[40];
1053    size_t count;
1054    char rCount [5];
1055
1056    count = 0;
1057
1058    infile = fopen(config, "r");
1059
1060    strcpy(script_name,config);
1061
1062    // remove just the '.txt' part of the config
1063    while((config[count] != '.') && (count < sizeof(dir_name)/sizeof(dir_name[0])))
1064        count++;
1065
1066    printf("\n SCRIPT : <%s> is currently being executed \n",script_name);
1067    if(strncpy(dir_name,config,count) == NULL)
1068        printf("Strcpy error");
1069
1070    dir_name[count]=NULL;
1071
1072    if(strcat(dir_path,dir_name) == NULL)
1073        printf("Strcat error");
1074
1075    if(restartCount)
1076    {
1077      sprintf(rCount,"_%d",restartCount);
1078      if(strcat(dir_path, rCount) == NULL)
1079        printf("Strcat error RestartCount");
1080    }
1081
1082    printf("\n COMPLETE FOLDER PATH : %s \n",dir_path);
1083    if(mkdir(dir_path,0777) == -1) {
1084        printf("\n Directory %s was not created \n",dir_path);
1085    } else {
1086        printf("\n Directory %s was created \n",dir_path);
1087    }
1088    printf("\n DIRECTORY CREATED FOR TEST RESULT IMAGES IN MMC CARD : %s \n",dir_name);
1089
1090    if( (NULL == infile)){
1091        printf("Error while opening script file %s!\n", config);
1092        return NULL;
1093    }
1094
1095    fseek(infile, 0, SEEK_END);
1096    fileSize = ftell(infile);
1097    fseek(infile, 0, SEEK_SET);
1098
1099    script = (char *) malloc(fileSize);
1100
1101    if ( NULL == script ) {
1102        printf("Unable to allocate buffer for the script\n");
1103
1104        return NULL;
1105    }
1106
1107    if ((nRead = fread(script, 1, fileSize, infile)) != fileSize) {
1108        printf("Error while reading script file!\n");
1109
1110        free(script);
1111        fclose(infile);
1112        return NULL;
1113    }
1114
1115    fclose(infile);
1116
1117    return script;
1118}
1119
1120int start_logging(char *config, int &pid) {
1121    char dir_name[40];
1122    size_t count = 0;
1123    int status = 0;
1124
1125    // remove just the '.txt' part of the config
1126    while((config[count] != '.') && (count < sizeof(dir_name)/sizeof(dir_name[0])))
1127        count++;
1128
1129    if(strncpy(dir_name,config,count) == NULL)
1130        printf("Strcpy error");
1131
1132    dir_name[count]=NULL;
1133
1134    pid = fork();
1135    if (pid == 0)
1136    {
1137        char *command_list[] = {"sh", "-c", NULL, NULL};
1138        char log_cmd[120];
1139        // child process to run logging
1140
1141        // set group id of this process to itself
1142        // we will use this group id to kill the
1143        // application logging
1144        setpgid(getpid(), getpid());
1145
1146        /* Start logcat */
1147        if(!sprintf(log_cmd,"logcat > /sdcard/%s/log.txt &",dir_name))
1148            printf(" Sprintf Error");
1149
1150        /* Start Syslink Trace */
1151        if(bLogSysLinkTrace) {
1152            if(!sprintf(log_cmd,"%s /system/bin/syslink_trace_daemon.out -l /sdcard/%s/syslink_trace.txt -f &",log_cmd, dir_name))
1153                printf(" Sprintf Error");
1154        }
1155
1156        command_list[2] = (char *)log_cmd;
1157        execvp("/system/bin/sh", command_list);
1158    } if(pid < 0)
1159    {
1160        printf("failed to fork logcat\n");
1161        return -1;
1162    }
1163
1164    //wait for logging to start
1165    if(waitpid(pid, &status, 0) != pid)
1166    {
1167        printf("waitpid failed in log fork\n");
1168        return -1;
1169    }else
1170        printf("logging started... status=%d\n", status);
1171
1172    return 0;
1173}
1174
1175int stop_logging(int &pid)
1176{
1177    if(pid > 0)
1178    {
1179        if(killpg(pid, SIGKILL))
1180        {
1181            printf("Exit command failed");
1182            return -1;
1183        } else {
1184            printf("\nlogging for script %s is complete\n   logcat saved @ location: %s\n",script_name,dir_path);
1185            if (bLogSysLinkTrace)
1186                printf("   syslink_trace is saved @ location: %s\n\n",dir_path);
1187        }
1188    }
1189    return 0;
1190}
1191
1192int execute_error_script(char *script) {
1193    char *cmd, *ctx;
1194    char id;
1195    status_t stat = NO_ERROR;
1196
1197    LOG_FUNCTION_NAME;
1198
1199    cmd = strtok_r((char *) script, DELIMITER, &ctx);
1200
1201    while ( NULL != cmd ) {
1202        id = cmd[0];
1203
1204        switch (id) {
1205
1206            case '0': {
1207                bufferStarvationTest = 1;
1208                params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation
1209
1210                if ( !recordingMode ) {
1211
1212                    recordingMode = true;
1213
1214                    if ( startPreview() < 0 ) {
1215                        printf("Error while starting preview\n");
1216
1217                        return -1;
1218                    }
1219
1220                    if ( openRecorder() < 0 ) {
1221                        printf("Error while openning video recorder\n");
1222
1223                        return -1;
1224                    }
1225
1226                    if ( configureRecorder() < 0 ) {
1227                        printf("Error while configuring video recorder\n");
1228
1229                        return -1;
1230                    }
1231
1232                    if ( startRecording() < 0 ) {
1233                        printf("Error while starting video recording\n");
1234
1235                        return -1;
1236                    }
1237
1238                }
1239
1240                usleep(1000000);//1s
1241
1242                stopPreview();
1243
1244                if ( recordingMode ) {
1245                    stopRecording();
1246                    closeRecorder();
1247
1248                    recordingMode = false;
1249                }
1250
1251                break;
1252            }
1253
1254            case '1': {
1255                int* tMemoryEater = new int[999999999];
1256
1257                if (!tMemoryEater) {
1258                    printf("Not enough memory\n");
1259                    return -1;
1260                } else {
1261                    delete tMemoryEater;
1262                }
1263
1264                break;
1265            }
1266
1267            case '2': {
1268                //camera = Camera::connect();
1269
1270                if ( NULL == camera.get() ) {
1271                    printf("Unable to connect to CameraService\n");
1272                    return -1;
1273                }
1274
1275                break;
1276            }
1277
1278            case '3': {
1279                int err = 0;
1280
1281                err = open("/dev/video5", O_RDWR);
1282
1283                if (err < 0) {
1284                    printf("Could not open the camera device5: %d\n",  err );
1285                    return err;
1286                }
1287
1288                if ( startPreview() < 0 ) {
1289                    printf("Error while starting preview\n");
1290                    return -1;
1291                }
1292
1293                usleep(1000000);//1s
1294
1295                stopPreview();
1296
1297                close(err);
1298                break;
1299            }
1300
1301            case '4': {
1302
1303                if ( hardwareActive ) {
1304
1305                    params.setPictureFormat("invalid-format");
1306                    params.setPreviewFormat("invalid-format");
1307
1308                    stat = camera->setParameters(params.flatten());
1309
1310                    if ( NO_ERROR != stat ) {
1311                        printf("Test passed!\n");
1312                    } else {
1313                        printf("Test failed!\n");
1314                    }
1315
1316                    initDefaults();
1317                }
1318
1319                break;
1320            }
1321
1322            case '5': {
1323
1324                if ( hardwareActive ) {
1325
1326                    params.setPictureSize(-1, -1);
1327                    params.setPreviewSize(-1, -1);
1328
1329                    stat = camera->setParameters(params.flatten());
1330
1331                    if ( NO_ERROR != stat ) {
1332                        printf("Test passed!\n");
1333                    } else {
1334                        printf("Test failed!\n");
1335                    }
1336
1337                    initDefaults();
1338                }
1339
1340                break;
1341            }
1342
1343            case '6': {
1344
1345                if ( hardwareActive ) {
1346
1347                    params.setPreviewFrameRate(-1);
1348
1349                    stat = camera->setParameters(params.flatten());
1350
1351                    if ( NO_ERROR != stat ) {
1352                        printf("Test passed!\n");
1353                    } else {
1354                        printf("Test failed!\n");
1355                    }
1356
1357                    initDefaults();
1358                }
1359
1360
1361                break;
1362            }
1363
1364            case 'q': {
1365                goto exit;
1366
1367                break;
1368            }
1369
1370            default: {
1371                printf("Unrecognized command!\n");
1372
1373                break;
1374            }
1375        }
1376
1377        cmd = strtok_r(NULL, DELIMITER, &ctx);
1378    }
1379
1380exit:
1381
1382    return 0;
1383}
1384
1385
1386
1387