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