diff options
Diffstat (limited to 'test')
| -rw-r--r-- | test/CameraHal/Android.mk | 38 | ||||
| -rw-r--r-- | test/CameraHal/camera_test.h | 165 | ||||
| -rw-r--r-- | test/CameraHal/camera_test_menu.cpp | 2522 | ||||
| -rw-r--r-- | test/CameraHal/camera_test_script.cpp | 1373 |
4 files changed, 4098 insertions, 0 deletions
diff --git a/test/CameraHal/Android.mk b/test/CameraHal/Android.mk new file mode 100644 index 0000000..c7da48a --- /dev/null +++ b/test/CameraHal/Android.mk @@ -0,0 +1,38 @@ +LOCAL_PATH:= $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES:= \ + camera_test_menu.cpp \ + camera_test_script.cpp + +LOCAL_SHARED_LIBRARIES:= \ + libdl \ + libui \ + libutils \ + libcutils \ + libbinder \ + libmedia \ + libui \ + libgui \ + libcamera_client + +LOCAL_C_INCLUDES += \ + frameworks/base/include/ui \ + frameworks/base/include/surfaceflinger \ + frameworks/base/include/camera \ + frameworks/base/include/media \ + $(PV_INCLUDES) + +LOCAL_MODULE:= camera_test +LOCAL_MODULE_TAGS:= tests + +LOCAL_CFLAGS += -Wall -fno-short-enums -O0 -g -D___ANDROID___ + +ifeq ($(TARGET_BOARD_PLATFORM),omap4) + LOCAL_CFLAGS += -DTARGET_OMAP4 +endif + +include $(BUILD_HEAPTRACKED_EXECUTABLE) + + diff --git a/test/CameraHal/camera_test.h b/test/CameraHal/camera_test.h new file mode 100644 index 0000000..6ff8eb3 --- /dev/null +++ b/test/CameraHal/camera_test.h @@ -0,0 +1,165 @@ +#ifndef CAMERA_TEST_H +#define CAMERA_TEST_H + +#define PRINTOVER(arg...) LOGD(#arg) +#define LOG_FUNCTION_NAME LOGD("%d: %s() ENTER", __LINE__, __FUNCTION__); +#define LOG_FUNCTION_NAME_EXIT LOGD("%d: %s() EXIT", __LINE__, __FUNCTION__); +#define KEY_GBCE "gbce" +#define KEY_CAMERA "camera-index" +#define KEY_SATURATION "saturation" +#define KEY_BRIGHTNESS "brightness" +#define KEY_BURST "burst-capture" +#define KEY_EXPOSURE "exposure" +#define KEY_CONTRAST "contrast" +#define KEY_SHARPNESS "sharpness" +#define KEY_ISO "iso" +#define KEY_CAF "caf" +#define KEY_MODE "mode" +#define KEY_VNF "vnf" +#define KEY_VSTAB "vstab" +#define KEY_COMPENSATION "exposure-compensation" + +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) +#define KEY_IPP "ippMode" +#else +#define KEY_IPP "ipp" +#endif + +#define KEY_BUFF_STARV "buff-starvation" +#define KEY_METERING_MODE "meter-mode" +#define KEY_AUTOCONVERGENCE "auto-convergence" +#define KEY_MANUALCONVERGENCE_VALUES "manual-convergence-values" +#define AUTOCONVERGENCE_MODE_MANUAL "mode-manual" +#define KEY_EXP_BRACKETING_RANGE "exp-bracketing-range" +#define KEY_TEMP_BRACKETING "temporal-bracketing" +#define KEY_TEMP_BRACKETING_POS "temporal-bracketing-range-positive" +#define KEY_TEMP_BRACKETING_NEG "temporal-bracketing-range-negative" +#define KEY_MEASUREMENT "measurement" +#define KEY_S3D2D_PREVIEW_MODE "s3d2d-preview" +#define KEY_STEREO_CAMERA "s3d-supported" +#define KEY_EXIF_MODEL "exif-model" +#define KEY_EXIF_MAKE "exif-make" + +#define KEY_AUTO_EXPOSURE_LOCK "auto-exposure-lock" +#define KEY_AUTO_WHITEBALANCE_LOCK "auto-whitebalance-lock" + +#define SDCARD_PATH "/sdcard/" + +#define MAX_BURST 15 +#define BURST_INC 5 +#define TEMP_BRACKETING_MAX_RANGE 4 + +#define MEDIASERVER_DUMP "procmem -w $(ps | grep mediaserver | grep -Eo '[0-9]+' | head -n 1) | grep \"\\(Name\\|libcamera.so\\|libOMX\\|libomxcameraadapter.so\\|librcm.so\\|libnotify.so\\|libipcutils.so\\|libipc.so\\|libsysmgr.so\\|TOTAL\\)\"" +#define MEMORY_DUMP "procrank -u" +#define KEY_METERING_MODE "meter-mode" + +#define TEST_FOCUS_AREA "(0,0,1000,1000,300),(-1000,-1000,1000,1000,300),(0,0,0,0,0)" + +#define COMPENSATION_OFFSET 20 +#define DELIMITER "|" + +#define MAX_PREVIEW_SURFACE_WIDTH 800 +#define MAX_PREVIEW_SURFACE_HEIGHT 480 + +#define MODEL "camera_test" +#define MAKE "camera_test" + +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) + +namespace android { + class CameraHandler: public CameraListener { + public: + virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2); + virtual void postData(int32_t msgType, + const sp<IMemory>& dataPtr, + camera_frame_metadata_t *metadata); + + virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr); + }; + +}; + +using namespace android; + +char * get_cycle_cmd(const char *aSrc); +int execute_functional_script(char *script); +status_t dump_mem_status(); +int openCamera(); +int closeCamera(); +void initDefaults(); +int startPreview(); +void stopPreview(); +int startRecording(); +int stopRecording(); +int closeRecorder(); +int openRecorder(); +int configureRecorder(); +void printSupportedParams(); +char *load_script(char *config); +int start_logging(char *config, int &pid); +int stop_logging(int &pid); +int execute_error_script(char *script); + +typedef struct pixel_format_t { + int32_t pixelFormatDesc; + const char *pixformat; +}pixel_format; + +typedef struct output_format_t { + output_format type; + const char *desc; +} outformat; + +typedef struct preview_size_t { + int width, height; + const char *desc; +} preview_size; + +typedef struct Vcapture_size_t { + int width, height; + const char *desc; +} Vcapture_size; + +typedef struct capture_Size_t { + int width, height; + const char *name; +} capture_Size; + +typedef struct video_Codecs_t { + video_encoder type; + const char *desc; +} video_Codecs; + +typedef struct audio_Codecs_t { + audio_encoder type; + const char *desc; +} audio_Codecs; + +typedef struct V_bitRate_t { + uint32_t bit_rate; + const char *desc; +} V_bitRate; + +typedef struct zoom_t { + int idx; + const char *zoom_description; +} Zoom; + +typedef struct fps_ranges_t { + const char *range; + const char *rangeDescription; +} fps_ranges; + +typedef struct fpsConst_Ranges_t { + const char *range; + const char *rangeDescription; + int constFramerate; +} fpsConst_Ranges; + +typedef struct fpsConst_RangesSec_t { + const char *range; + const char *rangeDescription; + int constFramerate; +} fpsConst_RangesSec; + +#endif diff --git a/test/CameraHal/camera_test_menu.cpp b/test/CameraHal/camera_test_menu.cpp new file mode 100644 index 0000000..9bbf16a --- /dev/null +++ b/test/CameraHal/camera_test_menu.cpp @@ -0,0 +1,2522 @@ +#include <stdlib.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <time.h> +#include <semaphore.h> +#include <pthread.h> + +#include <surfaceflinger/Surface.h> +#include <surfaceflinger/ISurface.h> +#include <surfaceflinger/ISurfaceComposer.h> +#include <surfaceflinger/ISurfaceComposerClient.h> +#include <surfaceflinger/SurfaceComposerClient.h> + +#include <camera/Camera.h> +#include <camera/ICamera.h> +#include <media/mediarecorder.h> + +#include <binder/IPCThreadState.h> +#include <binder/ProcessState.h> +#include <binder/IServiceManager.h> +#include <cutils/properties.h> +#include <camera/CameraParameters.h> +#include <system/audio.h> +#include <system/camera.h> + +#include <cutils/memory.h> +#include <utils/Log.h> + +#include <sys/wait.h> + +#include "camera_test.h" + +using namespace android; + +int camera_index = 0; +int print_menu; +sp<Camera> camera; +sp<MediaRecorder> recorder; +sp<SurfaceComposerClient> client; +sp<SurfaceControl> surfaceControl; +sp<Surface> previewSurface; +CameraParameters params; +float compensation = 0.0; +double latitude = 0.0; +double longitude = 0.0; +double degree_by_step = 17.5609756;//..0975609756097; +double altitude = 0.0; +int awb_mode = 0; +int effects_mode = 0; +int scene_mode = 0; +int caf_mode = 0; +int vnf_mode = 0; +int vstab_mode = 0; + +int tempBracketRange = 1; +int tempBracketIdx = 0; +int measurementIdx = 0; +int expBracketIdx = 0; +int AutoConvergenceModeIDX = 0; +int ManualConvergenceValuesIDX = 0; +int ManualConvergenceDefaultValueIDX = 2; +int gbceIDX = 0; +int rotation = 0; +bool reSizePreview = true; +bool hardwareActive = false; +bool recordingMode = false; +bool previewRunning = false; +int saturation = 0; +int zoomIDX = 0; +int videoCodecIDX = 0; +int audioCodecIDX = 0; +int outputFormatIDX = 0; +int contrast = 0; +int brightness = 0; +unsigned int burst = 0; +int sharpness = 0; +int iso_mode = 0; +int capture_mode = 0; +int exposure_mode = 0; +int ippIDX = 0; +int ippIDX_old = 0; +int previewFormat = 0; +int jpegQuality = 85; +int thumbQuality = 85; +int flashIdx = 0; +int fpsRangeIdx = 0; +timeval autofocus_start, picture_start; +char script_name[80]; +int prevcnt = 0; +int videoFd = -1; +int elockidx = 0; +int wblockidx = 0; + + +char dir_path[80] = SDCARD_PATH; + +const char *cameras[] = {"Primary Camera", "Secondary Camera 1", "Stereo Camera", "USB Camera", "Fake Camera"}; +const char *measurement[] = {"disable", "enable"}; +const char *expBracketing[] = {"disable", "enable"}; +const char *expBracketingRange[] = {"", "-30,0,30,0,-30"}; +const char *tempBracketing[] = {"disable", "enable"}; +const char *faceDetection[] = {"disable", "enable"}; +const char *lock[] = {"false", "true"}; + +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) +const char *ipp_mode[] = { "off", "Chroma Suppression", "Edge Enhancement" }; +#else +const char *ipp_mode[] = { "off", "ldc", "nsf", "ldc-nsf" }; +#endif + +const char *iso [] = { "auto", "100", "200", "400", "800", "1200", "1600"}; + +const char *effects [] = { +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) + "none", + "mono", + "negative", + "solarize", + "sepia", + "whiteboard", + "blackboard", + "cool", + "emboss" +#else + "none", + "mono", + "negative", + "solarize", + "sepia", + "vivid", + "whiteboard", + "blackboard", + "cool", + "emboss", + "blackwhite", + "aqua", + "posterize" +#endif +}; + +const char CameraParameters::FLASH_MODE_OFF[] = "off"; +const char CameraParameters::FLASH_MODE_AUTO[] = "auto"; +const char CameraParameters::FLASH_MODE_ON[] = "on"; +const char CameraParameters::FLASH_MODE_RED_EYE[] = "red-eye"; +const char CameraParameters::FLASH_MODE_TORCH[] = "torch"; + +const char *flashModes[] = { + "off", + "auto", + "on", + "red-eye", + "torch", + "fill-in", +}; + +const char *caf [] = { "Off", "On" }; +const char *vnf [] = { "Off", "On" }; +const char *vstab [] = { "Off", "On" }; + + +const char *scene [] = { +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) + "auto", + "portrait", + "landscape", + "night", + "night-portrait", + "fireworks", + "snow", + "action", +#else + "auto", + "portrait", + "landscape", + "night", + "night-portrait", + "night-indoor", + "fireworks", + "sport", + "cine", + "beach", + "snow", + "mood", + "closeup", + "underwater", + "document", + "barcode", + "oldfilm", + "candlelight", + "party", + "steadyphoto", + "sunset", + "action", + "theatre" +#endif +}; +const char *strawb_mode[] = { + "auto", + "incandescent", + "fluorescent", + "daylight", + "horizon", + "shadow", + "tungsten", + "shade", + "twilight", + "warm-fluorescent", + "facepriority", + "sunset" +}; + +size_t length_cam = ARRAY_SIZE(cameras); + + +preview_size previewSize [] = { + { 0, 0, "NULL"}, + { 128, 96, "SQCIF" }, + { 176, 144, "QCIF" }, + { 352, 288, "CIF" }, + { 320, 240, "QVGA" }, + { 352, 288, "CIF" }, + { 640, 480, "VGA" }, + { 720, 480, "NTSC" }, + { 720, 576, "PAL" }, + { 800, 480, "WVGA" }, + { 848, 480, "WVGA2"}, + { 864, 480, "WVGA3"}, + { 992, 560, "WVGA4"}, + { 1280, 720, "HD" }, + { 1920, 1080, "FULLHD"}, +}; + +size_t length_previewSize = ARRAY_SIZE(previewSize); + +Vcapture_size VcaptureSize [] = { + { 128, 96, "SQCIF" }, + { 176, 144, "QCIF" }, + { 352, 288, "CIF" }, + { 320, 240, "QVGA" }, + { 640, 480, "VGA" }, + { 704, 480, "TVNTSC" }, + { 704, 576, "TVPAL" }, + { 720, 480, "D1NTSC" }, + { 720, 576, "D1PAL" }, + { 800, 480, "WVGA" }, + #if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) + { 848, 480, "WVGA2"}, + { 864, 480, "WVGA3"}, + { 992, 560, "WVGA4"}, + #endif + { 1280, 720, "HD" }, + { 1920, 1080, "FULLHD"}, +}; + +size_t lenght_Vcapture_size = ARRAY_SIZE(VcaptureSize); + +capture_Size captureSize[] = { + { 320, 240, "QVGA" }, + { 640, 480, "VGA" }, + { 800, 600, "SVGA" }, + { 1152, 864, "1MP" }, + { 1280, 1024, "1.3MP" }, + { 1600, 1200, "2MP" }, + { 2048, 1536, "3MP" }, + { 2592, 1944, "5MP" }, + { 2608, 1960, "5MP" }, + { 3264, 2448, "8MP" }, + { 3648, 2736, "10MP"}, + { 4032, 3024, "12MP"}, +}; + +size_t length_capture_Size = ARRAY_SIZE(captureSize); + + +outformat outputFormat[] = { + { OUTPUT_FORMAT_THREE_GPP, "3gp" }, + { OUTPUT_FORMAT_MPEG_4, "mp4" }, + }; + +size_t length_outformat = ARRAY_SIZE(outputFormat); + +video_Codecs videoCodecs[] = { + { VIDEO_ENCODER_H263, "H263" }, + { VIDEO_ENCODER_H264, "H264" }, + { VIDEO_ENCODER_MPEG_4_SP, "MPEG4"} +}; + +size_t length_video_Codecs = ARRAY_SIZE(videoCodecs); + +audio_Codecs audioCodecs[] = { + { AUDIO_ENCODER_AMR_NB, "AMR_NB" }, + { AUDIO_ENCODER_AMR_WB, "AMR_WB" }, + { AUDIO_ENCODER_AAC, "AAC" }, + { AUDIO_ENCODER_AAC_PLUS, "AAC+" }, + { AUDIO_ENCODER_EAAC_PLUS, "EAAC+" } +}; + +size_t length_audio_Codecs = ARRAY_SIZE(audioCodecs); + +V_bitRate VbitRate[] = { + { 64000, "64K" }, + { 128000, "128K" }, + { 192000, "192K" }, + { 240000, "240K" }, + { 320000, "320K" }, + { 360000, "360K" }, + { 384000, "384K" }, + { 420000, "420K" }, + { 768000, "768K" }, + { 1000000, "1M" }, + { 1500000, "1.5M" }, + { 2000000, "2M" }, + { 4000000, "4M" }, + { 6000000, "6M" }, + { 8000000, "8M" }, + { 10000000, "10M" }, +}; + +size_t length_V_bitRate = ARRAY_SIZE(VbitRate); + +Zoom zoom[] = { + { 0, "1x" }, + { 12, "1.5x"}, + { 20, "2x" }, + { 27, "2.5x"}, + { 32, "3x" }, + { 36, "3.5x"}, + { 40, "4x" }, + { 60, "8x" }, +}; + +size_t length_Zoom = ARRAY_SIZE(zoom); + +fps_ranges fpsRanges[] = { + { "5000,30000", "[5:30]" }, + { "5000,10000", "[5:10]" }, + { "5000,15000", "[5:15]" }, + { "5000,20000", "[5:20]" }, +}; + +size_t length_fps_ranges = ARRAY_SIZE(fpsRanges); + +fpsConst_Ranges fpsConstRanges[] = { + { "5000,5000", "[5:5]", 5 }, + { "10000,10000", "[10:10]", 10 }, + { "15000,15000", "[15:15]", 15 }, + { "20000,20000", "[20:20]", 20 }, + { "25000,25000", "[25:25]", 25 }, + { "30000,30000", "[30:30]", 30 }, +}; + +size_t length_fpsConst_Ranges = ARRAY_SIZE(fpsConstRanges); + +fpsConst_RangesSec fpsConstRangesSec[] = { + { "5000,5000", "[5:5]", 5 }, + { "10000,10000", "[10:10]", 10 }, + { "15000,15000", "[15:15]", 15 }, + { "20000,20000", "[20:20]", 20 }, + { "25000,25000", "[25:25]", 25 }, + { "27000,27000", "[27:27]", 27 }, +}; + +size_t length_fpsConst_RangesSec = ARRAY_SIZE(fpsConstRangesSec); + +const char *antibanding[] = { + "off", + "auto", + "50hz", + "60hz", +}; +int antibanding_mode = 0; +const char *focus[] = { + "auto", + "infinity", + "macro", + "continuous-video", + "extended", + "portrait", +}; +int focus_mode = 0; +pixel_format pixelformat[] = { + { HAL_PIXEL_FORMAT_YCbCr_422_I, CameraParameters::PIXEL_FORMAT_YUV422I }, + { HAL_PIXEL_FORMAT_YCrCb_420_SP, CameraParameters::PIXEL_FORMAT_YUV420SP }, + { HAL_PIXEL_FORMAT_RGB_565, CameraParameters::PIXEL_FORMAT_RGB565 }, + { -1, CameraParameters::PIXEL_FORMAT_JPEG }, + { -1, "raw" }, + }; + +const char *codingformat[] = {"yuv422i-yuyv", "yuv420sp", "rgb565", "jpeg", "raw", "jps", "mpo", "raw+jpeg", "raw+mpo"}; +const char *gbce[] = {"disable", "enable"}; +int pictureFormat = 3; // jpeg +const char *exposure[] = {"auto", "macro", "portrait", "landscape", "sports", "night", "night-portrait", "backlighting", "manual"}; +const char *capture[] = { "high-performance", "high-quality", "video-mode" }; +const char *autoconvergencemode[] = { "mode-disable", "mode-frame", "mode-center", "mode-fft", "mode-manual" }; +const char *manualconvergencevalues[] = { "-100", "-50", "-30", "-25", "0", "25", "50", "100" }; + +const struct { + int fps; +} frameRate[] = { + {0}, + {5}, + {10}, + {15}, + {20}, + {25}, + {30} +}; + +int thumbSizeIDX = 3; +int previewSizeIDX = ARRAY_SIZE(previewSize) - 1; +int captureSizeIDX = ARRAY_SIZE(captureSize) - 1; +int frameRateIDX = ARRAY_SIZE(fpsConstRanges) - 1; +int frameRateIDXSec = ARRAY_SIZE(fpsConstRangesSec) - 1; +int VcaptureSizeIDX = ARRAY_SIZE(VcaptureSize) - 1; +int VbitRateIDX = ARRAY_SIZE(VbitRate) - 1; + +static unsigned int recording_counter = 1; + +int dump_preview = 0; +int bufferStarvationTest = 0; +bool showfps = false; + +const char *metering[] = { + "center", + "average", +}; +int meter_mode = 0; +bool bLogSysLinkTrace = true; +bool stressTest = false; +bool stopScript = false; +int restartCount = 0; + +/** Calculate delay from a reference time */ +unsigned long long timeval_delay(const timeval *ref) { + unsigned long long st, end, delay; + timeval current_time; + + gettimeofday(¤t_time, 0); + + st = ref->tv_sec * 1000000 + ref->tv_usec; + end = current_time.tv_sec * 1000000 + current_time.tv_usec; + delay = end - st; + + return delay; +} + +/** Callback for takePicture() */ +void my_raw_callback(const sp<IMemory>& mem) { + + static int counter = 1; + unsigned char *buff = NULL; + int size; + int fd = -1; + char fn[256]; + + LOG_FUNCTION_NAME; + + if (mem == NULL) + goto out; + + //Start preview after capture. + camera->startPreview(); + + fn[0] = 0; + sprintf(fn, "/sdcard/img%03d.raw", counter); + fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777); + + if (fd < 0) + goto out; + + size = mem->size(); + + if (size <= 0) + goto out; + + buff = (unsigned char *)mem->pointer(); + + if (!buff) + goto out; + + if (size != write(fd, buff, size)) + printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno)); + + counter++; + printf("%s: buffer=%08X, size=%d stored at %s\n", + __FUNCTION__, (int)buff, size, fn); + +out: + + if (fd >= 0) + close(fd); + + LOG_FUNCTION_NAME_EXIT; +} + +void saveFile(const sp<IMemory>& mem) { + static int counter = 1; + unsigned char *buff = NULL; + int size; + int fd = -1; + char fn[256]; + + LOG_FUNCTION_NAME; + + if (mem == NULL) + goto out; + + fn[0] = 0; + sprintf(fn, "/sdcard/preview%03d.yuv", counter); + fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777); + if(fd < 0) { + LOGE("Unable to open file %s: %s", fn, strerror(fd)); + goto out; + } + + size = mem->size(); + if (size <= 0) { + LOGE("IMemory object is of zero size"); + goto out; + } + + buff = (unsigned char *)mem->pointer(); + if (!buff) { + LOGE("Buffer pointer is invalid"); + goto out; + } + + if (size != write(fd, buff, size)) + printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno)); + + counter++; + printf("%s: buffer=%08X, size=%d\n", + __FUNCTION__, (int)buff, size); + +out: + + if (fd >= 0) + close(fd); + + LOG_FUNCTION_NAME_EXIT; +} + + +void debugShowFPS() +{ + static int mFrameCount = 0; + static int mLastFrameCount = 0; + static nsecs_t mLastFpsTime = 0; + static float mFps = 0; + mFrameCount++; + if ( ( mFrameCount % 30 ) == 0 ) { + nsecs_t now = systemTime(); + nsecs_t diff = now - mLastFpsTime; + mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; + mLastFpsTime = now; + mLastFrameCount = mFrameCount; + printf("####### [%d] Frames, %f FPS", mFrameCount, mFps); + } +} + +/** Callback for startPreview() */ +void my_preview_callback(const sp<IMemory>& mem) { + + printf("PREVIEW Callback 0x%x", ( unsigned int ) mem->pointer()); + if (dump_preview) { + + if(prevcnt==50) + saveFile(mem); + + prevcnt++; + + uint8_t *ptr = (uint8_t*) mem->pointer(); + + 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]); + + } + + debugShowFPS(); +} + +/** Callback for takePicture() */ +void my_jpeg_callback(const sp<IMemory>& mem) { + static int counter = 1; + unsigned char *buff = NULL; + int size; + int fd = -1; + char fn[256]; + + LOG_FUNCTION_NAME; + + //Start preview after capture. + camera->startPreview(); + + if (mem == NULL) + goto out; + + fn[0] = 0; + sprintf(fn, "%s/img%03d.jpg", dir_path,counter); + fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777); + + if(fd < 0) { + LOGE("Unable to open file %s: %s", fn, strerror(fd)); + goto out; + } + + size = mem->size(); + if (size <= 0) { + LOGE("IMemory object is of zero size"); + goto out; + } + + buff = (unsigned char *)mem->pointer(); + if (!buff) { + LOGE("Buffer pointer is invalid"); + goto out; + } + + if (size != write(fd, buff, size)) + printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno)); + + counter++; + printf("%s: buffer=%08X, size=%d stored at %s\n", + __FUNCTION__, (int)buff, size, fn); + +out: + + if (fd >= 0) + close(fd); + + LOG_FUNCTION_NAME_EXIT; +} + +void my_face_callback(camera_frame_metadata_t *metadata) { + int idx; + + if ( NULL == metadata ) { + return; + } + + for ( idx = 0 ; idx < metadata->number_of_faces ; idx++ ) { + printf("Face %d at %d,%d %d,%d \n", + idx, + metadata->faces[idx].rect[0], + metadata->faces[idx].rect[1], + metadata->faces[idx].rect[2], + metadata->faces[idx].rect[3]); + } + +} + +void CameraHandler::notify(int32_t msgType, int32_t ext1, int32_t ext2) { + + printf("Notify cb: %d %d %d\n", msgType, ext1, ext2); + + if ( msgType & CAMERA_MSG_FOCUS ) + printf("AutoFocus %s in %llu us\n", (ext1) ? "OK" : "FAIL", timeval_delay(&autofocus_start)); + + if ( msgType & CAMERA_MSG_SHUTTER ) + printf("Shutter done in %llu us\n", timeval_delay(&picture_start)); + + if ( msgType & CAMERA_MSG_ERROR && (ext1 == 1)) + { + printf("Camera Test CAMERA_MSG_ERROR.....\n"); + if (stressTest) + { + printf("Camera Test Notified of Error Restarting.....\n"); + stopScript = true; + } + else + { + printf("Camera Test Notified of Error Stopping.....\n"); + stopScript =false; + stopPreview(); + + if (recordingMode) + { + stopRecording(); + closeRecorder(); + recordingMode = false; + } + } + } +} + +void CameraHandler::postData(int32_t msgType, + const sp<IMemory>& dataPtr, + camera_frame_metadata_t *metadata) { + printf("Data cb: %d\n", msgType); + + if ( msgType & CAMERA_MSG_PREVIEW_FRAME ) + my_preview_callback(dataPtr); + + if ( msgType & CAMERA_MSG_RAW_IMAGE ) { + printf("RAW done in %llu us\n", timeval_delay(&picture_start)); + my_raw_callback(dataPtr); + } + + if (msgType & CAMERA_MSG_POSTVIEW_FRAME) { + printf("Postview frame %llu us\n", timeval_delay(&picture_start)); + } + + if (msgType & CAMERA_MSG_COMPRESSED_IMAGE ) { + printf("JPEG done in %llu us\n", timeval_delay(&picture_start)); + my_jpeg_callback(dataPtr); + } + + if ( ( msgType & CAMERA_MSG_PREVIEW_METADATA ) && + ( NULL != metadata ) ) { + printf("Face detected %d \n", metadata->number_of_faces); + my_face_callback(metadata); + } +} + +void CameraHandler::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) + +{ + printf("Recording cb: %d %lld %p\n", msgType, timestamp, dataPtr.get()); + + static uint32_t count = 0; + + //if(count==100) + //saveFile(dataPtr); + + count++; + + uint8_t *ptr = (uint8_t*) dataPtr->pointer(); + + 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]); + + camera->releaseRecordingFrame(dataPtr); +} + +int createPreviewSurface(unsigned int width, unsigned int height, int32_t pixFormat) { + unsigned int previewWidth, previewHeight; + + if ( MAX_PREVIEW_SURFACE_WIDTH < width ) { + previewWidth = MAX_PREVIEW_SURFACE_WIDTH; + } else { + previewWidth = width; + } + + if ( MAX_PREVIEW_SURFACE_HEIGHT < height ) { + previewHeight = MAX_PREVIEW_SURFACE_HEIGHT; + } else { + previewHeight = height; + } + + client = new SurfaceComposerClient(); + + if ( NULL == client.get() ) { + printf("Unable to establish connection to Surface Composer \n"); + + return -1; + } + + surfaceControl = client->createSurface(0, + previewWidth, + previewHeight, + pixFormat); + + previewSurface = surfaceControl->getSurface(); + + client->openGlobalTransaction(); + surfaceControl->setLayer(100000); + surfaceControl->setPosition(0, 0); + surfaceControl->setSize(previewWidth, previewHeight); + surfaceControl->show(); + client->closeGlobalTransaction(); + + return 0; +} + +void printSupportedParams() +{ + printf("\n\r\tSupported Cameras: %s", params.get("camera-indexes")); + printf("\n\r\tSupported Picture Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES)); + printf("\n\r\tSupported Picture Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS)); + printf("\n\r\tSupported Preview Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES)); + printf("\n\r\tSupported Preview Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS)); + printf("\n\r\tSupported Preview Frame Rates: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES)); + printf("\n\r\tSupported Thumbnail Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES)); + printf("\n\r\tSupported Whitebalance Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE)); + printf("\n\r\tSupported Effects: %s", params.get(CameraParameters::KEY_SUPPORTED_EFFECTS)); + printf("\n\r\tSupported Scene Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES)); + printf("\n\r\tSupported Focus Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES)); + printf("\n\r\tSupported Antibanding Options: %s", params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING)); + printf("\n\r\tSupported Flash Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES)); + printf("\n\r\tSupported Focus Areas: %d", params.getInt(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS)); + + if ( NULL != params.get(CameraParameters::KEY_FOCUS_DISTANCES) ) { + printf("\n\r\tFocus Distances: %s \n", params.get(CameraParameters::KEY_FOCUS_DISTANCES)); + } + + return; +} + + +int destroyPreviewSurface() { + + if ( NULL != previewSurface.get() ) { + previewSurface.clear(); + } + + if ( NULL != surfaceControl.get() ) { + surfaceControl->clear(); + surfaceControl.clear(); + } + + if ( NULL != client.get() ) { + client->dispose(); + client.clear(); + } + + return 0; +} + +int openRecorder() { + recorder = new MediaRecorder(); + + if ( NULL == recorder.get() ) { + printf("Error while creating MediaRecorder\n"); + + return -1; + } + + return 0; +} + +int closeRecorder() { + if ( NULL == recorder.get() ) { + printf("invalid recorder reference\n"); + + return -1; + } + + if ( recorder->init() < 0 ) { + printf("recorder failed to initialize\n"); + + return -1; + } + + if ( recorder->close() < 0 ) { + printf("recorder failed to close\n"); + + return -1; + } + + if ( recorder->release() < 0 ) { + printf("error while releasing recorder\n"); + + return -1; + } + + recorder.clear(); + + return 0; +} + +int configureRecorder() { + + char videoFile[256],vbit_string[50]; + videoFd = -1; + + if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) { + printf("invalid recorder and/or camera references\n"); + + return -1; + } + + camera->unlock(); + + sprintf(vbit_string,"video-param-encoding-bitrate=%u", VbitRate[VbitRateIDX].bit_rate); + String8 bit_rate(vbit_string); + if ( recorder->setParameters(bit_rate) < 0 ) { + printf("error while configuring bit rate\n"); + + return -1; + } + + if ( recorder->setCamera(camera->remote(), camera->getRecordingProxy()) < 0 ) { + printf("error while setting the camera\n"); + + return -1; + } + + if ( recorder->setVideoSource(VIDEO_SOURCE_CAMERA) < 0 ) { + printf("error while configuring camera video source\n"); + + return -1; + } + + + if ( recorder->setAudioSource(AUDIO_SOURCE_MIC) < 0 ) { + printf("error while configuring camera audio source\n"); + + return -1; + } + + if ( recorder->setOutputFormat(outputFormat[outputFormatIDX].type) < 0 ) { + printf("error while configuring output format\n"); + + return -1; + } + + if(mkdir("/mnt/sdcard/videos",0777) == -1) + printf("\n Directory --videos-- was not created \n"); + sprintf(videoFile, "/mnt/sdcard/videos/video%d.%s", recording_counter,outputFormat[outputFormatIDX].desc); + + videoFd = open(videoFile, O_CREAT | O_RDWR); + + if(videoFd < 0){ + printf("Error while creating video filename\n"); + + return -1; + } + + if ( recorder->setOutputFile(videoFd, 0, 0) < 0 ) { + printf("error while configuring video filename\n"); + + return -1; + } + + recording_counter++; + + if (camera_index == 0) { + if ( recorder->setVideoFrameRate(fpsConstRanges[frameRateIDX].constFramerate) < 0 ) { + printf("error while configuring video framerate\n"); + return -1; + } + } + else { + if ( recorder->setVideoFrameRate(fpsConstRangesSec[frameRateIDXSec].constFramerate) < 0 ) { + printf("error while configuring video framerate\n"); + return -1; + } + } + + if ( recorder->setVideoSize(VcaptureSize[VcaptureSizeIDX].width, VcaptureSize[VcaptureSizeIDX].height) < 0 ) { + printf("error while configuring video size\n"); + + return -1; + } + + if ( recorder->setVideoEncoder(videoCodecs[videoCodecIDX].type) < 0 ) { + printf("error while configuring video codec\n"); + + return -1; + } + + if ( recorder->setAudioEncoder(audioCodecs[audioCodecIDX].type) < 0 ) { + printf("error while configuring audio codec\n"); + + return -1; + } + + if ( recorder->setPreviewSurface( surfaceControl->getSurface() ) < 0 ) { + printf("error while configuring preview surface\n"); + + return -1; + } + + return 0; +} + +int startRecording() { + if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) { + printf("invalid recorder and/or camera references\n"); + + return -1; + } + + camera->unlock(); + + if ( recorder->prepare() < 0 ) { + printf("recorder prepare failed\n"); + + return -1; + } + + if ( recorder->start() < 0 ) { + printf("recorder start failed\n"); + + return -1; + } + + return 0; +} + +int stopRecording() { + if ( NULL == recorder.get() ) { + printf("invalid recorder reference\n"); + + return -1; + } + + if ( recorder->stop() < 0 ) { + printf("recorder failed to stop\n"); + + return -1; + } + + if ( 0 < videoFd ) { + close(videoFd); + } + + return 0; +} + +int openCamera() { + printf("openCamera(camera_index=%d)\n", camera_index); + camera = Camera::connect(camera_index); + + if ( NULL == camera.get() ) { + printf("Unable to connect to CameraService\n"); + printf("Retrying... \n"); + sleep(1); + camera = Camera::connect(camera_index); + + if ( NULL == camera.get() ) { + printf("Giving up!! \n"); + return -1; + } + } + + params = camera->getParameters(); + camera->setParameters(params.flatten()); + + camera->setListener(new CameraHandler()); + + hardwareActive = true; + + return 0; +} + +int closeCamera() { + if ( NULL == camera.get() ) { + printf("invalid camera reference\n"); + + return -1; + } + + camera->disconnect(); + camera.clear(); + + hardwareActive = false; + + return 0; +} + +//Workaround for an issue seen with ICS SurfaceFlinger. +//The last surface created is not getting rendered on screen, +//in our case this is the preview surface. Here we artificially wait +//for the preview to start and create a new temporary surface, which +//gets destroyed immediately. +int surfaceWorkaround(unsigned int width, unsigned int height, int32_t pixFormat) { + sleep(1); + + if ( NULL == client.get() ) { + return NO_INIT; + } + + sp<SurfaceControl> tmpSurface = client->createSurface(0, + width, + height, + pixFormat); + + if ( NULL != tmpSurface.get() ) { + tmpSurface->clear(); + tmpSurface.clear(); + } else { + return -ENOMEM; + } + + return NO_ERROR; +} + +int startPreview() { + int previewWidth, previewHeight; + if (reSizePreview) { + + if(recordingMode) + { + previewWidth = VcaptureSize[VcaptureSizeIDX].width; + previewHeight = VcaptureSize[VcaptureSizeIDX].height; + }else + { + previewWidth = previewSize[previewSizeIDX].width; + previewHeight = previewSize[previewSizeIDX].height; + } + + if ( createPreviewSurface(previewWidth, + previewHeight, + pixelformat[previewFormat].pixelFormatDesc) < 0 ) { + printf("Error while creating preview surface\n"); + return -1; + } + + if ( !hardwareActive ) { + openCamera(); + } + + params.setPreviewSize(previewWidth, previewHeight); + params.setPictureSize(captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height); + + camera->setParameters(params.flatten()); + camera->setPreviewDisplay(previewSurface); + + if(!hardwareActive) prevcnt = 0; + + camera->startPreview(); + + previewRunning = true; + reSizePreview = false; + + surfaceWorkaround( previewWidth, previewHeight, pixelformat[previewFormat].pixelFormatDesc); + } + + return 0; +} + +void stopPreview() { + if ( hardwareActive ) { + camera->stopPreview(); + + destroyPreviewSurface(); + + previewRunning = false; + reSizePreview = true; + closeCamera(); + } +} + +void initDefaults() { + camera_index = 0; + antibanding_mode = 0; + focus_mode = 0; + fpsRangeIdx = 0; + previewSizeIDX = 1; /* Default resolution set to WVGA */ + captureSizeIDX = 3; /* Default capture resolution is 8MP */ + frameRateIDX = ARRAY_SIZE(fpsConstRanges) - 1; /* Default frame rate is 30 FPS */ +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) + VcaptureSizeIDX = ARRAY_SIZE(VcaptureSize) - 6;/* Default video record is WVGA */ +#else + VcaptureSizeIDX = ARRAY_SIZE(VcaptureSize) - 2;/* Default video record is WVGA */ +#endif + VbitRateIDX = ARRAY_SIZE(VbitRate) - 4; /*Default video bit rate is 4M */ + thumbSizeIDX = 0; + compensation = 0.0; + awb_mode = 0; + effects_mode = 0; + scene_mode = 0; + caf_mode = 0; + vnf_mode = 0; + vstab_mode = 0; + expBracketIdx = 0; + flashIdx = 0; + rotation = 0; + zoomIDX = 0; + videoCodecIDX = 0; + gbceIDX = 0; +#ifdef TARGET_OMAP4 + ///Temporary fix until OMAP3 and OMAP4 3A values are synced + contrast = 90; + brightness = 50; + sharpness = 0; + saturation = 50; +#else + contrast = 100; + brightness = 100; + sharpness = 0; + saturation = 100; +#endif + iso_mode = 0; + capture_mode = 0; + exposure_mode = 0; + ippIDX = 0;//set the ipp to ldc-nsf as the capture mode is set to HQ by default + ippIDX_old = ippIDX; + jpegQuality = 85; + bufferStarvationTest = 0; + meter_mode = 0; + previewFormat = 1; + pictureFormat = 3; // jpeg + params.setPreviewSize(previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height); + params.setPictureSize(captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height); + params.set(CameraParameters::KEY_ROTATION, rotation); + params.set(KEY_COMPENSATION, (int) (compensation * 10)); + params.set(params.KEY_WHITE_BALANCE, strawb_mode[awb_mode]); + params.set(KEY_MODE, (capture[capture_mode])); + params.set(params.KEY_SCENE_MODE, scene[scene_mode]); + params.set(KEY_CAF, caf_mode); + params.set(KEY_ISO, iso_mode); + params.set(KEY_GBCE, gbce[gbceIDX]); + params.set(KEY_SHARPNESS, sharpness); + params.set(KEY_CONTRAST, contrast); + params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx); + params.set(KEY_EXPOSURE, exposure[exposure_mode]); + params.set(KEY_BRIGHTNESS, brightness); + params.set(KEY_SATURATION, saturation); + params.set(params.KEY_EFFECT, effects[effects_mode]); + params.setPreviewFrameRate(frameRate[ARRAY_SIZE(frameRate) - 1].fps); + params.set(params.KEY_ANTIBANDING, antibanding[antibanding_mode]); + params.set(params.KEY_FOCUS_MODE, focus[focus_mode]); + params.set(KEY_IPP, ippIDX); + params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality); + params.setPreviewFormat(pixelformat[previewFormat].pixformat); + params.setPictureFormat(codingformat[pictureFormat]); + params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation + params.set(KEY_METERING_MODE, metering[meter_mode]); + params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, previewSize[thumbSizeIDX].width); + params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, previewSize[thumbSizeIDX].height); + ManualConvergenceValuesIDX = ManualConvergenceDefaultValueIDX; + params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceValuesIDX]); + params.set(KEY_S3D2D_PREVIEW_MODE, "off"); + params.set(KEY_STEREO_CAMERA, "false"); + params.set(KEY_EXIF_MODEL, MODEL); + params.set(KEY_EXIF_MAKE, MAKE); +} + +int menu_gps() { + char ch; + char coord_str[100]; + + if (print_menu) { + printf("\n\n== GPS MENU ============================\n\n"); + printf(" e. Latitude: %.7lf\n", latitude); + printf(" d. Longitude: %.7lf\n", longitude); + printf(" c. Altitude: %.7lf\n", altitude); + printf("\n"); + printf(" q. Return to main menu\n"); + printf("\n"); + printf(" Choice: "); + } + + ch = getchar(); + printf("%c", ch); + + print_menu = 1; + + switch (ch) { + + case 'e': + latitude += degree_by_step; + + if (latitude > 90.0) { + latitude -= 180.0; + } + + snprintf(coord_str, 7, "%.7lf", latitude); + params.set(params.KEY_GPS_LATITUDE, coord_str); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'd': + longitude += degree_by_step; + + if (longitude > 180.0) { + longitude -= 360.0; + } + + snprintf(coord_str, 7, "%.7lf", longitude); + params.set(params.KEY_GPS_LONGITUDE, coord_str); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'c': + altitude += 12345.67890123456789; + + if (altitude > 100000.0) { + altitude -= 200000.0; + } + + snprintf(coord_str, 100, "%.20lf", altitude); + params.set(params.KEY_GPS_ALTITUDE, coord_str); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'Q': + case 'q': + return -1; + + default: + print_menu = 0; + break; + } + + return 0; +} + +int functional_menu() { + char ch; + + if (print_menu) { + + printf("\n\n=========== FUNCTIONAL TEST MENU ===================\n\n"); + + printf(" \n\nSTART / STOP / GENERAL SERVICES \n"); + printf(" -----------------------------\n"); + printf(" A Select Camera %s\n", cameras[camera_index]); + printf(" [. Resume Preview after capture\n"); + printf(" 0. Reset to defaults\n"); + printf(" q. Quit\n"); + printf(" @. Disconnect and Reconnect to CameraService \n"); + printf(" /. Enable/Disable showfps: %s\n", ((showfps)? "Enabled":"Disabled")); + printf(" a. GEO tagging settings menu\n"); + printf(" E. Camera Capability Dump"); + + + printf(" \n\n PREVIEW SUB MENU \n"); + printf(" -----------------------------\n"); + printf(" 1. Start Preview\n"); + printf(" 2. Stop Preview\n"); + printf(" ~. Preview format %s\n", pixelformat[previewFormat].pixformat); +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) + printf(" 4. Preview size: %4d x %4d - %s\n",previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height, previewSize[previewSizeIDX].desc); +#else + 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); +#endif + printf(" R. Preview framerate range: %s\n", fpsRanges[fpsRangeIdx].rangeDescription); + printf(" &. Dump a preview frame\n"); + printf(" _. Auto Convergence mode: %s\n", autoconvergencemode[AutoConvergenceModeIDX]); + printf(" ^. Manual Convergence Value: %s\n", manualconvergencevalues[ManualConvergenceValuesIDX]); + printf(" {. 2D Preview in 3D Stereo Mode: %s\n", params.get(KEY_S3D2D_PREVIEW_MODE)); + + printf(" \n\n IMAGE CAPTURE SUB MENU \n"); + printf(" -----------------------------\n"); + printf(" p. Take picture/Full Press\n"); + printf(" H. Exposure Bracketing: %s\n", expBracketing[expBracketIdx]); + printf(" U. Temporal Bracketing: %s\n", tempBracketing[tempBracketIdx]); + printf(" W. Temporal Bracketing Range: [-%d;+%d]\n", tempBracketRange, tempBracketRange); + printf(" $. Picture Format: %s\n", codingformat[pictureFormat]); + printf(" 3. Picture Rotation: %3d degree\n", rotation ); + printf(" 5. Picture size: %4d x %4d - %s\n",captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height, captureSize[captureSizeIDX].name); + printf(" i. ISO mode: %s\n", iso[iso_mode]); + printf(" u. Capture Mode: %s\n", capture[capture_mode]); + printf(" k. IPP Mode: %s\n", ipp_mode[ippIDX]); + printf(" K. GBCE: %s\n", gbce[gbceIDX]); + printf(" o. Jpeg Quality: %d\n", jpegQuality); + printf(" #. Burst Images: %3d\n", burst); + printf(" :. Thumbnail Size: %4d x %4d - %s\n",previewSize[thumbSizeIDX].width, previewSize[thumbSizeIDX].height, previewSize[thumbSizeIDX].desc); + printf(" ': Thumbnail Quality %d\n", thumbQuality); + + printf(" \n\n VIDEO CAPTURE SUB MENU \n"); + printf(" -----------------------------\n"); + + printf(" 6. Start Video Recording\n"); + printf(" 2. Stop Recording\n"); + printf(" l. Video Capture resolution: %4d x %4d - %s\n",VcaptureSize[VcaptureSizeIDX].width,VcaptureSize[VcaptureSizeIDX].height, VcaptureSize[VcaptureSizeIDX].desc); + printf(" ]. Video Bit rate : %s\n", VbitRate[VbitRateIDX].desc); + printf(" 9. Video Codec: %s\n", videoCodecs[videoCodecIDX].desc); + printf(" D. Audio Codec: %s\n", audioCodecs[audioCodecIDX].desc); + printf(" v. Output Format: %s\n", outputFormat[outputFormatIDX].desc); + + if (camera_index == 1) { + printf(" r. Framerate: %d\n", fpsConstRangesSec[frameRateIDXSec].constFramerate); + } + else { + printf(" r. Framerate: %d\n", fpsConstRanges[frameRateIDX].constFramerate); + } + printf(" *. Start Video Recording dump ( 1 raw frame ) \n"); + printf(" B VNF %s \n", vnf[vnf_mode]); + printf(" C VSTAB %s", vstab[vstab_mode]); + + printf(" \n\n 3A SETTING SUB MENU \n"); + printf(" -----------------------------\n"); + + printf(" M. Measurement Data: %s\n", measurement[measurementIdx]); + printf(" F. Start face detection \n"); + printf(" T. Stop face detection \n"); + printf(" G. Touch/Focus area AF\n"); + printf(" f. Auto Focus/Half Press\n"); + printf(" J.Flash: %s\n", flashModes[flashIdx]); + printf(" 7. EV offset: %4.1f\n", compensation); + printf(" 8. AWB mode: %s\n", strawb_mode[awb_mode]); + printf(" z. Zoom %s\n", zoom[zoomIDX].zoom_description); + printf(" j. Exposure %s\n", exposure[exposure_mode]); + printf(" e. Effect: %s\n", effects[effects_mode]); + printf(" w. Scene: %s\n", scene[scene_mode]); + printf(" s. Saturation: %d\n", saturation); + printf(" c. Contrast: %d\n", contrast); + printf(" h. Sharpness: %d\n", sharpness); + printf(" b. Brightness: %d\n", brightness); + printf(" x. Antibanding: %s\n", antibanding[antibanding_mode]); + printf(" g. Focus mode: %s\n", focus[focus_mode]); + printf(" m. Metering mode: %s\n" , metering[meter_mode]); + printf(" <. Exposure Lock: %s\n", lock[elockidx]); + printf(" >. WhiteBalance Lock: %s\n",lock[wblockidx]); + printf("\n"); + printf(" Choice: "); + } + + ch = getchar(); + printf("%c", ch); + + print_menu = 1; + + switch (ch) { + + case '_': + AutoConvergenceModeIDX++; + AutoConvergenceModeIDX %= ARRAY_SIZE(autoconvergencemode); + params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]); + if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) { + params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceValuesIDX]); + } + else { + params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceDefaultValueIDX]); + ManualConvergenceValuesIDX = ManualConvergenceDefaultValueIDX; + } + camera->setParameters(params.flatten()); + + break; + case '^': + if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) { + ManualConvergenceValuesIDX++; + ManualConvergenceValuesIDX %= ARRAY_SIZE(manualconvergencevalues); + params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceValuesIDX]); + camera->setParameters(params.flatten()); + } + break; + case 'A': + camera_index++; + camera_index %= ARRAY_SIZE(cameras); + if ( camera_index == 2) { + params.set(KEY_STEREO_CAMERA, "true"); + } else { + params.set(KEY_STEREO_CAMERA, "false"); + } + closeCamera(); + + openCamera(); + + if (camera_index == 0) { + params.setPreviewFrameRate(30); + } else { + params.setPreviewFrameRate(27); + } + + + break; + case '[': + if ( hardwareActive ) { + camera->setParameters(params.flatten()); + camera->startPreview(); + } + break; + + case '0': + initDefaults(); + break; + + case '1': + + if ( startPreview() < 0 ) { + printf("Error while starting preview\n"); + + return -1; + } + + break; + + case '2': + stopPreview(); + + if ( recordingMode ) { + camera->disconnect(); + camera.clear(); + stopRecording(); + closeRecorder(); + + camera = Camera::connect(camera_index); + if ( NULL == camera.get() ) { + sleep(1); + camera = Camera::connect(camera_index); + if ( NULL == camera.get() ) { + return -1; + } + } + camera->setListener(new CameraHandler()); + camera->setParameters(params.flatten()); + recordingMode = false; + } + + break; + + case '3': + rotation += 90; + rotation %= 360; + params.set(CameraParameters::KEY_ROTATION, rotation); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '4': + previewSizeIDX += 1; + previewSizeIDX %= ARRAY_SIZE(previewSize); + if ( strcmp(params.get(KEY_STEREO_CAMERA), "false") == 0 ) { + params.setPreviewSize(previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height); + } else { + params.setPreviewSize(previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height*2); + } + reSizePreview = true; + + if ( hardwareActive && previewRunning ) { + camera->stopPreview(); + camera->setParameters(params.flatten()); + camera->startPreview(); + } else if ( hardwareActive ) { + camera->setParameters(params.flatten()); + } + + break; + + case '5': + captureSizeIDX += 1; + captureSizeIDX %= ARRAY_SIZE(captureSize); + params.setPictureSize(captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'l': + case 'L': + VcaptureSizeIDX++; + VcaptureSizeIDX %= ARRAY_SIZE(VcaptureSize); + break; + + case ']': + VbitRateIDX++; + VbitRateIDX %= ARRAY_SIZE(VbitRate); + break; + + + case '6': + + if ( !recordingMode ) { + + recordingMode = true; + + if ( startPreview() < 0 ) { + printf("Error while starting preview\n"); + + return -1; + } + + if ( openRecorder() < 0 ) { + printf("Error while openning video recorder\n"); + + return -1; + } + + if ( configureRecorder() < 0 ) { + printf("Error while configuring video recorder\n"); + + return -1; + } + + if ( startRecording() < 0 ) { + printf("Error while starting video recording\n"); + + return -1; + } + } + + break; + + case '7': + + if ( compensation > 2.0) { + compensation = -2.0; + } else { + compensation += 0.1; + } + + params.set(KEY_COMPENSATION, (int) (compensation * 10)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '8': + awb_mode++; + awb_mode %= ARRAY_SIZE(strawb_mode); + params.set(params.KEY_WHITE_BALANCE, strawb_mode[awb_mode]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '9': + videoCodecIDX++; + videoCodecIDX %= ARRAY_SIZE(videoCodecs); + break; + case '~': + previewFormat += 1; + previewFormat %= ARRAY_SIZE(pixelformat) - 1; + params.setPreviewFormat(pixelformat[previewFormat].pixformat); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + case '$': + pictureFormat += 1; + if ( strcmp(params.get(KEY_STEREO_CAMERA), "false") == 0 && pictureFormat > 4 ) + pictureFormat = 0; + pictureFormat %= ARRAY_SIZE(codingformat); + params.setPictureFormat(codingformat[pictureFormat]); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '?' : + ///Set mode=3 to select video mode + params.set(KEY_MODE, 3); + params.set(KEY_VNF, 1); + params.set(KEY_VSTAB, 1); + break; + + case ':': + thumbSizeIDX += 1; + thumbSizeIDX %= ARRAY_SIZE(previewSize); + params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, previewSize[thumbSizeIDX].width); + params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, previewSize[thumbSizeIDX].height); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '\'': + if ( thumbQuality >= 100) { + thumbQuality = 0; + } else { + thumbQuality += 5; + } + + params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'B' : + vnf_mode++; + vnf_mode %= ARRAY_SIZE(vnf); + params.set(KEY_VNF, vnf_mode); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'C' : + vstab_mode++; + vstab_mode %= ARRAY_SIZE(vstab); + params.set(KEY_VSTAB, vstab_mode); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'E': + if(hardwareActive) + params.unflatten(camera->getParameters()); + printSupportedParams(); + break; + + case '*': + if ( hardwareActive ) + camera->startRecording(); + break; + + case 'o': + if ( jpegQuality >= 100) { + jpegQuality = 0; + } else { + jpegQuality += 5; + } + + params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'M': + measurementIdx = (measurementIdx + 1)%ARRAY_SIZE(measurement); + params.set(KEY_MEASUREMENT, measurement[measurementIdx]); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + case 'm': + { + meter_mode = (meter_mode + 1)%ARRAY_SIZE(metering); + params.set(KEY_METERING_MODE, metering[meter_mode]); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + } + + case 'k': + ippIDX += 1; + ippIDX %= ARRAY_SIZE(ipp_mode); + ippIDX_old = ippIDX; + +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) + params.set(KEY_IPP, ipp_mode[ippIDX]); +#else + params.set(KEY_IPP, ippIDX); +#endif + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'K': + gbceIDX+= 1; + gbceIDX %= ARRAY_SIZE(gbce); + params.set(KEY_GBCE, gbce[gbceIDX]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'F': + if ( hardwareActive ) + camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0); + + break; + + case 'T': + + if ( hardwareActive ) + camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0); + + break; + + case '@': + if ( hardwareActive ) { + + closeCamera(); + + if ( 0 >= openCamera() ) { + printf( "Reconnected to CameraService \n"); + } + } + + break; + + case '#': + + if ( burst >= MAX_BURST ) { + burst = 0; + } else { + burst += BURST_INC; + } + params.set(KEY_BURST, burst); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'J': + flashIdx++; + flashIdx %= ARRAY_SIZE(flashModes); + params.set(CameraParameters::KEY_FLASH_MODE, (flashModes[flashIdx])); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'u': + capture_mode++; + capture_mode %= ARRAY_SIZE(capture); + + // HQ should always be in ldc-nsf + // if not HQ, then return the ipp to its previous state + if( !strcmp(capture[capture_mode], "high-quality") ) { + ippIDX_old = ippIDX; + ippIDX = 3; + params.set(KEY_IPP, ipp_mode[ippIDX]); + } else { + ippIDX = ippIDX_old; + } + + params.set(KEY_MODE, (capture[capture_mode])); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'U': + tempBracketIdx++; + tempBracketIdx %= ARRAY_SIZE(tempBracketing); + params.set(KEY_TEMP_BRACKETING, tempBracketing[tempBracketIdx]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'H': + expBracketIdx++; + expBracketIdx %= ARRAY_SIZE(expBracketing); + + params.set(KEY_EXP_BRACKETING_RANGE, expBracketingRange[expBracketIdx]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'W': + tempBracketRange++; + tempBracketRange %= TEMP_BRACKETING_MAX_RANGE; + if ( 0 == tempBracketRange ) { + tempBracketRange = 1; + } + + params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange); + params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'w': + scene_mode++; + scene_mode %= ARRAY_SIZE(scene); + params.set(params.KEY_SCENE_MODE, scene[scene_mode]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'i': + iso_mode++; + iso_mode %= ARRAY_SIZE(iso); + params.set(KEY_ISO, iso[iso_mode]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'h': + if ( sharpness >= 100) { + sharpness = 0; + } else { + sharpness += 10; + } + params.set(KEY_SHARPNESS, sharpness); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'D': + { + audioCodecIDX++; + audioCodecIDX %= ARRAY_SIZE(audioCodecs); + break; + } + + case 'v': + { + outputFormatIDX++; + outputFormatIDX %= ARRAY_SIZE(outputFormat); + break; + } + + case 'z': + zoomIDX++; + zoomIDX %= ARRAY_SIZE(zoom); + params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'j': + exposure_mode++; + exposure_mode %= ARRAY_SIZE(exposure); + params.set(KEY_EXPOSURE, exposure[exposure_mode]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'c': + if( contrast >= 200){ + contrast = 0; + } else { + contrast += 10; + } + params.set(KEY_CONTRAST, contrast); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + case 'b': + if ( brightness >= 200) { + brightness = 0; + } else { + brightness += 10; + } + + params.set(KEY_BRIGHTNESS, brightness); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 's': + case 'S': + if ( saturation >= 100) { + saturation = 0; + } else { + saturation += 10; + } + + params.set(KEY_SATURATION, saturation); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'e': + effects_mode++; + effects_mode %= ARRAY_SIZE(effects); + params.set(params.KEY_EFFECT, effects[effects_mode]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'r': + + + if (camera_index == 0) { + frameRateIDX += 1; + frameRateIDX %= ARRAY_SIZE(fpsConstRanges); + params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRanges[frameRateIDX].range); + } else + { + frameRateIDXSec += 1; + frameRateIDXSec %= ARRAY_SIZE(fpsConstRangesSec); + params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRangesSec[frameRateIDXSec].range); + + + } + + if ( hardwareActive ) { + camera->setParameters(params.flatten()); + } + + break; + + case 'R': + fpsRangeIdx += 1; + fpsRangeIdx %= ARRAY_SIZE(fpsRanges); + params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsRanges[fpsRangeIdx].range); + + if ( hardwareActive ) { + camera->setParameters(params.flatten()); + } + + break; + + case 'x': + antibanding_mode++; + antibanding_mode %= ARRAY_SIZE(antibanding); + params.set(params.KEY_ANTIBANDING, antibanding[antibanding_mode]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'g': + focus_mode++; + focus_mode %= ARRAY_SIZE(focus); + params.set(params.KEY_FOCUS_MODE, focus[focus_mode]); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'G': + + params.set(CameraParameters::KEY_FOCUS_AREAS, TEST_FOCUS_AREA); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + params.remove(CameraParameters::KEY_FOCUS_AREAS); + + case 'f': + + gettimeofday(&autofocus_start, 0); + + if ( hardwareActive ) + camera->autoFocus(); + + break; + + case 'p': + + gettimeofday(&picture_start, 0); + + if ( hardwareActive ) + camera->takePicture(CAMERA_MSG_COMPRESSED_IMAGE|CAMERA_MSG_RAW_IMAGE); + + break; + + case '&': + printf("Enabling Preview Callback"); + dump_preview = 1; + if ( hardwareActive ) + camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK); + break; + + case '{': + if ( strcmp(params.get(KEY_S3D2D_PREVIEW_MODE), "off") == 0 ) + { + params.set(KEY_S3D2D_PREVIEW_MODE, "on"); + } + else + { + params.set(KEY_S3D2D_PREVIEW_MODE, "off"); + } + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'a': + + while (1) { + if ( menu_gps() < 0) + break; + }; + + break; + + case 'q': + + stopPreview(); + + return -1; + + case '/': + { + if (showfps) + { + property_set("debug.image.showfps", "0"); + showfps = false; + } + else + { + property_set("debug.image.showfps", "1"); + showfps = true; + } + break; + } + + case '<': + elockidx += 1; + elockidx %= ARRAY_SIZE(lock); + params.set(KEY_AUTO_EXPOSURE_LOCK, lock[elockidx]); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case '>': + wblockidx += 1; + wblockidx %= ARRAY_SIZE(lock); + params.set(KEY_AUTO_WHITEBALANCE_LOCK, lock[wblockidx]); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + default: + print_menu = 0; + + break; + } + + return 0; +} + +void print_usage() { + printf(" USAGE: camera_test <param> <script>\n"); + printf(" <param>\n-----------\n\n"); + printf(" F or f -> Functional tests \n"); + printf(" A or a -> API tests \n"); + printf(" E or e -> Error scenario tests \n"); + printf(" S or s -> Stress tests; with syslink trace \n"); + printf(" SN or sn -> Stress tests; No syslink trace \n\n"); + printf(" <script>\n----------\n"); + printf("Script name (Only for stress tests)\n\n"); + return; +} + +int error_scenario() { + char ch; + status_t stat = NO_ERROR; + + if (print_menu) { + printf(" 0. Buffer need\n"); + printf(" 1. Not enough memory\n"); + printf(" 2. Media server crash\n"); + printf(" 3. Overlay object request\n"); + printf(" 4. Pass unsupported preview&picture format\n"); + printf(" 5. Pass unsupported preview&picture resolution\n"); + printf(" 6. Pass unsupported preview framerate\n"); + + printf(" q. Quit\n"); + printf(" Choice: "); + } + + print_menu = 1; + ch = getchar(); + printf("%c\n", ch); + + switch (ch) { + case '0': { + printf("Case0:Buffer need\n"); + bufferStarvationTest = 1; + params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation + + if ( !recordingMode ) { + recordingMode = true; + if ( startPreview() < 0 ) { + printf("Error while starting preview\n"); + + return -1; + } + + if ( openRecorder() < 0 ) { + printf("Error while openning video recorder\n"); + + return -1; + } + + if ( configureRecorder() < 0 ) { + printf("Error while configuring video recorder\n"); + + return -1; + } + + if ( startRecording() < 0 ) { + printf("Error while starting video recording\n"); + + return -1; + } + + } + + usleep(1000000);//1s + + stopPreview(); + + if ( recordingMode ) { + stopRecording(); + closeRecorder(); + + recordingMode = false; + } + + break; + } + + case '1': { + printf("Case1:Not enough memory\n"); + int* tMemoryEater = new int[999999999]; + + if (!tMemoryEater) { + printf("Not enough memory\n"); + return -1; + } else { + delete tMemoryEater; + } + + break; + } + + case '2': { + printf("Case2:Media server crash\n"); + //camera = Camera::connect(); + + if ( NULL == camera.get() ) { + printf("Unable to connect to CameraService\n"); + return -1; + } + + break; + } + + case '3': { + printf("Case3:Overlay object request\n"); + int err = 0; + + err = open("/dev/video5", O_RDWR); + + if (err < 0) { + printf("Could not open the camera device5: %d\n", err ); + return err; + } + + if ( startPreview() < 0 ) { + printf("Error while starting preview\n"); + return -1; + } + + usleep(1000000);//1s + + stopPreview(); + + close(err); + break; + } + + case '4': { + + if ( hardwareActive ) { + + params.setPictureFormat("invalid-format"); + params.setPreviewFormat("invalid-format"); + + stat = camera->setParameters(params.flatten()); + + if ( NO_ERROR != stat ) { + printf("Test passed!\n"); + } else { + printf("Test failed!\n"); + } + + initDefaults(); + } + + break; + } + + case '5': { + + if ( hardwareActive ) { + + params.setPictureSize(-1, -1); + params.setPreviewSize(-1, -1); + + stat = camera->setParameters(params.flatten()); + + if ( NO_ERROR != stat ) { + printf("Test passed!\n"); + } else { + printf("Test failed!\n"); + } + + initDefaults(); + } + + break; + } + + case '6': { + + if ( hardwareActive ) { + + params.setPreviewFrameRate(-1); + + stat = camera->setParameters(params.flatten()); + + if ( NO_ERROR != stat ) { + printf("Test passed!\n"); + } else { + printf("Test failed!\n"); + } + + initDefaults(); + } + + + break; + } + + case 'q': { + return -1; + } + + default: { + print_menu = 0; + break; + } + } + + return 0; +} + +int restartCamera() { + + const char dir_path_name[80] = SDCARD_PATH; + + printf("+++Restarting Camera After Error+++\n"); + stopPreview(); + + if (recordingMode) { + stopRecording(); + closeRecorder(); + + recordingMode = false; + } + + sleep(3); //Wait a bit before restarting + + restartCount++; + + if (strcpy(dir_path, dir_path_name) == NULL) + { + printf("Error reseting dir name"); + return -1; + } + + if ( openCamera() < 0 ) + { + printf("+++Camera Restarted Failed+++\n"); + system("echo camerahal_test > /sys/power/wake_unlock"); + return -1; + } + + initDefaults(); + + stopScript = false; + + printf("+++Camera Restarted Successfully+++\n"); + return 0; +} + +int main(int argc, char *argv[]) { + char *cmd; + int pid; + sp<ProcessState> proc(ProcessState::self()); + + unsigned long long st, end, delay; + timeval current_time; + + gettimeofday(¤t_time, 0); + + st = current_time.tv_sec * 1000000 + current_time.tv_usec; + + cmd = NULL; + + if ( argc < 2 ) { + printf(" Please enter atleast 1 argument\n"); + print_usage(); + + return 0; + } + system("echo camerahal_test > /sys/power/wake_lock"); + if ( argc < 3 ) { + switch (*argv[1]) { + case 'S': + case 's': + printf("This is stress / regression tests \n"); + printf("Provide script file as 2nd argument\n"); + + break; + + case 'F': + case 'f': + ProcessState::self()->startThreadPool(); + + if ( openCamera() < 0 ) { + printf("Camera initialization failed\n"); + system("echo camerahal_test > /sys/power/wake_unlock"); + return -1; + } + + initDefaults(); + print_menu = 1; + + while ( 1 ) { + if ( functional_menu() < 0 ) + break; + }; + + break; + + case 'A': + case 'a': + printf("API level test cases coming soon ... \n"); + + break; + + case 'E': + case 'e': { + ProcessState::self()->startThreadPool(); + + if ( openCamera() < 0 ) { + printf("Camera initialization failed\n"); + system("echo camerahal_test > /sys/power/wake_unlock"); + return -1; + } + + initDefaults(); + print_menu = 1; + + while (1) { + if (error_scenario() < 0) { + break; + } + } + + break; + } + + default: + printf("INVALID OPTION USED\n"); + print_usage(); + + break; + } + } else if ( ( argc == 3) && ( ( *argv[1] == 'S' ) || ( *argv[1] == 's') ) ) { + + if((argv[1][1] == 'N') || (argv[1][1] == 'n')) { + bLogSysLinkTrace = false; + } + + ProcessState::self()->startThreadPool(); + + if ( openCamera() < 0 ) { + printf("Camera initialization failed\n"); + system("echo camerahal_test > /sys/power/wake_unlock"); + return -1; + } + + initDefaults(); + + cmd = load_script(argv[2]); + + if ( cmd != NULL) { + start_logging(argv[2], pid); + stressTest = true; + + while (1) + { + if ( execute_functional_script(cmd) == 0 ) + { + break; + } + else + { + printf("CameraTest Restarting Camera...\n"); + + free(cmd); + cmd = NULL; + + if ( (restartCamera() != 0) || ((cmd = load_script(argv[2])) == NULL) ) + { + printf("ERROR::CameraTest Restarting Camera...\n"); + break; + } + } + } + free(cmd); + stop_logging(pid); + } + } else if ( ( argc == 3) && ( ( *argv[1] == 'E' ) || ( *argv[1] == 'e') ) ) { + + ProcessState::self()->startThreadPool(); + + if ( openCamera() < 0 ) { + printf("Camera initialization failed\n"); + system("echo camerahal_test > /sys/power/wake_unlock"); + return -1; + } + + initDefaults(); + + cmd = load_script(argv[2]); + + if ( cmd != NULL) { + start_logging(argv[2], pid); + execute_error_script(cmd); + free(cmd); + stop_logging(pid); + } + + } else { + printf("INVALID OPTION USED\n"); + print_usage(); + } + + gettimeofday(¤t_time, 0); + end = current_time.tv_sec * 1000000 + current_time.tv_usec; + delay = end - st; + printf("Application clossed after: %llu ms\n", delay); + system("echo camerahal_test > /sys/power/wake_unlock"); + return 0; +} + diff --git a/test/CameraHal/camera_test_script.cpp b/test/CameraHal/camera_test_script.cpp new file mode 100644 index 0000000..15a403c --- /dev/null +++ b/test/CameraHal/camera_test_script.cpp @@ -0,0 +1,1373 @@ +#include <stdlib.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <time.h> +#include <semaphore.h> +#include <pthread.h> + +#include <surfaceflinger/Surface.h> +#include <surfaceflinger/ISurface.h> +#include <surfaceflinger/ISurfaceComposer.h> +#include <surfaceflinger/ISurfaceComposerClient.h> +#include <surfaceflinger/SurfaceComposerClient.h> + +#include <camera/Camera.h> +#include <camera/ICamera.h> +#include <media/mediarecorder.h> + +#include <binder/IPCThreadState.h> +#include <binder/ProcessState.h> +#include <binder/IServiceManager.h> +#include <cutils/properties.h> +#include <camera/CameraParameters.h> + +#include <sys/wait.h> + +#include "camera_test.h" + +using namespace android; + +extern bool stopScript; +extern bool hardwareActive; +extern sp<Camera> camera; +extern CameraParameters params; +extern bool recordingMode; +extern int camera_index; +extern int rotation; +extern const preview_size previewSize []; +extern const Vcapture_size VcaptureSize []; +extern const capture_Size captureSize[]; +extern const outformat outputFormat[]; +extern const video_Codecs videoCodecs[]; +extern const audio_Codecs audioCodecs[]; +extern const V_bitRate VbitRate[]; +extern const fps_ranges fpsRanges[]; +extern const fpsConst_Ranges fpsConstRanges[]; +extern const fpsConst_RangesSec fpsConstRangesSec[]; +extern const Zoom zoom []; +extern int previewSizeIDX; +extern bool reSizePreview; +extern bool previewRunning; +extern int captureSizeIDX; +extern float compensation; +extern int videoCodecIDX; +extern int outputFormatIDX; +extern int audioCodecIDX; +extern int VcaptureSizeIDX; +extern int VbitRateIDX; +extern int thumbSizeIDX; +extern int thumbQuality; +extern int jpegQuality; +extern int dump_preview; +extern int ippIDX_old; +extern const char *capture[]; +extern int capture_mode; +extern int ippIDX; +extern const char *ipp_mode[]; +extern int tempBracketRange; +extern int iso_mode; +extern int sharpness; +extern int contrast; +extern int zoomIDX; +extern int brightness; +extern int saturation; +extern int fpsRangeIdx; +extern timeval autofocus_start, picture_start; +extern const char *cameras[]; +extern double latitude; +extern double degree_by_step; +extern double longitude; +extern double altitude; +extern char dir_path[80]; +extern int AutoConvergenceModeIDX; +extern const char *autoconvergencemode[]; +extern const char *manualconvergencevalues[]; +extern const int ManualConvergenceDefaultValueIDX; +extern size_t length_cam; +extern char script_name[]; +extern int restartCount; +extern bool bLogSysLinkTrace; +extern int bufferStarvationTest; +extern size_t length_previewSize; +extern size_t lenght_Vcapture_size; +extern size_t length_outformat; +extern size_t length_capture_Size; +extern size_t length_video_Codecs; +extern size_t length_audio_Codecs; +extern size_t length_V_bitRate; +extern size_t length_Zoom; +extern size_t length_fps_ranges; +extern size_t length_fpsConst_Ranges; +extern size_t length_fpsConst_RangesSec; + + +int execute_functional_script(char *script) { + char *cmd, *ctx, *cycle_cmd, *temp_cmd; + char id; + unsigned int i; + int dly; + int cycleCounter = 1; + int tLen = 0; + unsigned int iteration = 0; + status_t ret = NO_ERROR; + int frameR = 20; + int frameRateIndex = 0; + + LOG_FUNCTION_NAME; + + dump_mem_status(); + + cmd = strtok_r((char *) script, DELIMITER, &ctx); + + while ( NULL != cmd && (stopScript == false)) { + id = cmd[0]; + printf("Full Command: %s \n", cmd); + printf("Command: %c \n", cmd[0]); + + switch (id) { + + // Case for Suspend-Resume Feature + case '!': { + // STEP 1: Mount Debugfs + system("mkdir /debug"); + system("mount -t debugfs debugfs /debug"); + + // STEP 2: Set up wake up Timer - wake up happens after 5 seconds + system("echo 10 > /debug/pm_debug/wakeup_timer_seconds"); + + // STEP 3: Make system ready for Suspend + system("echo camerahal_test > /sys/power/wake_unlock"); + // Release wake lock held by test app + printf(" Wake lock released "); + system("cat /sys/power/wake_lock"); + system("sendevent /dev/input/event0 1 60 1"); + system("sendevent /dev/input/event0 1 60 0"); + // Simulate F2 key press to make display OFF + printf(" F2 event simulation complete "); + + //STEP 4: Wait for system Resume and then simuate F1 key + sleep(50);//50s // This delay is not related to suspend resume timer + printf(" After 30 seconds of sleep"); + system("sendevent /dev/input/event0 1 59 0"); + system("sendevent /dev/input/event0 1 59 1"); + // Simulate F1 key press to make display ON + system("echo camerahal_test > /sys/power/wake_lock"); + // Acquire wake lock for test app + + break; + } + + case '[': + if ( hardwareActive ) + { + + camera->setParameters(params.flatten()); + + printf("starting camera preview.."); + status_t ret = camera->startPreview(); + if(ret !=NO_ERROR) + { + printf("startPreview failed %d..", ret); + } + } + break; + case '+': { + cycleCounter = atoi(cmd + 1); + cycle_cmd = get_cycle_cmd(ctx); + tLen = strlen(cycle_cmd); + temp_cmd = new char[tLen+1]; + + for (int ind = 0; ind < cycleCounter; ind++) { + strcpy(temp_cmd, cycle_cmd); + if ( execute_functional_script(temp_cmd) != 0 ) + return -1; + temp_cmd[0] = '\0'; + + //patch for image capture + //[ + if (ind < cycleCounter - 1) { + if (hardwareActive == false) { + if ( openCamera() < 0 ) { + printf("Camera initialization failed\n"); + + return -1; + } + + initDefaults(); + } + } + + //] + } + + ctx += tLen + 1; + + if (temp_cmd) { + delete temp_cmd; + temp_cmd = NULL; + } + + if (cycle_cmd) { + delete cycle_cmd; + cycle_cmd = NULL; + } + + break; + } + + case '0': + { + initDefaults(); + break; + } + + case '1': + + if ( startPreview() < 0 ) { + printf("Error while starting preview\n"); + + return -1; + } + + break; + + case '2': + stopPreview(); + + if ( recordingMode ) { + + camera->disconnect(); + camera.clear(); + stopRecording(); + closeRecorder(); + + camera = Camera::connect(camera_index); + if ( NULL == camera.get() ) { + sleep(1); + camera = Camera::connect(camera_index); + + if ( NULL == camera.get() ) { + return -1; + } + } + camera->setListener(new CameraHandler()); + camera->setParameters(params.flatten()); + + recordingMode = false; + } + + break; + + case '3': + rotation = atoi(cmd + 1); + params.set(CameraParameters::KEY_ROTATION, rotation); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '4': + { + printf("Setting resolution..."); + int width, height; + for(i = 0; i < length_previewSize ; i++) + { + if( strcmp((cmd + 1), previewSize[i].desc) == 0) + { + width = previewSize[i].width; + height = previewSize[i].height; + previewSizeIDX = i; + break; + } + } + + if (i == length_previewSize ) //if the resolution is not in the supported ones + { + char *res = NULL; + res = strtok(cmd + 1, "x"); + width = atoi(res); + res = strtok(NULL, "x"); + height = atoi(res); + } + + if ( strcmp(params.get(KEY_STEREO_CAMERA), "true") == 0 ) { + height *=2; + } + printf("Resolution: %d x %d\n", width, height); + params.setPreviewSize(width, height); + reSizePreview = true; + + if ( hardwareActive && previewRunning ) { + camera->stopPreview(); + camera->setParameters(params.flatten()); + camera->startPreview(); + } else if ( hardwareActive ) { + camera->setParameters(params.flatten()); + } + + break; + } + case '5': + + for (i = 0; i < length_capture_Size; i++) { + if ( strcmp((cmd + 1), captureSize[i].name) == 0) + break; + } + + if ( i < length_capture_Size ) { + params.setPictureSize(captureSize[i].width, captureSize[i].height); + captureSizeIDX = i; + } + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '6': + + if ( !recordingMode ) { + + recordingMode = true; + + if ( startPreview() < 0 ) { + printf("Error while starting preview\n"); + + return -1; + } + + if ( openRecorder() < 0 ) { + printf("Error while openning video recorder\n"); + + return -1; + } + + if ( configureRecorder() < 0 ) { + printf("Error while configuring video recorder\n"); + + return -1; + } + + if ( startRecording() < 0 ) { + printf("Error while starting video recording\n"); + + return -1; + } + + } + + break; + + case '7': + compensation = atof(cmd + 1); + params.set(KEY_COMPENSATION, (int) (compensation * 10)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '8': + params.set(params.KEY_WHITE_BALANCE, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '9': + for(i = 0; i < length_video_Codecs; i++) + { + if( strcmp((cmd + 1), videoCodecs[i].desc) == 0) + { + videoCodecIDX = i; + printf("Video Codec Selected: %s\n", + videoCodecs[i].desc); + break; + } + } + break; + + case 'v': + for(i = 0; i < length_outformat; i++) + + { + if( strcmp((cmd + 1), outputFormat[i].desc) == 0) + { + outputFormatIDX = i; + printf("Video Codec Selected: %s\n", + videoCodecs[i].desc); + break; + } + } + break; + + case '~': + params.setPreviewFormat(cmd + 1); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '$': + params.setPictureFormat(cmd + 1); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + case '-': + for(i = 0; i < length_audio_Codecs; i++) + { + if( strcmp((cmd + 1), audioCodecs[i].desc) == 0) + { + audioCodecIDX = i; + printf("Selected Audio: %s\n", audioCodecs[i].desc); + break; + } + } + break; + + case 'A': + camera_index=atoi(cmd+1); + // camera_index %= ARRAY_SIZE(cameras); + camera_index %= length_cam; + if ( camera_index == 2) + params.set(KEY_STEREO_CAMERA, "true"); + else + params.set(KEY_STEREO_CAMERA, "false"); + + printf("%s selected.\n", cameras[camera_index]); + + if ( hardwareActive ) { + stopPreview(); + closeCamera(); + openCamera(); + } else { + closeCamera(); + openCamera(); + } + + if (camera_index == 0) params.setPreviewFrameRate(30); + else params.setPreviewFrameRate(27); + + + break; + + case 'a': + char * temp_str; + + temp_str = strtok(cmd+1,"!"); + printf("Latitude %s \n",temp_str); + params.set(params.KEY_GPS_LATITUDE, temp_str); + temp_str=strtok(NULL,"!"); + printf("Longitude %s \n",temp_str); + params.set(params.KEY_GPS_LONGITUDE, temp_str); + temp_str=strtok(NULL,"!"); + printf("Altitude %s \n",temp_str); + params.set(params.KEY_GPS_ALTITUDE, temp_str); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'l': + case 'L': + for(i = 0; i < lenght_Vcapture_size; i++) + { + if( strcmp((cmd + 1), VcaptureSize[i].desc) == 0) + { + VcaptureSizeIDX = i; + printf("Video Capture Size: %s\n", VcaptureSize[i].desc); + break; + } + } + break; + case ']': + for(i = 0; i < length_V_bitRate; i++) + { + if( strcmp((cmd + 1), VbitRate[i].desc) == 0) + { + VbitRateIDX = i; + printf("Video Bit Rate: %s\n", VbitRate[i].desc); + break; + } + } + break; + case ':': + int width, height; + for(i = 0; i < length_previewSize ; i++) + { + if( strcmp((cmd + 1), previewSize[i].desc) == 0) + { + width = previewSize[i].width; + height = previewSize[i].height; + thumbSizeIDX = i; + break; + } + } + + if (i == length_previewSize ) //if the resolution is not in the supported ones + { + char *res = NULL; + res = strtok(cmd + 1, "x"); + width = atoi(res); + res = strtok(NULL, "x"); + height = atoi(res); + } + + params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width); + params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '\'': + thumbQuality = atoi(cmd + 1); + + params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case '*': + if ( hardwareActive ) + camera->startRecording(); + break; + + case 't': + params.setPreviewFormat((cmd + 1)); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'o': + jpegQuality = atoi(cmd + 1); + params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + + case '&': + printf("Enabling Preview Callback"); + dump_preview = 1; + camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK); + break; + + + case 'k': + ippIDX_old = atoi(cmd + 1); + params.set(KEY_IPP, atoi(cmd + 1)); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'K': + params.set(KEY_GBCE, (cmd+1)); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'u': + // HQ should always be in ldc-nsf + // if not HQ, then return the ipp to its previous state + if( !strcmp(capture[capture_mode], "high-quality") ) { + ippIDX_old = ippIDX; + ippIDX = 3; + params.set(KEY_IPP, ipp_mode[ippIDX]); + } else { + ippIDX = ippIDX_old; + } + + params.set(KEY_MODE, (cmd + 1)); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'U': + + params.set(KEY_TEMP_BRACKETING, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'W': + + tempBracketRange = atoi(cmd + 1); + tempBracketRange %= TEMP_BRACKETING_MAX_RANGE; + if ( 0 == tempBracketRange ) { + tempBracketRange = 1; + } + + params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange); + params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '#': + + params.set(KEY_BURST, atoi(cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'J': + params.set(CameraParameters::KEY_FLASH_MODE, (cmd+1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'w': + params.set(params.KEY_SCENE_MODE, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'B' : + params.set(KEY_VNF, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + + case 'C' : + params.set(KEY_VSTAB, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'D': + if ( hardwareActive ) + camera->stopRecording(); + break; + + case 'E': + if(hardwareActive) + params.unflatten(camera->getParameters()); + printSupportedParams(); + break; + + case 'i': + iso_mode = atoi(cmd + 1); + params.set(KEY_ISO, iso_mode); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'h': + sharpness = atoi(cmd + 1); + params.set(KEY_SHARPNESS, sharpness); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case '@': + if ( hardwareActive ) { + + closeCamera(); + + if ( 0 >= openCamera() ) { + printf( "Reconnected to CameraService \n"); + } + } + + break; + + case 'c': + contrast = atoi(cmd + 1); + params.set(KEY_CONTRAST, contrast); + + if ( hardwareActive ) { + camera->setParameters(params.flatten()); + } + + break; + + case 'z': + case 'Z': + +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) + params.set(CameraParameters::KEY_ZOOM, atoi(cmd + 1)); +#else + + for(i = 0; i < length_Zoom; i++) + { + if( strcmp((cmd + 1), zoom[i].zoom_description) == 0) + { + zoomIDX = i; + break; + } + } + + params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx); +#endif + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'j': + params.set(KEY_EXPOSURE, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'b': + brightness = atoi(cmd + 1); + params.set(KEY_BRIGHTNESS, brightness); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 's': + saturation = atoi(cmd + 1); + params.set(KEY_SATURATION, saturation); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'e': + params.set(params.KEY_EFFECT, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'r': + + frameR = atoi(cmd + 1); + + + if (camera_index == 0) { + for (i = 0; i < length_fpsConst_Ranges; i++) { + if (frameR == fpsConstRanges[i].constFramerate) + frameRateIndex = i; + + } + } else { + for (i = 0; i < length_fpsConst_RangesSec; i++) { + if (frameR == fpsConstRangesSec[i].constFramerate) + frameRateIndex = i; + } + } + + + if (camera_index == 0) + params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRanges[frameRateIndex].range); + else + params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRangesSec[frameRateIndex].range); + + + if ( hardwareActive && previewRunning ) { + camera->stopPreview(); + camera->setParameters(params.flatten()); + camera->startPreview(); + } else if ( hardwareActive ) { + camera->setParameters(params.flatten()); + } + + break; + + case 'R': + for(i = 0; i < length_fps_ranges; i++) + { + if( strcmp((cmd + 1), fpsRanges[i].rangeDescription) == 0) + { + fpsRangeIdx = i; + printf("Selected Framerate range: %s\n", fpsRanges[i].rangeDescription); + if ( hardwareActive ) { + params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsRanges[i].range); + params.remove(CameraParameters::KEY_PREVIEW_FRAME_RATE); + camera->setParameters(params.flatten()); + } + break; + } + } + break; + + case 'x': + params.set(params.KEY_ANTIBANDING, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'g': + params.set(params.KEY_FOCUS_MODE, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + break; + + case 'G': + + params.set(CameraParameters::KEY_FOCUS_AREAS, (cmd + 1)); + + if ( hardwareActive ) + camera->setParameters(params.flatten()); + + params.remove(CameraParameters::KEY_FOCUS_AREAS); + + case 'f': + gettimeofday(&autofocus_start, 0); + + if ( hardwareActive ) + camera->autoFocus(); + + break; + + case 'p': + gettimeofday(&picture_start, 0); + + if ( hardwareActive ) + ret = camera->takePicture(CAMERA_MSG_COMPRESSED_IMAGE|CAMERA_MSG_RAW_IMAGE); + + if ( ret != NO_ERROR ) + printf("Error returned while taking a picture"); + break; + + case 'd': + dly = atoi(cmd + 1); + sleep(dly); + break; + + case 'q': + dump_mem_status(); + stopPreview(); + + if ( recordingMode ) { + stopRecording(); + closeRecorder(); + + recordingMode = false; + } + goto exit; + + case '\n': + printf("Iteration: %d \n", iteration); + iteration++; + break; + + case '{': + if ( atoi(cmd + 1) > 0 ) + params.set(KEY_S3D2D_PREVIEW_MODE, "on"); + else + params.set(KEY_S3D2D_PREVIEW_MODE, "off"); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + + case 'M': + params.set(KEY_MEASUREMENT, (cmd + 1)); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + case 'm': + { + params.set(KEY_METERING_MODE, (cmd + 1)); + if ( hardwareActive ) + { + camera->setParameters(params.flatten()); + } + break; + } + case '<': + { + char coord_str[8]; + latitude += degree_by_step; + if (latitude > 90.0) + { + latitude -= 180.0; + } + snprintf(coord_str, 7, "%.7lf", latitude); + params.set(params.KEY_GPS_LATITUDE, coord_str); + if ( hardwareActive ) + { + camera->setParameters(params.flatten()); + } + break; + } + + case '=': + { + char coord_str[8]; + longitude += degree_by_step; + if (longitude > 180.0) + { + longitude -= 360.0; + } + snprintf(coord_str, 7, "%.7lf", longitude); + params.set(params.KEY_GPS_LONGITUDE, coord_str); + if ( hardwareActive ) + { + camera->setParameters(params.flatten()); + } + break; + } + + case '>': + { + char coord_str[8]; + altitude += 12345.67890123456789; + if (altitude > 100000.0) + { + altitude -= 200000.0; + } + snprintf(coord_str, 7, "%.7lf", altitude); + params.set(params.KEY_GPS_ALTITUDE, coord_str); + if ( hardwareActive ) + { + camera->setParameters(params.flatten()); + } + break; + } + + case 'X': + { + char rem_str[50]; + printf("Deleting images from %s \n", dir_path); + if(!sprintf(rem_str,"rm %s/*.jpg",dir_path)) + printf("Sprintf Error"); + if(system(rem_str)) + printf("Images were not deleted\n"); + break; + } + + case '_': + { + AutoConvergenceModeIDX = atoi(cmd + 1); + if ( AutoConvergenceModeIDX < 0 || AutoConvergenceModeIDX > 4 ) + AutoConvergenceModeIDX = 0; + params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]); + if ( AutoConvergenceModeIDX != 4 ) + params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceDefaultValueIDX]); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + break; + } + + case '^': + { + char strtmpval[7]; + if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) { + sprintf(strtmpval,"%d", atoi(cmd + 1)); + params.set(KEY_MANUALCONVERGENCE_VALUES, strtmpval); + if ( hardwareActive ) + camera->setParameters(params.flatten()); + } + break; + } + + default: + printf("Unrecognized command!\n"); + break; + } + + cmd = strtok_r(NULL, DELIMITER, &ctx); + } + +exit: + if (stopScript == true) + { + return -1; + } + else + { + return 0; + } +} + + +char * get_cycle_cmd(const char *aSrc) { + unsigned ind = 0; + char *cycle_cmd = new char[256]; + + while ((*aSrc != '+') && (*aSrc != '\0')) { + cycle_cmd[ind++] = *aSrc++; + } + cycle_cmd[ind] = '\0'; + + return cycle_cmd; +} + +status_t dump_mem_status() { + system(MEDIASERVER_DUMP); + return system(MEMORY_DUMP); +} + +char *load_script(char *config) { + FILE *infile; + size_t fileSize; + char *script; + size_t nRead = 0; + char dir_name[40]; + size_t count; + char rCount [5]; + + count = 0; + + infile = fopen(config, "r"); + + strcpy(script_name,config); + + // remove just the '.txt' part of the config + while((config[count] != '.') && (count < sizeof(dir_name)/sizeof(dir_name[0]))) + count++; + + printf("\n SCRIPT : <%s> is currently being executed \n",script_name); + if(strncpy(dir_name,config,count) == NULL) + printf("Strcpy error"); + + dir_name[count]=NULL; + + if(strcat(dir_path,dir_name) == NULL) + printf("Strcat error"); + + if(restartCount) + { + sprintf(rCount,"_%d",restartCount); + if(strcat(dir_path, rCount) == NULL) + printf("Strcat error RestartCount"); + } + + printf("\n COMPLETE FOLDER PATH : %s \n",dir_path); + if(mkdir(dir_path,0777) == -1) { + printf("\n Directory %s was not created \n",dir_path); + } else { + printf("\n Directory %s was created \n",dir_path); + } + printf("\n DIRECTORY CREATED FOR TEST RESULT IMAGES IN MMC CARD : %s \n",dir_name); + + if( (NULL == infile)){ + printf("Error while opening script file %s!\n", config); + return NULL; + } + + fseek(infile, 0, SEEK_END); + fileSize = ftell(infile); + fseek(infile, 0, SEEK_SET); + + script = (char *) malloc(fileSize); + + if ( NULL == script ) { + printf("Unable to allocate buffer for the script\n"); + + return NULL; + } + + if ((nRead = fread(script, 1, fileSize, infile)) != fileSize) { + printf("Error while reading script file!\n"); + + free(script); + fclose(infile); + return NULL; + } + + fclose(infile); + + return script; +} + +int start_logging(char *config, int &pid) { + char dir_name[40]; + size_t count = 0; + int status = 0; + + // remove just the '.txt' part of the config + while((config[count] != '.') && (count < sizeof(dir_name)/sizeof(dir_name[0]))) + count++; + + if(strncpy(dir_name,config,count) == NULL) + printf("Strcpy error"); + + dir_name[count]=NULL; + + pid = fork(); + if (pid == 0) + { + char *command_list[] = {"sh", "-c", NULL, NULL}; + char log_cmd[120]; + // child process to run logging + + // set group id of this process to itself + // we will use this group id to kill the + // application logging + setpgid(getpid(), getpid()); + + /* Start logcat */ + if(!sprintf(log_cmd,"logcat > /sdcard/%s/log.txt &",dir_name)) + printf(" Sprintf Error"); + + /* Start Syslink Trace */ + if(bLogSysLinkTrace) { + if(!sprintf(log_cmd,"%s /system/bin/syslink_trace_daemon.out -l /sdcard/%s/syslink_trace.txt -f &",log_cmd, dir_name)) + printf(" Sprintf Error"); + } + + command_list[2] = (char *)log_cmd; + execvp("/system/bin/sh", command_list); + } if(pid < 0) + { + printf("failed to fork logcat\n"); + return -1; + } + + //wait for logging to start + if(waitpid(pid, &status, 0) != pid) + { + printf("waitpid failed in log fork\n"); + return -1; + }else + printf("logging started... status=%d\n", status); + + return 0; +} + +int stop_logging(int &pid) +{ + if(pid > 0) + { + if(killpg(pid, SIGKILL)) + { + printf("Exit command failed"); + return -1; + } else { + printf("\nlogging for script %s is complete\n logcat saved @ location: %s\n",script_name,dir_path); + if (bLogSysLinkTrace) + printf(" syslink_trace is saved @ location: %s\n\n",dir_path); + } + } + return 0; +} + +int execute_error_script(char *script) { + char *cmd, *ctx; + char id; + status_t stat = NO_ERROR; + + LOG_FUNCTION_NAME; + + cmd = strtok_r((char *) script, DELIMITER, &ctx); + + while ( NULL != cmd ) { + id = cmd[0]; + + switch (id) { + + case '0': { + bufferStarvationTest = 1; + params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation + + if ( !recordingMode ) { + + recordingMode = true; + + if ( startPreview() < 0 ) { + printf("Error while starting preview\n"); + + return -1; + } + + if ( openRecorder() < 0 ) { + printf("Error while openning video recorder\n"); + + return -1; + } + + if ( configureRecorder() < 0 ) { + printf("Error while configuring video recorder\n"); + + return -1; + } + + if ( startRecording() < 0 ) { + printf("Error while starting video recording\n"); + + return -1; + } + + } + + usleep(1000000);//1s + + stopPreview(); + + if ( recordingMode ) { + stopRecording(); + closeRecorder(); + + recordingMode = false; + } + + break; + } + + case '1': { + int* tMemoryEater = new int[999999999]; + + if (!tMemoryEater) { + printf("Not enough memory\n"); + return -1; + } else { + delete tMemoryEater; + } + + break; + } + + case '2': { + //camera = Camera::connect(); + + if ( NULL == camera.get() ) { + printf("Unable to connect to CameraService\n"); + return -1; + } + + break; + } + + case '3': { + int err = 0; + + err = open("/dev/video5", O_RDWR); + + if (err < 0) { + printf("Could not open the camera device5: %d\n", err ); + return err; + } + + if ( startPreview() < 0 ) { + printf("Error while starting preview\n"); + return -1; + } + + usleep(1000000);//1s + + stopPreview(); + + close(err); + break; + } + + case '4': { + + if ( hardwareActive ) { + + params.setPictureFormat("invalid-format"); + params.setPreviewFormat("invalid-format"); + + stat = camera->setParameters(params.flatten()); + + if ( NO_ERROR != stat ) { + printf("Test passed!\n"); + } else { + printf("Test failed!\n"); + } + + initDefaults(); + } + + break; + } + + case '5': { + + if ( hardwareActive ) { + + params.setPictureSize(-1, -1); + params.setPreviewSize(-1, -1); + + stat = camera->setParameters(params.flatten()); + + if ( NO_ERROR != stat ) { + printf("Test passed!\n"); + } else { + printf("Test failed!\n"); + } + + initDefaults(); + } + + break; + } + + case '6': { + + if ( hardwareActive ) { + + params.setPreviewFrameRate(-1); + + stat = camera->setParameters(params.flatten()); + + if ( NO_ERROR != stat ) { + printf("Test passed!\n"); + } else { + printf("Test failed!\n"); + } + + initDefaults(); + } + + + break; + } + + case 'q': { + goto exit; + + break; + } + + default: { + printf("Unrecognized command!\n"); + + break; + } + } + + cmd = strtok_r(NULL, DELIMITER, &ctx); + } + +exit: + + return 0; +} + + + |