initial commit
Change-Id: I8f7a7eeece0e516efa486b77e9d97805c0e65d3e
Signed-off-by: Iliyan Malchev <malchev@google.com>
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;
+}
+
