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