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