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 <gui/Surface.h> 11#include <gui/SurfaceComposerClient.h> 12 13#include <camera/Camera.h> 14#include <camera/ICamera.h> 15#include <media/mediarecorder.h> 16 17#include <binder/IPCThreadState.h> 18#include <binder/ProcessState.h> 19#include <binder/IServiceManager.h> 20#include <cutils/properties.h> 21#include <camera/CameraParameters.h> 22#include <system/audio.h> 23#include <system/camera.h> 24 25#include <cutils/memory.h> 26#include <utils/Log.h> 27 28#include <sys/wait.h> 29 30#include "camera_test.h" 31 32using namespace android; 33 34int camera_index = 0; 35int print_menu; 36sp<Camera> camera; 37sp<MediaRecorder> recorder; 38sp<SurfaceComposerClient> client; 39sp<SurfaceControl> surfaceControl; 40sp<Surface> previewSurface; 41CameraParameters params; 42float compensation = 0.0; 43double latitude = 0.0; 44double longitude = 0.0; 45double degree_by_step = 17.5609756;//..0975609756097; 46double altitude = 0.0; 47int awb_mode = 0; 48int effects_mode = 0; 49int scene_mode = 0; 50int caf_mode = 0; 51int vnf_mode = 0; 52int vstab_mode = 0; 53 54int tempBracketRange = 1; 55int tempBracketIdx = 0; 56int measurementIdx = 0; 57int expBracketIdx = 0; 58int AutoConvergenceModeIDX = 0; 59int ManualConvergenceValuesIDX = 0; 60int ManualConvergenceDefaultValueIDX = 2; 61int gbceIDX = 0; 62int glbceIDX = 0; 63int rotation = 0; 64bool reSizePreview = true; 65bool hardwareActive = false; 66bool recordingMode = false; 67bool previewRunning = false; 68int saturation = 0; 69int zoomIDX = 0; 70int videoCodecIDX = 0; 71int audioCodecIDX = 0; 72int outputFormatIDX = 0; 73int contrast = 0; 74int brightness = 0; 75unsigned int burst = 0; 76int sharpness = 0; 77int iso_mode = 0; 78int capture_mode = 0; 79int exposure_mode = 0; 80int ippIDX = 0; 81int ippIDX_old = 0; 82int previewFormat = 0; 83int jpegQuality = 85; 84int thumbQuality = 85; 85int flashIdx = 0; 86int fpsRangeIdx = 0; 87timeval autofocus_start, picture_start; 88char script_name[80]; 89int prevcnt = 0; 90int videoFd = -1; 91int elockidx = 0; 92int wblockidx = 0; 93 94 95char dir_path[80] = SDCARD_PATH; 96 97const char *cameras[] = {"Primary Camera", "Secondary Camera 1", "Stereo Camera", "USB Camera", "Fake Camera"}; 98const char *measurement[] = {"disable", "enable"}; 99const char *expBracketing[] = {"disable", "enable"}; 100const char *expBracketingRange[] = {"", "-30,0,30,0,-30"}; 101const char *tempBracketing[] = {"disable", "enable"}; 102const char *faceDetection[] = {"disable", "enable"}; 103const char *lock[] = {"false", "true"}; 104 105#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) 106const char *ipp_mode[] = { "off", "Chroma Suppression", "Edge Enhancement" }; 107#else 108const char *ipp_mode[] = { "off", "ldc", "nsf", "ldc-nsf" }; 109#endif 110 111const char *iso [] = { "auto", "100", "200", "400", "800", "1200", "1600"}; 112 113const char *effects [] = { 114#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) 115 "none", 116 "mono", 117 "negative", 118 "solarize", 119 "sepia", 120 "whiteboard", 121 "blackboard", 122 "cool", 123 "emboss" 124#else 125 "none", 126 "mono", 127 "negative", 128 "solarize", 129 "sepia", 130 "vivid", 131 "whiteboard", 132 "blackboard", 133 "cool", 134 "emboss", 135 "blackwhite", 136 "aqua", 137 "posterize" 138#endif 139}; 140 141const char CameraParameters::FLASH_MODE_OFF[] = "off"; 142const char CameraParameters::FLASH_MODE_AUTO[] = "auto"; 143const char CameraParameters::FLASH_MODE_ON[] = "on"; 144const char CameraParameters::FLASH_MODE_RED_EYE[] = "red-eye"; 145const char CameraParameters::FLASH_MODE_TORCH[] = "torch"; 146 147const char *flashModes[] = { 148 "off", 149 "auto", 150 "on", 151 "red-eye", 152 "torch", 153 "fill-in", 154}; 155 156const char *caf [] = { "Off", "On" }; 157const char *vnf [] = { "Off", "On" }; 158const char *vstab [] = { "Off", "On" }; 159 160 161const char *scene [] = { 162#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) 163 "auto", 164 "portrait", 165 "landscape", 166 "night", 167 "night-portrait", 168 "fireworks", 169 "snow", 170 "action", 171#else 172 "auto", 173 "portrait", 174 "landscape", 175 "night", 176 "night-portrait", 177 "night-indoor", 178 "fireworks", 179 "sport", 180 "cine", 181 "beach", 182 "snow", 183 "mood", 184 "closeup", 185 "underwater", 186 "document", 187 "barcode", 188 "oldfilm", 189 "candlelight", 190 "party", 191 "steadyphoto", 192 "sunset", 193 "action", 194 "theatre" 195#endif 196}; 197const char *strawb_mode[] = { 198 "auto", 199 "incandescent", 200 "fluorescent", 201 "daylight", 202 "horizon", 203 "shadow", 204 "tungsten", 205 "shade", 206 "twilight", 207 "warm-fluorescent", 208 "facepriority", 209 "sunset" 210}; 211 212size_t length_cam = ARRAY_SIZE(cameras); 213 214 215preview_size previewSize [] = { 216 { 0, 0, "NULL"}, 217 { 128, 96, "SQCIF" }, 218 { 176, 144, "QCIF" }, 219 { 352, 288, "CIF" }, 220 { 320, 240, "QVGA" }, 221 { 352, 288, "CIF" }, 222 { 640, 480, "VGA" }, 223 { 720, 480, "NTSC" }, 224 { 720, 576, "PAL" }, 225 { 800, 480, "WVGA" }, 226 { 848, 480, "WVGA2"}, 227 { 864, 480, "WVGA3"}, 228 { 992, 560, "WVGA4"}, 229 { 1280, 720, "HD" }, 230 { 1920, 1080, "FULLHD"}, 231}; 232 233size_t length_previewSize = ARRAY_SIZE(previewSize); 234 235Vcapture_size VcaptureSize [] = { 236 { 128, 96, "SQCIF" }, 237 { 176, 144, "QCIF" }, 238 { 352, 288, "CIF" }, 239 { 320, 240, "QVGA" }, 240 { 640, 480, "VGA" }, 241 { 704, 480, "TVNTSC" }, 242 { 704, 576, "TVPAL" }, 243 { 720, 480, "D1NTSC" }, 244 { 720, 576, "D1PAL" }, 245 { 800, 480, "WVGA" }, 246 #if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) 247 { 848, 480, "WVGA2"}, 248 { 864, 480, "WVGA3"}, 249 { 992, 560, "WVGA4"}, 250 #endif 251 { 1280, 720, "HD" }, 252 { 1920, 1080, "FULLHD"}, 253}; 254 255size_t lenght_Vcapture_size = ARRAY_SIZE(VcaptureSize); 256 257capture_Size captureSize[] = { 258 { 320, 240, "QVGA" }, 259 { 640, 480, "VGA" }, 260 { 800, 600, "SVGA" }, 261 { 1152, 864, "1MP" }, 262 { 1280, 1024, "1.3MP" }, 263 { 1600, 1200, "2MP" }, 264 { 2048, 1536, "3MP" }, 265 { 2592, 1944, "5MP" }, 266 { 2608, 1960, "5MP" }, 267 { 3264, 2448, "8MP" }, 268 { 3648, 2736, "10MP"}, 269 { 4032, 3024, "12MP"}, 270}; 271 272size_t length_capture_Size = ARRAY_SIZE(captureSize); 273 274 275outformat outputFormat[] = { 276 { OUTPUT_FORMAT_THREE_GPP, "3gp" }, 277 { OUTPUT_FORMAT_MPEG_4, "mp4" }, 278 }; 279 280size_t length_outformat = ARRAY_SIZE(outputFormat); 281 282video_Codecs videoCodecs[] = { 283 { VIDEO_ENCODER_H263, "H263" }, 284 { VIDEO_ENCODER_H264, "H264" }, 285 { VIDEO_ENCODER_MPEG_4_SP, "MPEG4"} 286}; 287 288size_t length_video_Codecs = ARRAY_SIZE(videoCodecs); 289 290audio_Codecs audioCodecs[] = { 291 { AUDIO_ENCODER_AMR_NB, "AMR_NB" }, 292 { AUDIO_ENCODER_AMR_WB, "AMR_WB" }, 293 { AUDIO_ENCODER_AAC, "AAC" }, 294 { AUDIO_ENCODER_HE_AAC, "AAC+" }, 295 { AUDIO_ENCODER_LIST_END, "disabled"}, 296}; 297 298size_t length_audio_Codecs = ARRAY_SIZE(audioCodecs); 299 300V_bitRate VbitRate[] = { 301 { 64000, "64K" }, 302 { 128000, "128K" }, 303 { 192000, "192K" }, 304 { 240000, "240K" }, 305 { 320000, "320K" }, 306 { 360000, "360K" }, 307 { 384000, "384K" }, 308 { 420000, "420K" }, 309 { 768000, "768K" }, 310 { 1000000, "1M" }, 311 { 1500000, "1.5M" }, 312 { 2000000, "2M" }, 313 { 4000000, "4M" }, 314 { 6000000, "6M" }, 315 { 8000000, "8M" }, 316 { 10000000, "10M" }, 317}; 318 319size_t length_V_bitRate = ARRAY_SIZE(VbitRate); 320 321Zoom zoom[] = { 322 { 0, "1x" }, 323 { 12, "1.5x"}, 324 { 20, "2x" }, 325 { 27, "2.5x"}, 326 { 32, "3x" }, 327 { 36, "3.5x"}, 328 { 40, "4x" }, 329 { 60, "8x" }, 330}; 331 332size_t length_Zoom = ARRAY_SIZE(zoom); 333 334fps_ranges fpsRanges[] = { 335 { "5000,30000", "[5:30]" }, 336 { "5000,10000", "[5:10]" }, 337 { "5000,15000", "[5:15]" }, 338 { "5000,20000", "[5:20]" }, 339}; 340 341size_t length_fps_ranges = ARRAY_SIZE(fpsRanges); 342 343fpsConst_Ranges fpsConstRanges[] = { 344 { "5000,5000", "[5:5]", 5 }, 345 { "10000,10000", "[10:10]", 10 }, 346 { "15000,15000", "[15:15]", 15 }, 347 { "20000,20000", "[20:20]", 20 }, 348 { "25000,25000", "[25:25]", 25 }, 349 { "30000,30000", "[30:30]", 30 }, 350}; 351 352size_t length_fpsConst_Ranges = ARRAY_SIZE(fpsConstRanges); 353 354fpsConst_RangesSec fpsConstRangesSec[] = { 355 { "5000,5000", "[5:5]", 5 }, 356 { "10000,10000", "[10:10]", 10 }, 357 { "15000,15000", "[15:15]", 15 }, 358 { "20000,20000", "[20:20]", 20 }, 359 { "25000,25000", "[25:25]", 25 }, 360 { "27000,27000", "[27:27]", 27 }, 361}; 362 363size_t length_fpsConst_RangesSec = ARRAY_SIZE(fpsConstRangesSec); 364 365const char *antibanding[] = { 366 "off", 367 "auto", 368 "50hz", 369 "60hz", 370}; 371int antibanding_mode = 0; 372const char *focus[] = { 373 "auto", 374 "infinity", 375 "macro", 376 "continuous-video", 377 "extended", 378 "portrait", 379}; 380int focus_mode = 0; 381pixel_format pixelformat[] = { 382 { HAL_PIXEL_FORMAT_YCbCr_422_I, CameraParameters::PIXEL_FORMAT_YUV422I }, 383 { HAL_PIXEL_FORMAT_YCrCb_420_SP, CameraParameters::PIXEL_FORMAT_YUV420SP }, 384 { HAL_PIXEL_FORMAT_RGB_565, CameraParameters::PIXEL_FORMAT_RGB565 }, 385 { -1, CameraParameters::PIXEL_FORMAT_JPEG }, 386 { -1, "raw" }, 387 }; 388 389const char *codingformat[] = {"yuv422i-yuyv", "yuv420sp", "rgb565", "jpeg", "raw", "jps", "mpo", "raw+jpeg", "raw+mpo"}; 390const char *gbce[] = {"disable", "enable"}; 391int pictureFormat = 3; // jpeg 392const char *exposure[] = {"auto", "macro", "portrait", "landscape", "sports", "night", "night-portrait", "backlighting", "manual"}; 393const char *capture[] = { "high-performance", "high-quality", "video-mode" }; 394const char *autoconvergencemode[] = { "mode-disable", "mode-frame", "mode-center", "mode-fft", "mode-manual" }; 395const char *manualconvergencevalues[] = { "-100", "-50", "-30", "-25", "0", "25", "50", "100" }; 396 397const struct { 398 int fps; 399} frameRate[] = { 400 {0}, 401 {5}, 402 {10}, 403 {15}, 404 {20}, 405 {25}, 406 {30} 407}; 408 409int thumbSizeIDX = 3; 410int previewSizeIDX = ARRAY_SIZE(previewSize) - 1; 411int captureSizeIDX = ARRAY_SIZE(captureSize) - 1; 412int frameRateIDX = ARRAY_SIZE(fpsConstRanges) - 1; 413int frameRateIDXSec = ARRAY_SIZE(fpsConstRangesSec) - 1; 414int VcaptureSizeIDX = ARRAY_SIZE(VcaptureSize) - 1; 415int VbitRateIDX = ARRAY_SIZE(VbitRate) - 1; 416 417static unsigned int recording_counter = 1; 418 419int dump_preview = 0; 420int bufferStarvationTest = 0; 421bool showfps = false; 422 423const char *metering[] = { 424 "center", 425 "average", 426}; 427int meter_mode = 0; 428bool bLogSysLinkTrace = true; 429bool stressTest = false; 430bool stopScript = false; 431int restartCount = 0; 432 433static const String16 processName("camera_test"); 434 435/** Calculate delay from a reference time */ 436unsigned long long timeval_delay(const timeval *ref) { 437 unsigned long long st, end, delay; 438 timeval current_time; 439 440 gettimeofday(¤t_time, 0); 441 442 st = ref->tv_sec * 1000000 + ref->tv_usec; 443 end = current_time.tv_sec * 1000000 + current_time.tv_usec; 444 delay = end - st; 445 446 return delay; 447} 448 449/** Callback for takePicture() */ 450void my_raw_callback(const sp<IMemory>& mem) { 451 452 static int counter = 1; 453 unsigned char *buff = NULL; 454 int size; 455 int fd = -1; 456 char fn[256]; 457 458 LOG_FUNCTION_NAME; 459 460 if (mem == NULL) 461 goto out; 462 463 //Start preview after capture. 464 camera->startPreview(); 465 466 fn[0] = 0; 467 sprintf(fn, "/sdcard/img%03d.raw", counter); 468 fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777); 469 470 if (fd < 0) 471 goto out; 472 473 size = mem->size(); 474 475 if (size <= 0) 476 goto out; 477 478 buff = (unsigned char *)mem->pointer(); 479 480 if (!buff) 481 goto out; 482 483 if (size != write(fd, buff, size)) 484 printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno)); 485 486 counter++; 487 printf("%s: buffer=%08X, size=%d stored at %s\n", 488 __FUNCTION__, (int)buff, size, fn); 489 490out: 491 492 if (fd >= 0) 493 close(fd); 494 495 LOG_FUNCTION_NAME_EXIT; 496} 497 498void saveFile(const sp<IMemory>& mem) { 499 static int counter = 1; 500 unsigned char *buff = NULL; 501 int size; 502 int fd = -1; 503 char fn[256]; 504 505 LOG_FUNCTION_NAME; 506 507 if (mem == NULL) 508 goto out; 509 510 fn[0] = 0; 511 sprintf(fn, "/sdcard/preview%03d.yuv", counter); 512 fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777); 513 if(fd < 0) { 514 ALOGE("Unable to open file %s: %s", fn, strerror(fd)); 515 goto out; 516 } 517 518 size = mem->size(); 519 if (size <= 0) { 520 ALOGE("IMemory object is of zero size"); 521 goto out; 522 } 523 524 buff = (unsigned char *)mem->pointer(); 525 if (!buff) { 526 ALOGE("Buffer pointer is invalid"); 527 goto out; 528 } 529 530 if (size != write(fd, buff, size)) 531 printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno)); 532 533 counter++; 534 printf("%s: buffer=%08X, size=%d\n", 535 __FUNCTION__, (int)buff, size); 536 537out: 538 539 if (fd >= 0) 540 close(fd); 541 542 LOG_FUNCTION_NAME_EXIT; 543} 544 545 546void debugShowFPS() 547{ 548 static int mFrameCount = 0; 549 static int mLastFrameCount = 0; 550 static nsecs_t mLastFpsTime = 0; 551 static float mFps = 0; 552 mFrameCount++; 553 if ( ( mFrameCount % 30 ) == 0 ) { 554 nsecs_t now = systemTime(); 555 nsecs_t diff = now - mLastFpsTime; 556 mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; 557 mLastFpsTime = now; 558 mLastFrameCount = mFrameCount; 559 printf("####### [%d] Frames, %f FPS", mFrameCount, mFps); 560 } 561} 562 563/** Callback for startPreview() */ 564void my_preview_callback(const sp<IMemory>& mem) { 565 566 printf("PREVIEW Callback 0x%x", ( unsigned int ) mem->pointer()); 567 if (dump_preview) { 568 569 if(prevcnt==50) 570 saveFile(mem); 571 572 prevcnt++; 573 574 uint8_t *ptr = (uint8_t*) mem->pointer(); 575 576 printf("PRV_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7], ptr[8], ptr[9]); 577 578 } 579 580 debugShowFPS(); 581} 582 583/** Callback for takePicture() */ 584void my_jpeg_callback(const sp<IMemory>& mem) { 585 static int counter = 1; 586 unsigned char *buff = NULL; 587 int size; 588 int fd = -1; 589 char fn[256]; 590 591 LOG_FUNCTION_NAME; 592 593 //Start preview after capture. 594 camera->startPreview(); 595 596 if (mem == NULL) 597 goto out; 598 599 fn[0] = 0; 600 sprintf(fn, "%s/img%03d.jpg", dir_path,counter); 601 fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777); 602 603 if(fd < 0) { 604 ALOGE("Unable to open file %s: %s", fn, strerror(fd)); 605 goto out; 606 } 607 608 size = mem->size(); 609 if (size <= 0) { 610 ALOGE("IMemory object is of zero size"); 611 goto out; 612 } 613 614 buff = (unsigned char *)mem->pointer(); 615 if (!buff) { 616 ALOGE("Buffer pointer is invalid"); 617 goto out; 618 } 619 620 if (size != write(fd, buff, size)) 621 printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno)); 622 623 counter++; 624 printf("%s: buffer=%08X, size=%d stored at %s\n", 625 __FUNCTION__, (int)buff, size, fn); 626 627out: 628 629 if (fd >= 0) 630 close(fd); 631 632 LOG_FUNCTION_NAME_EXIT; 633} 634 635void my_face_callback(camera_frame_metadata_t *metadata) { 636 int idx; 637 638 if ( NULL == metadata ) { 639 return; 640 } 641 642 for ( idx = 0 ; idx < metadata->number_of_faces ; idx++ ) { 643 printf("Face %d at %d,%d %d,%d \n", 644 idx, 645 metadata->faces[idx].rect[0], 646 metadata->faces[idx].rect[1], 647 metadata->faces[idx].rect[2], 648 metadata->faces[idx].rect[3]); 649 } 650 651} 652 653void CameraHandler::notify(int32_t msgType, int32_t ext1, int32_t ext2) { 654 655 printf("Notify cb: %d %d %d\n", msgType, ext1, ext2); 656 657 if ( msgType & CAMERA_MSG_FOCUS ) 658 printf("AutoFocus %s in %llu us\n", (ext1) ? "OK" : "FAIL", timeval_delay(&autofocus_start)); 659 660 if ( msgType & CAMERA_MSG_SHUTTER ) 661 printf("Shutter done in %llu us\n", timeval_delay(&picture_start)); 662 663 if ( msgType & CAMERA_MSG_ERROR && (ext1 == 1)) 664 { 665 printf("Camera Test CAMERA_MSG_ERROR.....\n"); 666 if (stressTest) 667 { 668 printf("Camera Test Notified of Error Restarting.....\n"); 669 stopScript = true; 670 } 671 else 672 { 673 printf("Camera Test Notified of Error Stopping.....\n"); 674 stopScript =false; 675 stopPreview(); 676 677 if (recordingMode) 678 { 679 stopRecording(); 680 closeRecorder(); 681 recordingMode = false; 682 } 683 } 684 } 685} 686 687void CameraHandler::postData(int32_t msgType, 688 const sp<IMemory>& dataPtr, 689 camera_frame_metadata_t *metadata) { 690 printf("Data cb: %d\n", msgType); 691 692 if ( msgType & CAMERA_MSG_PREVIEW_FRAME ) 693 my_preview_callback(dataPtr); 694 695 if ( msgType & CAMERA_MSG_RAW_IMAGE ) { 696 printf("RAW done in %llu us\n", timeval_delay(&picture_start)); 697 my_raw_callback(dataPtr); 698 } 699 700 if (msgType & CAMERA_MSG_POSTVIEW_FRAME) { 701 printf("Postview frame %llu us\n", timeval_delay(&picture_start)); 702 } 703 704 if (msgType & CAMERA_MSG_COMPRESSED_IMAGE ) { 705 printf("JPEG done in %llu us\n", timeval_delay(&picture_start)); 706 my_jpeg_callback(dataPtr); 707 } 708 709 if ( ( msgType & CAMERA_MSG_PREVIEW_METADATA ) && 710 ( NULL != metadata ) ) { 711 printf("Face detected %d \n", metadata->number_of_faces); 712 my_face_callback(metadata); 713 } 714} 715 716void CameraHandler::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) 717 718{ 719 printf("Recording cb: %d %lld %p\n", msgType, timestamp, dataPtr.get()); 720 721 static uint32_t count = 0; 722 723 //if(count==100) 724 //saveFile(dataPtr); 725 726 count++; 727 728 uint8_t *ptr = (uint8_t*) dataPtr->pointer(); 729 730 printf("VID_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7], ptr[8], ptr[9]); 731 732 camera->releaseRecordingFrame(dataPtr); 733} 734 735int createPreviewSurface(unsigned int width, unsigned int height, int32_t pixFormat) { 736 unsigned int previewWidth, previewHeight; 737 738 if ( MAX_PREVIEW_SURFACE_WIDTH < width ) { 739 previewWidth = MAX_PREVIEW_SURFACE_WIDTH; 740 } else { 741 previewWidth = width; 742 } 743 744 if ( MAX_PREVIEW_SURFACE_HEIGHT < height ) { 745 previewHeight = MAX_PREVIEW_SURFACE_HEIGHT; 746 } else { 747 previewHeight = height; 748 } 749 750 client = new SurfaceComposerClient(); 751 752 if ( NULL == client.get() ) { 753 printf("Unable to establish connection to Surface Composer \n"); 754 755 return -1; 756 } 757 758 surfaceControl = client->createSurface(String8("camera_test_menu"), 759 previewWidth, 760 previewHeight, 761 pixFormat, 0); 762 763 previewSurface = surfaceControl->getSurface(); 764 765 client->openGlobalTransaction(); 766 surfaceControl->setLayer(0x7fffffff); 767 surfaceControl->setPosition(0, 0); 768 surfaceControl->setSize(previewWidth, previewHeight); 769 surfaceControl->show(); 770 client->closeGlobalTransaction(); 771 772 return 0; 773} 774 775void printSupportedParams() 776{ 777 printf("\n\r\tSupported Cameras: %s", params.get("camera-indexes")); 778 printf("\n\r\tSupported Picture Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES)); 779 printf("\n\r\tSupported Picture Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS)); 780 printf("\n\r\tSupported Preview Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES)); 781 printf("\n\r\tSupported Preview Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS)); 782 printf("\n\r\tSupported Preview Frame Rates: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES)); 783 printf("\n\r\tSupported Thumbnail Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES)); 784 printf("\n\r\tSupported Whitebalance Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE)); 785 printf("\n\r\tSupported Effects: %s", params.get(CameraParameters::KEY_SUPPORTED_EFFECTS)); 786 printf("\n\r\tSupported Scene Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES)); 787 printf("\n\r\tSupported Focus Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES)); 788 printf("\n\r\tSupported Antibanding Options: %s", params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING)); 789 printf("\n\r\tSupported Flash Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES)); 790 printf("\n\r\tSupported Focus Areas: %d", params.getInt(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS)); 791 792 if ( NULL != params.get(CameraParameters::KEY_FOCUS_DISTANCES) ) { 793 printf("\n\r\tFocus Distances: %s \n", params.get(CameraParameters::KEY_FOCUS_DISTANCES)); 794 } 795 796 return; 797} 798 799 800int destroyPreviewSurface() { 801 802 if ( NULL != previewSurface.get() ) { 803 previewSurface.clear(); 804 } 805 806 if ( NULL != surfaceControl.get() ) { 807 surfaceControl->clear(); 808 surfaceControl.clear(); 809 } 810 811 if ( NULL != client.get() ) { 812 client->dispose(); 813 client.clear(); 814 } 815 816 return 0; 817} 818 819int openRecorder() { 820 recorder = new MediaRecorder(); 821 822 if ( NULL == recorder.get() ) { 823 printf("Error while creating MediaRecorder\n"); 824 825 return -1; 826 } 827 828 return 0; 829} 830 831int closeRecorder() { 832 if ( NULL == recorder.get() ) { 833 printf("invalid recorder reference\n"); 834 835 return -1; 836 } 837 838 if ( recorder->init() < 0 ) { 839 printf("recorder failed to initialize\n"); 840 841 return -1; 842 } 843 844 if ( recorder->close() < 0 ) { 845 printf("recorder failed to close\n"); 846 847 return -1; 848 } 849 850 if ( recorder->release() < 0 ) { 851 printf("error while releasing recorder\n"); 852 853 return -1; 854 } 855 856 recorder.clear(); 857 858 return 0; 859} 860 861int configureRecorder() { 862 863 char videoFile[256],vbit_string[50]; 864 videoFd = -1; 865 866 if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) { 867 printf("invalid recorder and/or camera references\n"); 868 869 return -1; 870 } 871 872 camera->unlock(); 873 874 sprintf(vbit_string,"video-param-encoding-bitrate=%u", VbitRate[VbitRateIDX].bit_rate); 875 String8 bit_rate(vbit_string); 876 if ( recorder->setParameters(bit_rate) < 0 ) { 877 printf("error while configuring bit rate\n"); 878 879 return -1; 880 } 881 882 if ( recorder->setCamera(camera->remote(), camera->getRecordingProxy()) < 0 ) { 883 printf("error while setting the camera\n"); 884 885 return -1; 886 } 887 888 if ( recorder->setVideoSource(VIDEO_SOURCE_CAMERA) < 0 ) { 889 printf("error while configuring camera video source\n"); 890 891 return -1; 892 } 893 894 895 if ( AUDIO_ENCODER_LIST_END != audioCodecs[audioCodecIDX].type ) { 896 if ( recorder->setAudioSource(AUDIO_SOURCE_DEFAULT) < 0 ) { 897 printf("error while configuring camera audio source\n"); 898 899 return -1; 900 } 901 } 902 903 if ( recorder->setOutputFormat(outputFormat[outputFormatIDX].type) < 0 ) { 904 printf("error while configuring output format\n"); 905 906 return -1; 907 } 908 909 if(mkdir("/mnt/sdcard/videos",0777) == -1) 910 printf("\n Directory --videos-- was not created \n"); 911 sprintf(videoFile, "/mnt/sdcard/videos/video%d.%s", recording_counter,outputFormat[outputFormatIDX].desc); 912 913 videoFd = open(videoFile, O_CREAT | O_RDWR); 914 915 if(videoFd < 0){ 916 printf("Error while creating video filename\n"); 917 918 return -1; 919 } 920 921 if ( recorder->setOutputFile(videoFd, 0, 0) < 0 ) { 922 printf("error while configuring video filename\n"); 923 924 return -1; 925 } 926 927 recording_counter++; 928 929 if (camera_index == 0) { 930 if ( recorder->setVideoFrameRate(fpsConstRanges[frameRateIDX].constFramerate) < 0 ) { 931 printf("error while configuring video framerate\n"); 932 return -1; 933 } 934 } 935 else { 936 if ( recorder->setVideoFrameRate(fpsConstRangesSec[frameRateIDXSec].constFramerate) < 0 ) { 937 printf("error while configuring video framerate\n"); 938 return -1; 939 } 940 } 941 942 if ( recorder->setVideoSize(VcaptureSize[VcaptureSizeIDX].width, VcaptureSize[VcaptureSizeIDX].height) < 0 ) { 943 printf("error while configuring video size\n"); 944 945 return -1; 946 } 947 948 if ( recorder->setVideoEncoder(videoCodecs[videoCodecIDX].type) < 0 ) { 949 printf("error while configuring video codec\n"); 950 951 return -1; 952 } 953 954 if ( AUDIO_ENCODER_LIST_END != audioCodecs[audioCodecIDX].type ) { 955 if ( recorder->setAudioEncoder(audioCodecs[audioCodecIDX].type) < 0 ) { 956 printf("error while configuring audio codec\n"); 957 958 return -1; 959 } 960 } 961 962 if ( recorder->setPreviewSurface( surfaceControl->getSurface()->getIGraphicBufferProducer() ) < 0 ) { 963 printf("error while configuring preview surface\n"); 964 965 return -1; 966 } 967 968 return 0; 969} 970 971int startRecording() { 972 if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) { 973 printf("invalid recorder and/or camera references\n"); 974 975 return -1; 976 } 977 978 camera->unlock(); 979 980 if ( recorder->prepare() < 0 ) { 981 printf("recorder prepare failed\n"); 982 983 return -1; 984 } 985 986 if ( recorder->start() < 0 ) { 987 printf("recorder start failed\n"); 988 989 return -1; 990 } 991 992 return 0; 993} 994 995int stopRecording() { 996 if ( NULL == recorder.get() ) { 997 printf("invalid recorder reference\n"); 998 999 return -1; 1000 } 1001 1002 if ( recorder->stop() < 0 ) { 1003 printf("recorder failed to stop\n"); 1004 1005 return -1; 1006 } 1007 1008 if ( 0 < videoFd ) { 1009 close(videoFd); 1010 } 1011 1012 return 0; 1013} 1014 1015int openCamera() { 1016 printf("openCamera(camera_index=%d)\n", camera_index); 1017 camera = Camera::connect(camera_index, 1018 processName, 1019 Camera::USE_CALLING_UID); 1020 1021 if ( NULL == camera.get() ) { 1022 printf("Unable to connect to CameraService\n"); 1023 printf("Retrying... \n"); 1024 sleep(1); 1025 camera = Camera::connect(camera_index, 1026 processName, 1027 Camera::USE_CALLING_UID); 1028 1029 if ( NULL == camera.get() ) { 1030 printf("Giving up!! \n"); 1031 return -1; 1032 } 1033 } 1034 1035 params = camera->getParameters(); 1036 camera->setParameters(params.flatten()); 1037 1038 camera->setListener(new CameraHandler()); 1039 1040 hardwareActive = true; 1041 1042 return 0; 1043} 1044 1045int closeCamera() { 1046 if ( NULL == camera.get() ) { 1047 printf("invalid camera reference\n"); 1048 1049 return -1; 1050 } 1051 1052 camera->disconnect(); 1053 camera.clear(); 1054 1055 hardwareActive = false; 1056 1057 return 0; 1058} 1059 1060int startPreview() { 1061 int previewWidth, previewHeight; 1062 if (reSizePreview) { 1063 1064 if(recordingMode) 1065 { 1066 previewWidth = VcaptureSize[VcaptureSizeIDX].width; 1067 previewHeight = VcaptureSize[VcaptureSizeIDX].height; 1068 }else 1069 { 1070 previewWidth = previewSize[previewSizeIDX].width; 1071 previewHeight = previewSize[previewSizeIDX].height; 1072 } 1073 1074 if ( createPreviewSurface(previewWidth, 1075 previewHeight, 1076 pixelformat[previewFormat].pixelFormatDesc) < 0 ) { 1077 printf("Error while creating preview surface\n"); 1078 return -1; 1079 } 1080 1081 if ( !hardwareActive ) { 1082 openCamera(); 1083 } 1084 1085 params.setPreviewSize(previewWidth, previewHeight); 1086 params.setPictureSize(captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height); 1087 1088 camera->setParameters(params.flatten()); 1089 camera->setPreviewTexture(previewSurface->getIGraphicBufferProducer()); 1090 1091 if(!hardwareActive) prevcnt = 0; 1092 1093 camera->startPreview(); 1094 1095 previewRunning = true; 1096 reSizePreview = false; 1097 1098 } 1099 1100 return 0; 1101} 1102 1103void stopPreview() { 1104 if ( hardwareActive ) { 1105 camera->stopPreview(); 1106 1107 destroyPreviewSurface(); 1108 1109 previewRunning = false; 1110 reSizePreview = true; 1111 closeCamera(); 1112 } 1113} 1114 1115void initDefaults() { 1116 camera_index = 0; 1117 antibanding_mode = 0; 1118 focus_mode = 0; 1119 fpsRangeIdx = 0; 1120 previewSizeIDX = 1; /* Default resolution set to WVGA */ 1121 captureSizeIDX = 3; /* Default capture resolution is 8MP */ 1122 frameRateIDX = ARRAY_SIZE(fpsConstRanges) - 1; /* Default frame rate is 30 FPS */ 1123#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) 1124 VcaptureSizeIDX = ARRAY_SIZE(VcaptureSize) - 6;/* Default video record is WVGA */ 1125#else 1126 VcaptureSizeIDX = ARRAY_SIZE(VcaptureSize) - 2;/* Default video record is WVGA */ 1127#endif 1128 VbitRateIDX = ARRAY_SIZE(VbitRate) - 4; /*Default video bit rate is 4M */ 1129 thumbSizeIDX = 0; 1130 compensation = 0.0; 1131 awb_mode = 0; 1132 effects_mode = 0; 1133 scene_mode = 0; 1134 caf_mode = 0; 1135 vnf_mode = 0; 1136 vstab_mode = 0; 1137 expBracketIdx = 0; 1138 flashIdx = 0; 1139 rotation = 0; 1140 zoomIDX = 0; 1141 videoCodecIDX = 0; 1142 gbceIDX = 0; 1143 glbceIDX = 0; 1144#ifdef TARGET_OMAP4 1145 ///Temporary fix until OMAP3 and OMAP4 3A values are synced 1146 contrast = 90; 1147 brightness = 50; 1148 sharpness = 0; 1149 saturation = 50; 1150#else 1151 contrast = 100; 1152 brightness = 100; 1153 sharpness = 0; 1154 saturation = 100; 1155#endif 1156 iso_mode = 0; 1157 capture_mode = 0; 1158 exposure_mode = 0; 1159 ippIDX = 0;//set the ipp to ldc-nsf as the capture mode is set to HQ by default 1160 ippIDX_old = ippIDX; 1161 jpegQuality = 85; 1162 bufferStarvationTest = 0; 1163 meter_mode = 0; 1164 previewFormat = 1; 1165 pictureFormat = 3; // jpeg 1166 params.setPreviewSize(previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height); 1167 params.setPictureSize(captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height); 1168 params.set(CameraParameters::KEY_ROTATION, rotation); 1169 params.set(KEY_COMPENSATION, (int) (compensation * 10)); 1170 params.set(params.KEY_WHITE_BALANCE, strawb_mode[awb_mode]); 1171 params.set(KEY_MODE, (capture[capture_mode])); 1172 params.set(params.KEY_SCENE_MODE, scene[scene_mode]); 1173 params.set(KEY_CAF, caf_mode); 1174 params.set(KEY_ISO, iso_mode); 1175 params.set(KEY_GBCE, gbce[gbceIDX]); 1176 params.set(KEY_GLBCE, gbce[glbceIDX]); 1177 params.set(KEY_SHARPNESS, sharpness); 1178 params.set(KEY_CONTRAST, contrast); 1179 params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx); 1180 params.set(KEY_EXPOSURE, exposure[exposure_mode]); 1181 params.set(KEY_BRIGHTNESS, brightness); 1182 params.set(KEY_SATURATION, saturation); 1183 params.set(params.KEY_EFFECT, effects[effects_mode]); 1184 params.setPreviewFrameRate(frameRate[ARRAY_SIZE(frameRate) - 1].fps); 1185 params.set(params.KEY_ANTIBANDING, antibanding[antibanding_mode]); 1186 params.set(params.KEY_FOCUS_MODE, focus[focus_mode]); 1187 params.set(KEY_IPP, ipp_mode[ippIDX]); 1188 params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality); 1189 params.setPreviewFormat(pixelformat[previewFormat].pixformat); 1190 params.setPictureFormat(codingformat[pictureFormat]); 1191 params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation 1192 params.set(KEY_METERING_MODE, metering[meter_mode]); 1193 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, previewSize[thumbSizeIDX].width); 1194 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, previewSize[thumbSizeIDX].height); 1195 ManualConvergenceValuesIDX = ManualConvergenceDefaultValueIDX; 1196 params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceValuesIDX]); 1197 params.set(KEY_S3D2D_PREVIEW_MODE, "off"); 1198 params.set(KEY_STEREO_CAMERA, "false"); 1199 params.set(KEY_EXIF_MODEL, MODEL); 1200 params.set(KEY_EXIF_MAKE, MAKE); 1201} 1202 1203int menu_gps() { 1204 char ch; 1205 char coord_str[100]; 1206 1207 if (print_menu) { 1208 printf("\n\n== GPS MENU ============================\n\n"); 1209 printf(" e. Latitude: %.7lf\n", latitude); 1210 printf(" d. Longitude: %.7lf\n", longitude); 1211 printf(" c. Altitude: %.7lf\n", altitude); 1212 printf("\n"); 1213 printf(" q. Return to main menu\n"); 1214 printf("\n"); 1215 printf(" Choice: "); 1216 } 1217 1218 ch = getchar(); 1219 printf("%c", ch); 1220 1221 print_menu = 1; 1222 1223 switch (ch) { 1224 1225 case 'e': 1226 latitude += degree_by_step; 1227 1228 if (latitude > 90.0) { 1229 latitude -= 180.0; 1230 } 1231 1232 snprintf(coord_str, 7, "%.7lf", latitude); 1233 params.set(params.KEY_GPS_LATITUDE, coord_str); 1234 1235 if ( hardwareActive ) 1236 camera->setParameters(params.flatten()); 1237 1238 break; 1239 1240 case 'd': 1241 longitude += degree_by_step; 1242 1243 if (longitude > 180.0) { 1244 longitude -= 360.0; 1245 } 1246 1247 snprintf(coord_str, 7, "%.7lf", longitude); 1248 params.set(params.KEY_GPS_LONGITUDE, coord_str); 1249 1250 if ( hardwareActive ) 1251 camera->setParameters(params.flatten()); 1252 1253 break; 1254 1255 case 'c': 1256 altitude += 12345.67890123456789; 1257 1258 if (altitude > 100000.0) { 1259 altitude -= 200000.0; 1260 } 1261 1262 snprintf(coord_str, 100, "%.20lf", altitude); 1263 params.set(params.KEY_GPS_ALTITUDE, coord_str); 1264 1265 if ( hardwareActive ) 1266 camera->setParameters(params.flatten()); 1267 1268 break; 1269 1270 case 'Q': 1271 case 'q': 1272 return -1; 1273 1274 default: 1275 print_menu = 0; 1276 break; 1277 } 1278 1279 return 0; 1280} 1281 1282int functional_menu() { 1283 char ch; 1284 1285 if (print_menu) { 1286 1287 printf("\n\n=========== FUNCTIONAL TEST MENU ===================\n\n"); 1288 1289 printf(" \n\nSTART / STOP / GENERAL SERVICES \n"); 1290 printf(" -----------------------------\n"); 1291 printf(" A Select Camera %s\n", cameras[camera_index]); 1292 printf(" [. Resume Preview after capture\n"); 1293 printf(" 0. Reset to defaults\n"); 1294 printf(" q. Quit\n"); 1295 printf(" @. Disconnect and Reconnect to CameraService \n"); 1296 printf(" /. Enable/Disable showfps: %s\n", ((showfps)? "Enabled":"Disabled")); 1297 printf(" a. GEO tagging settings menu\n"); 1298 printf(" E. Camera Capability Dump"); 1299 1300 1301 printf(" \n\n PREVIEW SUB MENU \n"); 1302 printf(" -----------------------------\n"); 1303 printf(" 1. Start Preview\n"); 1304 printf(" 2. Stop Preview\n"); 1305 printf(" ~. Preview format %s\n", pixelformat[previewFormat].pixformat); 1306#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) 1307 printf(" 4. Preview size: %4d x %4d - %s\n",previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height, previewSize[previewSizeIDX].desc); 1308#else 1309 printf(" 4. Preview size: %4d x %4d - %s\n",previewSize[previewSizeIDX].width, camera_index == 2 ? previewSize[previewSizeIDX].height*2 : previewSize[previewSizeIDX].height, previewSize[previewSizeIDX].desc); 1310#endif 1311 printf(" R. Preview framerate range: %s\n", fpsRanges[fpsRangeIdx].rangeDescription); 1312 printf(" &. Dump a preview frame\n"); 1313 printf(" _. Auto Convergence mode: %s\n", autoconvergencemode[AutoConvergenceModeIDX]); 1314 printf(" ^. Manual Convergence Value: %s\n", manualconvergencevalues[ManualConvergenceValuesIDX]); 1315 printf(" {. 2D Preview in 3D Stereo Mode: %s\n", params.get(KEY_S3D2D_PREVIEW_MODE)); 1316 1317 printf(" \n\n IMAGE CAPTURE SUB MENU \n"); 1318 printf(" -----------------------------\n"); 1319 printf(" p. Take picture/Full Press\n"); 1320 printf(" H. Exposure Bracketing: %s\n", expBracketing[expBracketIdx]); 1321 printf(" U. Temporal Bracketing: %s\n", tempBracketing[tempBracketIdx]); 1322 printf(" W. Temporal Bracketing Range: [-%d;+%d]\n", tempBracketRange, tempBracketRange); 1323 printf(" $. Picture Format: %s\n", codingformat[pictureFormat]); 1324 printf(" 3. Picture Rotation: %3d degree\n", rotation ); 1325 printf(" 5. Picture size: %4d x %4d - %s\n",captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height, captureSize[captureSizeIDX].name); 1326 printf(" i. ISO mode: %s\n", iso[iso_mode]); 1327 printf(" u. Capture Mode: %s\n", capture[capture_mode]); 1328 printf(" k. IPP Mode: %s\n", ipp_mode[ippIDX]); 1329 printf(" K. GBCE: %s\n", gbce[gbceIDX]); 1330 printf(" O. GLBCE %s\n", gbce[glbceIDX]); 1331 printf(" o. Jpeg Quality: %d\n", jpegQuality); 1332 printf(" #. Burst Images: %3d\n", burst); 1333 printf(" :. Thumbnail Size: %4d x %4d - %s\n",previewSize[thumbSizeIDX].width, previewSize[thumbSizeIDX].height, previewSize[thumbSizeIDX].desc); 1334 printf(" ': Thumbnail Quality %d\n", thumbQuality); 1335 1336 printf(" \n\n VIDEO CAPTURE SUB MENU \n"); 1337 printf(" -----------------------------\n"); 1338 1339 printf(" 6. Start Video Recording\n"); 1340 printf(" 2. Stop Recording\n"); 1341 printf(" l. Video Capture resolution: %4d x %4d - %s\n",VcaptureSize[VcaptureSizeIDX].width,VcaptureSize[VcaptureSizeIDX].height, VcaptureSize[VcaptureSizeIDX].desc); 1342 printf(" ]. Video Bit rate : %s\n", VbitRate[VbitRateIDX].desc); 1343 printf(" 9. Video Codec: %s\n", videoCodecs[videoCodecIDX].desc); 1344 printf(" D. Audio Codec: %s\n", audioCodecs[audioCodecIDX].desc); 1345 printf(" v. Output Format: %s\n", outputFormat[outputFormatIDX].desc); 1346 1347 if (camera_index == 1) { 1348 printf(" r. Framerate: %d\n", fpsConstRangesSec[frameRateIDXSec].constFramerate); 1349 } 1350 else { 1351 printf(" r. Framerate: %d\n", fpsConstRanges[frameRateIDX].constFramerate); 1352 } 1353 printf(" *. Start Video Recording dump ( 1 raw frame ) \n"); 1354 printf(" B VNF %s \n", vnf[vnf_mode]); 1355 printf(" C VSTAB %s", vstab[vstab_mode]); 1356 1357 printf(" \n\n 3A SETTING SUB MENU \n"); 1358 printf(" -----------------------------\n"); 1359 1360 printf(" M. Measurement Data: %s\n", measurement[measurementIdx]); 1361 printf(" F. Start face detection \n"); 1362 printf(" T. Stop face detection \n"); 1363 printf(" G. Touch/Focus area AF\n"); 1364 printf(" f. Auto Focus/Half Press\n"); 1365 printf(" J.Flash: %s\n", flashModes[flashIdx]); 1366 printf(" 7. EV offset: %4.1f\n", compensation); 1367 printf(" 8. AWB mode: %s\n", strawb_mode[awb_mode]); 1368 printf(" z. Zoom %s\n", zoom[zoomIDX].zoom_description); 1369 printf(" j. Exposure %s\n", exposure[exposure_mode]); 1370 printf(" e. Effect: %s\n", effects[effects_mode]); 1371 printf(" w. Scene: %s\n", scene[scene_mode]); 1372 printf(" s. Saturation: %d\n", saturation); 1373 printf(" c. Contrast: %d\n", contrast); 1374 printf(" h. Sharpness: %d\n", sharpness); 1375 printf(" b. Brightness: %d\n", brightness); 1376 printf(" x. Antibanding: %s\n", antibanding[antibanding_mode]); 1377 printf(" g. Focus mode: %s\n", focus[focus_mode]); 1378 printf(" m. Metering mode: %s\n" , metering[meter_mode]); 1379 printf(" <. Exposure Lock: %s\n", lock[elockidx]); 1380 printf(" >. WhiteBalance Lock: %s\n",lock[wblockidx]); 1381 printf("\n"); 1382 printf(" Choice: "); 1383 } 1384 1385 ch = getchar(); 1386 printf("%c", ch); 1387 1388 print_menu = 1; 1389 1390 switch (ch) { 1391 1392 case '_': 1393 AutoConvergenceModeIDX++; 1394 AutoConvergenceModeIDX %= ARRAY_SIZE(autoconvergencemode); 1395 params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]); 1396 if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) { 1397 params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceValuesIDX]); 1398 } 1399 else { 1400 params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceDefaultValueIDX]); 1401 ManualConvergenceValuesIDX = ManualConvergenceDefaultValueIDX; 1402 } 1403 camera->setParameters(params.flatten()); 1404 1405 break; 1406 case '^': 1407 if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) { 1408 ManualConvergenceValuesIDX++; 1409 ManualConvergenceValuesIDX %= ARRAY_SIZE(manualconvergencevalues); 1410 params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceValuesIDX]); 1411 camera->setParameters(params.flatten()); 1412 } 1413 break; 1414 case 'A': 1415 camera_index++; 1416 camera_index %= ARRAY_SIZE(cameras); 1417 if ( camera_index == 2) { 1418 params.set(KEY_STEREO_CAMERA, "true"); 1419 } else { 1420 params.set(KEY_STEREO_CAMERA, "false"); 1421 } 1422 closeCamera(); 1423 1424 openCamera(); 1425 1426 if (camera_index == 0) { 1427 params.setPreviewFrameRate(30); 1428 } else { 1429 params.setPreviewFrameRate(27); 1430 } 1431 1432 1433 break; 1434 case '[': 1435 if ( hardwareActive ) { 1436 camera->setParameters(params.flatten()); 1437 camera->startPreview(); 1438 } 1439 break; 1440 1441 case '0': 1442 initDefaults(); 1443 break; 1444 1445 case '1': 1446 1447 if ( startPreview() < 0 ) { 1448 printf("Error while starting preview\n"); 1449 1450 return -1; 1451 } 1452 1453 break; 1454 1455 case '2': 1456 stopPreview(); 1457 1458 if ( recordingMode ) { 1459 camera->disconnect(); 1460 camera.clear(); 1461 stopRecording(); 1462 closeRecorder(); 1463 1464 camera = Camera::connect(camera_index, 1465 processName, 1466 Camera::USE_CALLING_UID); 1467 if ( NULL == camera.get() ) { 1468 sleep(1); 1469 camera = Camera::connect(camera_index, 1470 processName, 1471 Camera::USE_CALLING_UID); 1472 if ( NULL == camera.get() ) { 1473 return -1; 1474 } 1475 } 1476 camera->setListener(new CameraHandler()); 1477 camera->setParameters(params.flatten()); 1478 recordingMode = false; 1479 } 1480 1481 break; 1482 1483 case '3': 1484 rotation += 90; 1485 rotation %= 360; 1486 params.set(CameraParameters::KEY_ROTATION, rotation); 1487 if ( hardwareActive ) 1488 camera->setParameters(params.flatten()); 1489 1490 break; 1491 1492 case '4': 1493 previewSizeIDX += 1; 1494 previewSizeIDX %= ARRAY_SIZE(previewSize); 1495 if ( NULL != params.get(KEY_STEREO_CAMERA) ) { 1496 if ( strcmp(params.get(KEY_STEREO_CAMERA), "false") == 0 ) { 1497 params.setPreviewSize(previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height); 1498 } else { 1499 params.setPreviewSize(previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height*2); 1500 } 1501 } 1502 reSizePreview = true; 1503 1504 if ( hardwareActive && previewRunning ) { 1505 camera->stopPreview(); 1506 camera->setParameters(params.flatten()); 1507 camera->startPreview(); 1508 } else if ( hardwareActive ) { 1509 camera->setParameters(params.flatten()); 1510 } 1511 1512 break; 1513 1514 case '5': 1515 captureSizeIDX += 1; 1516 captureSizeIDX %= ARRAY_SIZE(captureSize); 1517 params.setPictureSize(captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height); 1518 1519 if ( hardwareActive ) 1520 camera->setParameters(params.flatten()); 1521 break; 1522 1523 case 'l': 1524 case 'L': 1525 VcaptureSizeIDX++; 1526 VcaptureSizeIDX %= ARRAY_SIZE(VcaptureSize); 1527 break; 1528 1529 case ']': 1530 VbitRateIDX++; 1531 VbitRateIDX %= ARRAY_SIZE(VbitRate); 1532 break; 1533 1534 1535 case '6': 1536 1537 if ( !recordingMode ) { 1538 1539 recordingMode = true; 1540 1541 if ( startPreview() < 0 ) { 1542 printf("Error while starting preview\n"); 1543 1544 return -1; 1545 } 1546 1547 if ( openRecorder() < 0 ) { 1548 printf("Error while openning video recorder\n"); 1549 1550 return -1; 1551 } 1552 1553 if ( configureRecorder() < 0 ) { 1554 printf("Error while configuring video recorder\n"); 1555 1556 return -1; 1557 } 1558 1559 if ( startRecording() < 0 ) { 1560 printf("Error while starting video recording\n"); 1561 1562 return -1; 1563 } 1564 } 1565 1566 break; 1567 1568 case '7': 1569 1570 if ( compensation > 2.0) { 1571 compensation = -2.0; 1572 } else { 1573 compensation += 0.1; 1574 } 1575 1576 params.set(KEY_COMPENSATION, (int) (compensation * 10)); 1577 1578 if ( hardwareActive ) 1579 camera->setParameters(params.flatten()); 1580 1581 break; 1582 1583 case '8': 1584 awb_mode++; 1585 awb_mode %= ARRAY_SIZE(strawb_mode); 1586 params.set(params.KEY_WHITE_BALANCE, strawb_mode[awb_mode]); 1587 1588 if ( hardwareActive ) 1589 camera->setParameters(params.flatten()); 1590 1591 break; 1592 1593 case '9': 1594 videoCodecIDX++; 1595 videoCodecIDX %= ARRAY_SIZE(videoCodecs); 1596 break; 1597 case '~': 1598 previewFormat += 1; 1599 previewFormat %= ARRAY_SIZE(pixelformat) - 1; 1600 params.setPreviewFormat(pixelformat[previewFormat].pixformat); 1601 1602 if ( hardwareActive ) 1603 camera->setParameters(params.flatten()); 1604 1605 break; 1606 case '$': 1607 pictureFormat += 1; 1608 if ( NULL != params.get(KEY_STEREO_CAMERA) ) { 1609 if ( strcmp(params.get(KEY_STEREO_CAMERA), "false") == 0 && pictureFormat > 4 ) 1610 pictureFormat = 0; 1611 } 1612 pictureFormat %= ARRAY_SIZE(codingformat); 1613 params.setPictureFormat(codingformat[pictureFormat]); 1614 if ( hardwareActive ) 1615 camera->setParameters(params.flatten()); 1616 1617 break; 1618 1619 case '?' : 1620 ///Set mode=3 to select video mode 1621 params.set(KEY_MODE, 3); 1622 params.set(KEY_VNF, 1); 1623 params.set(KEY_VSTAB, 1); 1624 break; 1625 1626 case ':': 1627 thumbSizeIDX += 1; 1628 thumbSizeIDX %= ARRAY_SIZE(previewSize); 1629 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, previewSize[thumbSizeIDX].width); 1630 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, previewSize[thumbSizeIDX].height); 1631 1632 if ( hardwareActive ) 1633 camera->setParameters(params.flatten()); 1634 1635 break; 1636 1637 case '\'': 1638 if ( thumbQuality >= 100) { 1639 thumbQuality = 0; 1640 } else { 1641 thumbQuality += 5; 1642 } 1643 1644 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality); 1645 if ( hardwareActive ) 1646 camera->setParameters(params.flatten()); 1647 break; 1648 1649 case 'B' : 1650 vnf_mode++; 1651 vnf_mode %= ARRAY_SIZE(vnf); 1652 params.set(KEY_VNF, vnf_mode); 1653 1654 if ( hardwareActive ) 1655 camera->setParameters(params.flatten()); 1656 break; 1657 1658 case 'C' : 1659 vstab_mode++; 1660 vstab_mode %= ARRAY_SIZE(vstab); 1661 params.set(KEY_VSTAB, vstab_mode); 1662 1663 if ( hardwareActive ) 1664 camera->setParameters(params.flatten()); 1665 break; 1666 1667 case 'E': 1668 if(hardwareActive) 1669 params.unflatten(camera->getParameters()); 1670 printSupportedParams(); 1671 break; 1672 1673 case '*': 1674 if ( hardwareActive ) 1675 camera->startRecording(); 1676 break; 1677 1678 case 'o': 1679 if ( jpegQuality >= 100) { 1680 jpegQuality = 0; 1681 } else { 1682 jpegQuality += 5; 1683 } 1684 1685 params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality); 1686 if ( hardwareActive ) 1687 camera->setParameters(params.flatten()); 1688 break; 1689 1690 case 'M': 1691 measurementIdx = (measurementIdx + 1)%ARRAY_SIZE(measurement); 1692 params.set(KEY_MEASUREMENT, measurement[measurementIdx]); 1693 if ( hardwareActive ) 1694 camera->setParameters(params.flatten()); 1695 break; 1696 case 'm': 1697 { 1698 meter_mode = (meter_mode + 1)%ARRAY_SIZE(metering); 1699 params.set(KEY_METERING_MODE, metering[meter_mode]); 1700 if ( hardwareActive ) 1701 camera->setParameters(params.flatten()); 1702 break; 1703 } 1704 1705 case 'k': 1706 ippIDX += 1; 1707 ippIDX %= ARRAY_SIZE(ipp_mode); 1708 ippIDX_old = ippIDX; 1709 1710 params.set(KEY_IPP, ipp_mode[ippIDX]); 1711 1712 if ( hardwareActive ) 1713 camera->setParameters(params.flatten()); 1714 1715 break; 1716 1717 case 'K': 1718 gbceIDX+= 1; 1719 gbceIDX %= ARRAY_SIZE(gbce); 1720 params.set(KEY_GBCE, gbce[gbceIDX]); 1721 1722 if ( hardwareActive ) 1723 camera->setParameters(params.flatten()); 1724 break; 1725 1726 case 'O': 1727 glbceIDX+= 1; 1728 glbceIDX %= ARRAY_SIZE(gbce); 1729 params.set(KEY_GLBCE, gbce[glbceIDX]); 1730 1731 if ( hardwareActive ) 1732 camera->setParameters(params.flatten()); 1733 break; 1734 1735 case 'F': 1736 if ( hardwareActive ) 1737 camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0); 1738 1739 break; 1740 1741 case 'T': 1742 1743 if ( hardwareActive ) 1744 camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0); 1745 1746 break; 1747 1748 case '@': 1749 if ( hardwareActive ) { 1750 1751 closeCamera(); 1752 1753 if ( 0 >= openCamera() ) { 1754 printf( "Reconnected to CameraService \n"); 1755 } 1756 } 1757 1758 break; 1759 1760 case '#': 1761 1762 if ( burst >= MAX_BURST ) { 1763 burst = 0; 1764 } else { 1765 burst += BURST_INC; 1766 } 1767 params.set(KEY_BURST, burst); 1768 1769 if ( hardwareActive ) 1770 camera->setParameters(params.flatten()); 1771 1772 break; 1773 1774 case 'J': 1775 flashIdx++; 1776 flashIdx %= ARRAY_SIZE(flashModes); 1777 params.set(CameraParameters::KEY_FLASH_MODE, (flashModes[flashIdx])); 1778 1779 if ( hardwareActive ) 1780 camera->setParameters(params.flatten()); 1781 1782 break; 1783 1784 case 'u': 1785 capture_mode++; 1786 capture_mode %= ARRAY_SIZE(capture); 1787 1788 // HQ should always be in ldc-nsf 1789 // if not HQ, then return the ipp to its previous state 1790 if( !strcmp(capture[capture_mode], "high-quality") ) { 1791 ippIDX_old = ippIDX; 1792 ippIDX = 3; 1793 params.set(KEY_IPP, ipp_mode[ippIDX]); 1794 } else { 1795 ippIDX = ippIDX_old; 1796 } 1797 1798 params.set(KEY_MODE, (capture[capture_mode])); 1799 1800 if ( hardwareActive ) 1801 camera->setParameters(params.flatten()); 1802 1803 break; 1804 1805 case 'U': 1806 tempBracketIdx++; 1807 tempBracketIdx %= ARRAY_SIZE(tempBracketing); 1808 params.set(KEY_TEMP_BRACKETING, tempBracketing[tempBracketIdx]); 1809 1810 if ( hardwareActive ) 1811 camera->setParameters(params.flatten()); 1812 1813 break; 1814 1815 case 'H': 1816 expBracketIdx++; 1817 expBracketIdx %= ARRAY_SIZE(expBracketing); 1818 1819 params.set(KEY_EXP_BRACKETING_RANGE, expBracketingRange[expBracketIdx]); 1820 1821 if ( hardwareActive ) 1822 camera->setParameters(params.flatten()); 1823 1824 break; 1825 1826 case 'W': 1827 tempBracketRange++; 1828 tempBracketRange %= TEMP_BRACKETING_MAX_RANGE; 1829 if ( 0 == tempBracketRange ) { 1830 tempBracketRange = 1; 1831 } 1832 1833 params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange); 1834 params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange); 1835 1836 if ( hardwareActive ) 1837 camera->setParameters(params.flatten()); 1838 1839 break; 1840 1841 case 'w': 1842 scene_mode++; 1843 scene_mode %= ARRAY_SIZE(scene); 1844 params.set(params.KEY_SCENE_MODE, scene[scene_mode]); 1845 1846 if ( hardwareActive ) 1847 camera->setParameters(params.flatten()); 1848 1849 break; 1850 1851 case 'i': 1852 iso_mode++; 1853 iso_mode %= ARRAY_SIZE(iso); 1854 params.set(KEY_ISO, iso[iso_mode]); 1855 1856 if ( hardwareActive ) 1857 camera->setParameters(params.flatten()); 1858 break; 1859 1860 case 'h': 1861 if ( sharpness >= 100) { 1862 sharpness = 0; 1863 } else { 1864 sharpness += 10; 1865 } 1866 params.set(KEY_SHARPNESS, sharpness); 1867 if ( hardwareActive ) 1868 camera->setParameters(params.flatten()); 1869 break; 1870 1871 case 'D': 1872 { 1873 audioCodecIDX++; 1874 audioCodecIDX %= ARRAY_SIZE(audioCodecs); 1875 break; 1876 } 1877 1878 case 'v': 1879 { 1880 outputFormatIDX++; 1881 outputFormatIDX %= ARRAY_SIZE(outputFormat); 1882 break; 1883 } 1884 1885 case 'z': 1886 zoomIDX++; 1887 zoomIDX %= ARRAY_SIZE(zoom); 1888 params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx); 1889 1890 if ( hardwareActive ) 1891 camera->setParameters(params.flatten()); 1892 1893 break; 1894 1895 case 'j': 1896 exposure_mode++; 1897 exposure_mode %= ARRAY_SIZE(exposure); 1898 params.set(KEY_EXPOSURE, exposure[exposure_mode]); 1899 1900 if ( hardwareActive ) 1901 camera->setParameters(params.flatten()); 1902 1903 break; 1904 1905 case 'c': 1906 if( contrast >= 200){ 1907 contrast = 0; 1908 } else { 1909 contrast += 10; 1910 } 1911 params.set(KEY_CONTRAST, contrast); 1912 if ( hardwareActive ) 1913 camera->setParameters(params.flatten()); 1914 break; 1915 case 'b': 1916 if ( brightness >= 200) { 1917 brightness = 0; 1918 } else { 1919 brightness += 10; 1920 } 1921 1922 params.set(KEY_BRIGHTNESS, brightness); 1923 1924 if ( hardwareActive ) 1925 camera->setParameters(params.flatten()); 1926 1927 break; 1928 1929 case 's': 1930 case 'S': 1931 if ( saturation >= 100) { 1932 saturation = 0; 1933 } else { 1934 saturation += 10; 1935 } 1936 1937 params.set(KEY_SATURATION, saturation); 1938 1939 if ( hardwareActive ) 1940 camera->setParameters(params.flatten()); 1941 1942 break; 1943 1944 case 'e': 1945 effects_mode++; 1946 effects_mode %= ARRAY_SIZE(effects); 1947 params.set(params.KEY_EFFECT, effects[effects_mode]); 1948 1949 if ( hardwareActive ) 1950 camera->setParameters(params.flatten()); 1951 1952 break; 1953 1954 case 'r': 1955 1956 1957 if (camera_index == 0) { 1958 frameRateIDX += 1; 1959 frameRateIDX %= ARRAY_SIZE(fpsConstRanges); 1960 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRanges[frameRateIDX].range); 1961 } else 1962 { 1963 frameRateIDXSec += 1; 1964 frameRateIDXSec %= ARRAY_SIZE(fpsConstRangesSec); 1965 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRangesSec[frameRateIDXSec].range); 1966 1967 1968 } 1969 1970 if ( hardwareActive ) { 1971 camera->setParameters(params.flatten()); 1972 } 1973 1974 break; 1975 1976 case 'R': 1977 fpsRangeIdx += 1; 1978 fpsRangeIdx %= ARRAY_SIZE(fpsRanges); 1979 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsRanges[fpsRangeIdx].range); 1980 1981 if ( hardwareActive ) { 1982 camera->setParameters(params.flatten()); 1983 } 1984 1985 break; 1986 1987 case 'x': 1988 antibanding_mode++; 1989 antibanding_mode %= ARRAY_SIZE(antibanding); 1990 params.set(params.KEY_ANTIBANDING, antibanding[antibanding_mode]); 1991 1992 if ( hardwareActive ) 1993 camera->setParameters(params.flatten()); 1994 1995 break; 1996 1997 case 'g': 1998 focus_mode++; 1999 focus_mode %= ARRAY_SIZE(focus); 2000 params.set(params.KEY_FOCUS_MODE, focus[focus_mode]); 2001 2002 if ( hardwareActive ) 2003 camera->setParameters(params.flatten()); 2004 2005 break; 2006 2007 case 'G': 2008 2009 params.set(CameraParameters::KEY_FOCUS_AREAS, TEST_FOCUS_AREA); 2010 2011 if ( hardwareActive ) 2012 camera->setParameters(params.flatten()); 2013 2014 params.remove(CameraParameters::KEY_FOCUS_AREAS); 2015 2016 case 'f': 2017 2018 gettimeofday(&autofocus_start, 0); 2019 2020 if ( hardwareActive ) 2021 camera->autoFocus(); 2022 2023 break; 2024 2025 case 'p': 2026 2027 gettimeofday(&picture_start, 0); 2028 2029 if ( hardwareActive ) 2030 camera->takePicture(CAMERA_MSG_COMPRESSED_IMAGE|CAMERA_MSG_RAW_IMAGE); 2031 2032 break; 2033 2034 case '&': 2035 printf("Enabling Preview Callback"); 2036 dump_preview = 1; 2037 if ( hardwareActive ) 2038 camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK); 2039 break; 2040 2041 case '{': 2042 if ( strcmp(params.get(KEY_S3D2D_PREVIEW_MODE), "off") == 0 ) 2043 { 2044 params.set(KEY_S3D2D_PREVIEW_MODE, "on"); 2045 } 2046 else 2047 { 2048 params.set(KEY_S3D2D_PREVIEW_MODE, "off"); 2049 } 2050 if ( hardwareActive ) 2051 camera->setParameters(params.flatten()); 2052 break; 2053 2054 case 'a': 2055 2056 while (1) { 2057 if ( menu_gps() < 0) 2058 break; 2059 }; 2060 2061 break; 2062 2063 case 'q': 2064 2065 stopPreview(); 2066 2067 return -1; 2068 2069 case '/': 2070 { 2071 if (showfps) 2072 { 2073 property_set("debug.image.showfps", "0"); 2074 showfps = false; 2075 } 2076 else 2077 { 2078 property_set("debug.image.showfps", "1"); 2079 showfps = true; 2080 } 2081 break; 2082 } 2083 2084 case '<': 2085 elockidx += 1; 2086 elockidx %= ARRAY_SIZE(lock); 2087 params.set(KEY_AUTO_EXPOSURE_LOCK, lock[elockidx]); 2088 if ( hardwareActive ) 2089 camera->setParameters(params.flatten()); 2090 break; 2091 2092 case '>': 2093 wblockidx += 1; 2094 wblockidx %= ARRAY_SIZE(lock); 2095 params.set(KEY_AUTO_WHITEBALANCE_LOCK, lock[wblockidx]); 2096 if ( hardwareActive ) 2097 camera->setParameters(params.flatten()); 2098 break; 2099 2100 default: 2101 print_menu = 0; 2102 2103 break; 2104 } 2105 2106 return 0; 2107} 2108 2109void print_usage() { 2110 printf(" USAGE: camera_test <param> <script>\n"); 2111 printf(" <param>\n-----------\n\n"); 2112 printf(" F or f -> Functional tests \n"); 2113 printf(" A or a -> API tests \n"); 2114 printf(" E or e -> Error scenario tests \n"); 2115 printf(" S or s -> Stress tests; with syslink trace \n"); 2116 printf(" SN or sn -> Stress tests; No syslink trace \n\n"); 2117 printf(" <script>\n----------\n"); 2118 printf("Script name (Only for stress tests)\n\n"); 2119 return; 2120} 2121 2122int error_scenario() { 2123 char ch; 2124 status_t stat = NO_ERROR; 2125 2126 if (print_menu) { 2127 printf(" 0. Buffer need\n"); 2128 printf(" 1. Not enough memory\n"); 2129 printf(" 2. Media server crash\n"); 2130 printf(" 3. Overlay object request\n"); 2131 printf(" 4. Pass unsupported preview&picture format\n"); 2132 printf(" 5. Pass unsupported preview&picture resolution\n"); 2133 printf(" 6. Pass unsupported preview framerate\n"); 2134 2135 printf(" q. Quit\n"); 2136 printf(" Choice: "); 2137 } 2138 2139 print_menu = 1; 2140 ch = getchar(); 2141 printf("%c\n", ch); 2142 2143 switch (ch) { 2144 case '0': { 2145 printf("Case0:Buffer need\n"); 2146 bufferStarvationTest = 1; 2147 params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation 2148 2149 if ( !recordingMode ) { 2150 recordingMode = true; 2151 if ( startPreview() < 0 ) { 2152 printf("Error while starting preview\n"); 2153 2154 return -1; 2155 } 2156 2157 if ( openRecorder() < 0 ) { 2158 printf("Error while openning video recorder\n"); 2159 2160 return -1; 2161 } 2162 2163 if ( configureRecorder() < 0 ) { 2164 printf("Error while configuring video recorder\n"); 2165 2166 return -1; 2167 } 2168 2169 if ( startRecording() < 0 ) { 2170 printf("Error while starting video recording\n"); 2171 2172 return -1; 2173 } 2174 2175 } 2176 2177 usleep(1000000);//1s 2178 2179 stopPreview(); 2180 2181 if ( recordingMode ) { 2182 stopRecording(); 2183 closeRecorder(); 2184 2185 recordingMode = false; 2186 } 2187 2188 break; 2189 } 2190 2191 case '1': { 2192 printf("Case1:Not enough memory\n"); 2193 int* tMemoryEater = new int[999999999]; 2194 2195 if (!tMemoryEater) { 2196 printf("Not enough memory\n"); 2197 return -1; 2198 } else { 2199 delete tMemoryEater; 2200 } 2201 2202 break; 2203 } 2204 2205 case '2': { 2206 printf("Case2:Media server crash\n"); 2207 //camera = Camera::connect(); 2208 2209 if ( NULL == camera.get() ) { 2210 printf("Unable to connect to CameraService\n"); 2211 return -1; 2212 } 2213 2214 break; 2215 } 2216 2217 case '3': { 2218 printf("Case3:Overlay object request\n"); 2219 int err = 0; 2220 2221 err = open("/dev/video5", O_RDWR); 2222 2223 if (err < 0) { 2224 printf("Could not open the camera device5: %d\n", err ); 2225 return err; 2226 } 2227 2228 if ( startPreview() < 0 ) { 2229 printf("Error while starting preview\n"); 2230 return -1; 2231 } 2232 2233 usleep(1000000);//1s 2234 2235 stopPreview(); 2236 2237 close(err); 2238 break; 2239 } 2240 2241 case '4': { 2242 2243 if ( hardwareActive ) { 2244 2245 params.setPictureFormat("invalid-format"); 2246 params.setPreviewFormat("invalid-format"); 2247 2248 stat = camera->setParameters(params.flatten()); 2249 2250 if ( NO_ERROR != stat ) { 2251 printf("Test passed!\n"); 2252 } else { 2253 printf("Test failed!\n"); 2254 } 2255 2256 initDefaults(); 2257 } 2258 2259 break; 2260 } 2261 2262 case '5': { 2263 2264 if ( hardwareActive ) { 2265 2266 params.setPictureSize(-1, -1); 2267 params.setPreviewSize(-1, -1); 2268 2269 stat = camera->setParameters(params.flatten()); 2270 2271 if ( NO_ERROR != stat ) { 2272 printf("Test passed!\n"); 2273 } else { 2274 printf("Test failed!\n"); 2275 } 2276 2277 initDefaults(); 2278 } 2279 2280 break; 2281 } 2282 2283 case '6': { 2284 2285 if ( hardwareActive ) { 2286 2287 params.setPreviewFrameRate(-1); 2288 2289 stat = camera->setParameters(params.flatten()); 2290 2291 if ( NO_ERROR != stat ) { 2292 printf("Test passed!\n"); 2293 } else { 2294 printf("Test failed!\n"); 2295 } 2296 2297 initDefaults(); 2298 } 2299 2300 2301 break; 2302 } 2303 2304 case 'q': { 2305 return -1; 2306 } 2307 2308 default: { 2309 print_menu = 0; 2310 break; 2311 } 2312 } 2313 2314 return 0; 2315} 2316 2317int restartCamera() { 2318 2319 const char dir_path_name[80] = SDCARD_PATH; 2320 2321 printf("+++Restarting Camera After Error+++\n"); 2322 stopPreview(); 2323 2324 if (recordingMode) { 2325 stopRecording(); 2326 closeRecorder(); 2327 2328 recordingMode = false; 2329 } 2330 2331 sleep(3); //Wait a bit before restarting 2332 2333 restartCount++; 2334 2335 if (strcpy(dir_path, dir_path_name) == NULL) 2336 { 2337 printf("Error reseting dir name"); 2338 return -1; 2339 } 2340 2341 if ( openCamera() < 0 ) 2342 { 2343 printf("+++Camera Restarted Failed+++\n"); 2344 system("echo camerahal_test > /sys/power/wake_unlock"); 2345 return -1; 2346 } 2347 2348 initDefaults(); 2349 2350 stopScript = false; 2351 2352 printf("+++Camera Restarted Successfully+++\n"); 2353 return 0; 2354} 2355 2356int main(int argc, char *argv[]) { 2357 char *cmd; 2358 int pid; 2359 sp<ProcessState> proc(ProcessState::self()); 2360 2361 unsigned long long st, end, delay; 2362 timeval current_time; 2363 2364 gettimeofday(¤t_time, 0); 2365 2366 st = current_time.tv_sec * 1000000 + current_time.tv_usec; 2367 2368 cmd = NULL; 2369 2370 if ( argc < 2 ) { 2371 printf(" Please enter atleast 1 argument\n"); 2372 print_usage(); 2373 2374 return 0; 2375 } 2376 system("echo camerahal_test > /sys/power/wake_lock"); 2377 if ( argc < 3 ) { 2378 switch (*argv[1]) { 2379 case 'S': 2380 case 's': 2381 printf("This is stress / regression tests \n"); 2382 printf("Provide script file as 2nd argument\n"); 2383 2384 break; 2385 2386 case 'F': 2387 case 'f': 2388 ProcessState::self()->startThreadPool(); 2389 2390 if ( openCamera() < 0 ) { 2391 printf("Camera initialization failed\n"); 2392 system("echo camerahal_test > /sys/power/wake_unlock"); 2393 return -1; 2394 } 2395 2396 initDefaults(); 2397 print_menu = 1; 2398 2399 while ( 1 ) { 2400 if ( functional_menu() < 0 ) 2401 break; 2402 }; 2403 2404 break; 2405 2406 case 'A': 2407 case 'a': 2408 printf("API level test cases coming soon ... \n"); 2409 2410 break; 2411 2412 case 'E': 2413 case 'e': { 2414 ProcessState::self()->startThreadPool(); 2415 2416 if ( openCamera() < 0 ) { 2417 printf("Camera initialization failed\n"); 2418 system("echo camerahal_test > /sys/power/wake_unlock"); 2419 return -1; 2420 } 2421 2422 initDefaults(); 2423 print_menu = 1; 2424 2425 while (1) { 2426 if (error_scenario() < 0) { 2427 break; 2428 } 2429 } 2430 2431 break; 2432 } 2433 2434 default: 2435 printf("INVALID OPTION USED\n"); 2436 print_usage(); 2437 2438 break; 2439 } 2440 } else if ( ( argc == 3) && ( ( *argv[1] == 'S' ) || ( *argv[1] == 's') ) ) { 2441 2442 if((argv[1][1] == 'N') || (argv[1][1] == 'n')) { 2443 bLogSysLinkTrace = false; 2444 } 2445 2446 ProcessState::self()->startThreadPool(); 2447 2448 if ( openCamera() < 0 ) { 2449 printf("Camera initialization failed\n"); 2450 system("echo camerahal_test > /sys/power/wake_unlock"); 2451 return -1; 2452 } 2453 2454 initDefaults(); 2455 2456 cmd = load_script(argv[2]); 2457 2458 if ( cmd != NULL) { 2459 start_logging(argv[2], pid); 2460 stressTest = true; 2461 2462 while (1) 2463 { 2464 if ( execute_functional_script(cmd) == 0 ) 2465 { 2466 break; 2467 } 2468 else 2469 { 2470 printf("CameraTest Restarting Camera...\n"); 2471 2472 free(cmd); 2473 cmd = NULL; 2474 2475 if ( (restartCamera() != 0) || ((cmd = load_script(argv[2])) == NULL) ) 2476 { 2477 printf("ERROR::CameraTest Restarting Camera...\n"); 2478 break; 2479 } 2480 } 2481 } 2482 free(cmd); 2483 stop_logging(pid); 2484 } 2485 } else if ( ( argc == 3) && ( ( *argv[1] == 'E' ) || ( *argv[1] == 'e') ) ) { 2486 2487 ProcessState::self()->startThreadPool(); 2488 2489 if ( openCamera() < 0 ) { 2490 printf("Camera initialization failed\n"); 2491 system("echo camerahal_test > /sys/power/wake_unlock"); 2492 return -1; 2493 } 2494 2495 initDefaults(); 2496 2497 cmd = load_script(argv[2]); 2498 2499 if ( cmd != NULL) { 2500 start_logging(argv[2], pid); 2501 execute_error_script(cmd); 2502 free(cmd); 2503 stop_logging(pid); 2504 } 2505 2506 } else { 2507 printf("INVALID OPTION USED\n"); 2508 print_usage(); 2509 } 2510 2511 gettimeofday(¤t_time, 0); 2512 end = current_time.tv_sec * 1000000 + current_time.tv_usec; 2513 delay = end - st; 2514 printf("Application clossed after: %llu ms\n", delay); 2515 system("echo camerahal_test > /sys/power/wake_unlock"); 2516 return 0; 2517} 2518