#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 <string.h>
#include <assert.h>
#include <climits>
#include <ui/DisplayInfo.h>
#include <gui/GLConsumer.h>
#include <gui/Surface.h>
#include <ui/GraphicBuffer.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 <camera/ShotParameters.h>
#include <system/audio.h>
#include <system/camera.h>
#include <binder/IMemory.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
#include <cutils/memory.h>
#include <utils/Log.h>
#include <sys/wait.h>
#include "camera_test.h"
#include "camera_test_surfacetexture.h"
#ifdef ANDROID_API_JB_OR_LATER
#include "camera_test_bufferqueue.h"
#endif
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;
sp<BufferSourceThread> bufferSourceOutputThread;
sp<BufferSourceInput> bufferSourceInput;
CameraParameters params;
ShotParameters shotParams;
float compensation = 0.0;
double latitude = 0.0;
double longitude = 0.0;
double degree_by_step = 17.5609756;
double altitude = 0.0;
int awb_mode = 0;
int effects_mode = 0;
int scene_mode = 0;
int caf_mode = 0;
int tempBracketRange = 1;
int tempBracketIdx = 0;
int measurementIdx = 0;
int expBracketIdx = BRACKETING_IDX_DEFAULT;
int AutoConvergenceModeIDX = 0;
int gbceIDX = 0;
int glbceIDX = 0;
int rotation = 0;
int previewRotation = 0;
bool reSizePreview = true;
bool hardwareActive = false;
bool recordingMode = false;
bool previewRunning = false;
bool vstabtoggle = false;
bool AutoExposureLocktoggle = false;
bool AutoWhiteBalanceLocktoggle = false;
bool vnftoggle = false;
bool faceDetectToggle = false;
bool metaDataToggle = false;
bool shotConfigFlush = false;
bool streamCapture = 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;
unsigned int burstCount = 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 pictureFormat = 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 afTimeoutIdx = 0;
int platformID = BLAZE_TABLET2;
int numAntibanding = 0;
int numEffects = 0;
int numcaptureSize = 0;
int nummodevalues = 0;
int numVcaptureSize = 0;
int numpreviewSize = 0;
int numthumbnailSize = 0;
int numawb = 0;
int numscene = 0;
int numfocus = 0;
int numflash = 0;
int numExposureMode = 0;
int numisoMode = 0;
int antibanding_mode = 0;
int effectsStrLenght = 0;
int numfps = 0;
int numpreviewFormat = 0;
int numpictureFormat = 0;
int *constFramerate = 0;
int rangeCnt = 0;
int constCnt = 0;
int focus_mode = 0;
int thumbSizeIDX = 0;
int previewSizeIDX = 1;
int captureSizeIDX = 0;
int VcaptureSizeIDX = 1;
int frameRateIDX = 0;
char *str;
char *param;
char *antibandStr = 0;
char *exposureModeStr = 0;
char *isoModeStr = 0;
char *effectssStr = 0;
char *captureSizeStr = 0;
char *modevaluesstr = 0;
char *videosnapshotstr = 0;
char *autoconvergencestr = 0;
char *VcaptureSizeStr = 0;
char *thumbnailSizeStr = 0;
char *vstabstr = 0;
char *vnfstr = 0;
char *zoomstr = 0;
char *smoothzoomstr = 0;
char *AutoExposureLockstr = 0;
char *AutoWhiteBalanceLockstr = 0;
char *previewSizeStr = 0;
char *awbStr = 0;
char *sceneStr = 0;
char *focusStr = 0;
char *flashStr = 0;
char *fpsstr = 0;
char *previewFormatStr = 0;
char *pictureFormatStr = 0;
char **modevalues = 0;
char **elem;
char **antiband = 0;
char **effectss = 0;
char **awb = 0;
char **scene = 0;
char **focus = 0;
char **flash = 0;
char **exposureMode = 0;
char **isoMode = 0;
char **previewFormatArray = 0;
char **pictureFormatArray = 0;
char **fps_const_str = 0;
char **rangeDescription = 0;
char **fps_range_str = 0;
param_Array ** capture_Array = 0;
param_Array ** Vcapture_Array = 0;
param_Array ** preview_Array = 0;
param_Array ** thumbnail_Array = 0;
fps_Array * fpsArray = 0;
int enableMisalignmentCorrectionIdx = 0;
char **autoconvergencemode = 0;
int numAutoConvergence = 0;
const char MeteringAreas[] = "(-656,-671,188,454,1)";
char **stereoLayout;
int numLay = 0;
char **stereoCapLayout;
int numCLay = 0;
int stereoLayoutIDX = 1;
int stereoCapLayoutIDX = 0;
char *layoutstr =0;
char *capturelayoutstr =0;
char output_dir_path[256];
char videos_dir_path[256 + 8];
char images_dir_path[256 + 8];
const char *cameras[] = {"Primary Camera", "Secondary Camera 1", "Stereo Camera"};
const char *measurement[] = {"disable", "enable"};
param_NamedExpBracketList_t expBracketing[] = {
{
"Disabled",
PARAM_EXP_BRACKET_PARAM_NONE,
PARAM_EXP_BRACKET_VALUE_NONE,
PARAM_EXP_BRACKET_APPLY_NONE,
"0"
},
{
"Relative exposure compensation",
PARAM_EXP_BRACKET_PARAM_COMP,
PARAM_EXP_BRACKET_VALUE_REL,
PARAM_EXP_BRACKET_APPLY_ADJUST,
"-300,-150,0,150,300,150,0,-150,-300"
},
{
"Relative exposure compensation (forced)",
PARAM_EXP_BRACKET_PARAM_COMP,
PARAM_EXP_BRACKET_VALUE_REL,
PARAM_EXP_BRACKET_APPLY_FORCED,
"-300F,-150F,0F,150F,300F,150F,0F,-150F,-300F"
},
{
"Absolute exposure and gain",
PARAM_EXP_BRACKET_PARAM_PAIR,
PARAM_EXP_BRACKET_VALUE_ABS,
PARAM_EXP_BRACKET_APPLY_ADJUST,
"(33000,10),(0,70),(33000,100),(0,130),(33000,160),(0,180),(33000,200),(0,130),(33000,200)"
},
{
"Absolute exposure and gain (forced)",
PARAM_EXP_BRACKET_PARAM_PAIR,
PARAM_EXP_BRACKET_VALUE_ABS,
PARAM_EXP_BRACKET_APPLY_FORCED,
"(33000,10)F,(0,70)F,(33000,100)F,(0,130)F,(33000,160)F,(0,180)F,(33000,200)F,(0,130)F,(33000,200)F"
},
{
"Relative exposure and gain",
PARAM_EXP_BRACKET_PARAM_PAIR,
PARAM_EXP_BRACKET_VALUE_REL,
PARAM_EXP_BRACKET_APPLY_ADJUST,
"(-300,-100),(-300,+0),(-100, +0),(-100,+100),(+0,+0),(+100,-100),(+100,+0),(+300,+0),(+300,+100)"
},
{
"Relative exposure and gain (forced)",
PARAM_EXP_BRACKET_PARAM_PAIR,
PARAM_EXP_BRACKET_VALUE_REL,
PARAM_EXP_BRACKET_APPLY_FORCED,
"(-300,-100)F,(-300,+0)F,(-100, +0)F,(-100,+100)F,(+0,+0)F,(+100,-100)F,(+100,+0)F,(+300,+0)F,(+300,+100)F"
},
};
const char *tempBracketing[] = {"false", "true"};
const char *faceDetection[] = {"disable", "enable"};
const char *afTimeout[] = {"enable", "disable" };
const char *misalignmentCorrection[] = {"enable", "disable" };
#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 *caf [] = { "Off", "On" };
int numCamera = 0;
bool stereoMode = false;
int manualExp = 0;
int manualExpMin = 0;
int manualExpMax = 0;
int manualExpStep = 0;
int manualGain = 0;
int manualGainMin = 0;
int manualGainMax = 0;
int manualGainStep = 0;
int manualConv = 0;
int manualConvMin = 0;
int manualConvMax = 0;
int manualConvStep = 0;
param_Array 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"},
{ 240, 160,"240x160"},
{ 768, 576, "768x576" },
{ 960, 720, "960x720"},
{ 256, 96,"SQCIF"},// stereo
{ 128, 192, "SQCIF"},
{ 352, 144,"QCIF"},
{ 176, 288, "QCIF"},
{ 480, 160, "240x160"},
{ 240, 320, "240x160"},
{ 704, 288, "CIF"},
{ 352, 576, "CIF"},
{ 640, 240,"QVGA"},
{ 320, 480, "QVGA"},
{ 1280, 480,"VGA"},
{ 640, 960, "VGA"},
{ 1536, 576,"768x576"},
{ 768, 1152, "768x576"},
{ 1440, 480,"NTSC"},
{ 720, 960,"NTSC"},
{ 1440, 576, "PAL"},
{ 720, 1152, "PAL"},
{ 1600, 480, "WVGA"},
{ 800, 960,"WVGA"},
{ 2560, 720, "HD"},
{ 1280, 1440, "HD"}
};
size_t length_previewSize = ARRAY_SIZE(previewSize);
param_Array thumbnailSize [] = {
{ 0, 0, "NULL"},
{ 128, 96, "SQCIF" },
{ 176, 144, "QCIF" },
{ 352, 288, "CIF" },
{ 320, 240, "QVGA" },
{ 352, 288, "CIF" },
{ 640, 480, "VGA" },
};
size_t length_thumbnailSize = ARRAY_SIZE(thumbnailSize);
param_Array VcaptureSize [] = {
{ 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" },
#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
{ 848, 480, "WVGA2"},
{ 864, 480, "WVGA3"},
{ 992, 560, "WVGA4"},
#endif
{ 1280, 720, "HD" },
{ 1920, 1080, "FULLHD"},
{ 240, 160,"240x160"},
{ 768, 576, "768x576" },
{ 960, 720, "960x720"},
{ 256, 96,"SQCIF"},// stereo
{ 128, 192, "SQCIF"},
{ 352, 144,"QCIF"},
{ 176, 288, "QCIF"},
{ 480, 160, "240x160"},
{ 240, 320, "240x160"},
{ 704, 288, "CIF"},
{ 352, 576, "CIF"},
{ 640, 240,"QVGA"},
{ 320, 480, "QVGA"},
{ 1280, 480,"VGA"},
{ 640, 960, "VGA"},
{ 1536, 576,"768x576"},
{ 768, 1152, "768x576"},
{ 1440, 480,"NTSC"},
{ 720, 960,"NTSC"},
{ 1440, 576, "PAL"},
{ 720, 1152, "PAL"},
{ 1600, 480, "WVGA"},
{ 800, 960,"WVGA"},
{ 2560, 720, "HD"},
{ 1280, 1440, "HD"}
};
size_t lenght_Vcapture_size = ARRAY_SIZE(VcaptureSize);
param_Array captureSize[] = {
{ 320, 240, "QVGA" },
{ 640, 480, "VGA" },
{ 800, 600, "SVGA" },
{ 1152, 864, "1MP" },
{ 1280, 1024, "1.3MP" },
{ 1600, 1200, "2MP" },
{ 2016, 1512, "3MP" },
{ 2592, 1944, "5MP" },
{ 2608, 1960, "5MP" },
{ 3264, 2448, "8MP" },
{ 3648, 2736, "10MP"},
{ 4032, 3024, "12MP"},
{ 640, 240, "QVGA"}, //stereo
{ 320, 480, "QVGA"},
{ 1280, 480, "VGA"},
{ 640, 960, "VGA"},
{ 2560, 960, "1280x960"},
{ 1280, 1920, "1280x960"},
{ 2304, 864, "1MP"},
{ 1152, 1728, "1MP"},
{ 2560, 1024, "1.3MP"},
{ 1280, 2048, "1.3MP"},
{ 3200, 1200, "2MP"},
{ 1600, 2400, "2MP"},
{ 4096, 1536, "3MP"},
{ 2048, 3072, "3MP"}
};
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_HE_AAC, "AAC+" },
{ AUDIO_ENCODER_LIST_END, "disabled"},
};
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" },
{ 28, "2.5x"},
{ 32, "3x" },
{ 36, "3.5x"},
{ 40, "4x" },
{ 60, "8x" },
};
size_t length_Zoom = ARRAY_SIZE(zoom);
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, CameraParameters::PIXEL_FORMAT_BAYER_RGGB },
};
const char *gbce[] = {"disable", "enable"};
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 stressTest = false;
bool stopScript = false;
int restartCount = 0;
bool firstTime = true;
bool firstTimeStereo = true;
//TI extensions for enable/disable algos
const char *algoFixedGamma[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoNSF1[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoNSF2[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoSharpening[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoThreeLinColorMap[] = {CameraParameters::FALSE, CameraParameters::TRUE};
const char *algoGIC[] = {CameraParameters::FALSE, CameraParameters::TRUE};
int algoFixedGammaIDX = 1;
int algoNSF1IDX = 1;
int algoNSF2IDX = 1;
int algoSharpeningIDX = 1;
int algoThreeLinColorMapIDX = 1;
int algoGICIDX = 1;
/** Buffer source reset */
bool bufferSourceInputReset = false;
bool bufferSourceOutputReset = false;
/** 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[384];
LOG_FUNCTION_NAME;
if (mem == NULL)
goto out;
if( strcmp(modevalues[capture_mode], "cp-cam") ) {
//Start preview after capture.
camera->startPreview();
}
fn[0] = 0;
sprintf(fn, "%s/img%03d.raw", images_dir_path, counter);
fd = open(fn, O_CREAT | O_WRONLY | 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[384];
LOG_FUNCTION_NAME;
if (mem == NULL)
goto out;
fn[0] = 0;
sprintf(fn, "%s/preview%03d.yuv", images_dir_path, counter);
fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777);
if(fd < 0) {
CAMHAL_LOGE("Unable to open file %s: %s", fn, strerror(fd));
goto out;
}
size = mem->size();
if (size <= 0) {
CAMHAL_LOGE("IMemory object is of zero size");
goto out;
}
buff = (unsigned char *)mem->pointer();
if (!buff) {
CAMHAL_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[384];
LOG_FUNCTION_NAME;
if( strcmp(modevalues[capture_mode], "cp-cam")) {
if(burstCount > 1) {
burstCount --;
// Restart preview if taking a single capture
// or after the last iteration of burstCount
} else if(burstCount == 0 || burstCount == 1) {
camera->startPreview();
burstCount = burst;
}
}
if (mem == NULL)
goto out;
fn[0] = 0;
sprintf(fn, "%s/img%03d.jpg", images_dir_path, counter);
fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777);
if(fd < 0) {
CAMHAL_LOGE("Unable to open file %s: %s", fn, strerror(fd));
goto out;
}
size = mem->size();
if (size <= 0) {
CAMHAL_LOGE("IMemory object is of zero size");
goto out;
}
buff = (unsigned char *)mem->pointer();
if (!buff) {
CAMHAL_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) {
int32_t msgMask;
printf("Data cb: %d\n", msgType);
if ( msgType & CAMERA_MSG_PREVIEW_FRAME )
my_preview_callback(dataPtr);
msgMask = CAMERA_MSG_RAW_IMAGE;
#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
msgMask |= CAMERA_MSG_RAW_BURST;
#endif
if ( msgType & msgMask) {
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 ) ) {
if (metaDataToggle) {
printf("Preview exposure: %6d Preview gain: %4d\n",
metadata->exposure_time, metadata->analog_gain);
}
if (faceDetectToggle) {
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)
{
static uint32_t count = 0;
//if(count==100)
//saveFile(dataPtr);
count++;
uint8_t *ptr = (uint8_t*) dataPtr->pointer();
#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
if ( msgType & CAMERA_MSG_RAW_BURST) {
printf("RAW done timestamp: %llu\n", timestamp);
my_raw_callback(dataPtr);
} else
#endif
{
printf("Recording cb: %d %lld %p\n", msgType, timestamp, dataPtr.get());
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;
DisplayInfo dinfo;
SurfaceComposerClient::getDisplayInfo(0, &dinfo);
const unsigned MAX_PREVIEW_SURFACE_WIDTH = dinfo.w;
const unsigned MAX_PREVIEW_SURFACE_HEIGHT = dinfo.h;
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(0x7fffffff);
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 Video Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
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 ISO Modes: %s", params.get("iso-mode-values"));
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));
printf("\n\r\tSupported Metering Areas: %d", params.getInt(CameraParameters::KEY_MAX_NUM_METERING_AREAS));
printf("\n\r\tSupported Preview FPS Range: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE));
printf("\n\r\tSupported Exposure modes: %s", params.get("exposure-mode-values"));
printf("\n\r\tSupported VSTAB modes: %s", params.get(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED));
printf("\n\r\tSupported VNF modes: %s", params.get("vnf-supported"));
printf("\n\r\tSupported AutoExposureLock: %s", params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED));
printf("\n\r\tSupported AutoWhiteBalanceLock: %s", params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED));
printf("\n\r\tSupported Zoom: %s", params.get(CameraParameters::KEY_ZOOM_SUPPORTED));
printf("\n\r\tSupported Smooth Zoom: %s", params.get(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED));
printf("\n\r\tSupported Video Snapshot: %s", params.get(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED));
printf("\n\r\tSupported Capture modes: %s", params.get("mode-values"));
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[384],vbit_string[50];
videoFd = -1;
struct CameraInfo cameraInfo;
camera->getCameraInfo(camera_index, &cameraInfo);
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 ( AUDIO_ENCODER_LIST_END != audioCodecs[audioCodecIDX].type ) {
if ( recorder->setAudioSource(AUDIO_SOURCE_DEFAULT) < 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;
}
sprintf(videoFile, "%s/video%d.%s", videos_dir_path, 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 (cameraInfo.orientation == 90 || cameraInfo.orientation == 270 ) {
if ( recorder->setVideoSize(Vcapture_Array[VcaptureSizeIDX]->height, Vcapture_Array[VcaptureSizeIDX]->width) < 0 ) {
printf("error while configuring video size\n");
return -1;
}
} else {
if ( recorder->setVideoSize(Vcapture_Array[VcaptureSizeIDX]->width, Vcapture_Array[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 ( AUDIO_ENCODER_LIST_END != audioCodecs[audioCodecIDX].type ) {
if ( recorder->setAudioEncoder(audioCodecs[audioCodecIDX].type) < 0 ) {
printf("error while configuring audio codec\n");
return -1;
}
}
if ( recorder->setPreviewSurface( surfaceControl->getSurface()->getIGraphicBufferProducer() ) < 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() {
antibandStr = new char [256];
effectssStr = new char [256];
exposureModeStr = new char [256];
captureSizeStr = new char [500];
VcaptureSizeStr = new char [500];
previewSizeStr = new char [500];
thumbnailSizeStr = new char [500];
awbStr = new char [400];
sceneStr = new char [400];
isoModeStr = new char [256];
focusStr = new char [256];
flashStr = new char [256];
fpsstr = new char [256];
previewFormatStr = new char [256];
pictureFormatStr = new char [256];
constFramerate = new int[32];
vstabstr = new char[256];
vnfstr = new char[256];
AutoExposureLockstr = new char[256];
AutoWhiteBalanceLockstr = new char[256];
zoomstr = new char[256];
smoothzoomstr = new char[256];
modevaluesstr = new char[256];
videosnapshotstr = new char[256];
autoconvergencestr = new char[256];
layoutstr = new char[256];
capturelayoutstr = new char[256];
requestBufferSourceReset();
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;
}
}
if ( firstTime ) {
params = camera->getParameters();
firstTime = false;
}
getParametersFromCapabilities();
getSizeParametersFromCapabilities();
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;
}
deleteAllocatedMemory();
camera->disconnect();
camera.clear();
hardwareActive = false;
return 0;
}
void createBufferOutputSource() {
if(bufferSourceOutputThread.get() && bufferSourceOutputReset) {
bufferSourceOutputThread->requestExit();
bufferSourceOutputThread.clear();
}
if(!bufferSourceOutputThread.get()) {
#ifdef ANDROID_API_JB_OR_LATER
bufferSourceOutputThread = new BQ_BufferSourceThread(123, camera);
#else
bufferSourceOutputThread = new ST_BufferSourceThread(false, 123, camera);
#endif
bufferSourceOutputThread->run();
}
bufferSourceOutputReset = false;
}
void createBufferInputSource() {
if (bufferSourceInput.get() && bufferSourceInputReset) {
bufferSourceInput.clear();
}
if (!bufferSourceInput.get()) {
#ifdef ANDROID_API_JB_OR_LATER
bufferSourceInput = new BQ_BufferSourceInput(1234, camera);
#else
bufferSourceInput = new ST_BufferSourceInput(1234, camera);
#endif
}
bufferSourceInputReset = false;
}
void requestBufferSourceReset() {
bufferSourceInputReset = true;
bufferSourceOutputReset = true;
}
int startPreview() {
int previewWidth, previewHeight;
struct CameraInfo cameraInfo;
DisplayInfo dinfo;
int orientation;
unsigned int correctedHeight;
SurfaceComposerClient::getDisplayInfo(0, &dinfo);
printf ("dinfo.orientation = %d\n", dinfo.orientation);
printf ("dinfo.w = %d\n", dinfo.w);
printf ("dinfo.h = %d\n", dinfo.h);
// calculate display orientation from sensor orientation
camera->getCameraInfo(camera_index, &cameraInfo);
if (cameraInfo.facing == CAMERA_FACING_FRONT) {
orientation = (cameraInfo.orientation + dinfo.orientation) % 360;
orientation = (360 - orientation) % 360; // compensate the mirror
} else { // back-facing
orientation = (cameraInfo.orientation - dinfo.orientation + 360) % 360;
}
if (reSizePreview) {
int orientedWidth, orientedHeight;
if(recordingMode)
{
previewWidth = Vcapture_Array[VcaptureSizeIDX]->width;
previewHeight = Vcapture_Array[VcaptureSizeIDX]->height;
}else
{
previewWidth = preview_Array[previewSizeIDX]->width;
previewHeight = preview_Array[previewSizeIDX]->height;
}
// corrected height for aspect ratio
if ((orientation == 90) || (orientation == 270)) {
orientedHeight = previewWidth;
orientedWidth = previewHeight;
} else {
orientedHeight = previewHeight;
orientedWidth = previewWidth;
}
correctedHeight = (dinfo.w * orientedHeight) / orientedWidth;
printf("correctedHeight = %d", correctedHeight);
if ( createPreviewSurface(dinfo.w, correctedHeight,
pixelformat[previewFormat].pixelFormatDesc) < 0 ) {
printf("Error while creating preview surface\n");
return -1;
}
if ( !hardwareActive ) {
openCamera();
}
if(stereoMode && firstTimeStereo)
{
params.set(KEY_S3D_PRV_FRAME_LAYOUT, stereoLayout[stereoLayoutIDX]);
params.set(KEY_S3D_CAP_FRAME_LAYOUT, stereoCapLayout[stereoCapLayoutIDX]);
}
if ((cameraInfo.orientation == 90 || cameraInfo.orientation == 270) && recordingMode) {
params.setPreviewSize(previewHeight, previewWidth);
} else {
params.setPreviewSize(previewWidth, previewHeight);
}
params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
// calculate display orientation from sensor orientation
camera->getCameraInfo(camera_index, &cameraInfo);
if (cameraInfo.facing == CAMERA_FACING_FRONT) {
orientation = (cameraInfo.orientation + dinfo.orientation) % 360;
orientation= (360 - orientation) % 360; // compensate the mirror
} else { // back-facing
orientation = (cameraInfo.orientation - dinfo.orientation + 360) % 360;
}
if(!strcmp(params.get(KEY_MODE), "video-mode") ) {
orientation = 0;
}
camera->sendCommand(CAMERA_CMD_SET_DISPLAY_ORIENTATION, orientation, 0);
camera->setParameters(params.flatten());
camera->setPreviewTexture(previewSurface->getIGraphicBufferProducer());
}
if(hardwareActive) prevcnt = 0;
camera->startPreview();
previewRunning = true;
reSizePreview = false;
const char *format = params.getPictureFormat();
if((NULL != format) && isRawPixelFormat(format)) {
createBufferOutputSource();
createBufferInputSource();
}
return 0;
}
int getParametersFromCapabilities() {
const char *valstr = NULL;
numCamera = camera->getNumberOfCameras();
params.unflatten(camera->getParameters());
valstr = params.get(KEY_AUTOCONVERGENCE_MODE_VALUES);
if (NULL != valstr) {
strcpy(autoconvergencestr, valstr);
getSupportedParameters(autoconvergencestr,&numAutoConvergence,(char***)&autoconvergencemode);
} else {
printf("no supported parameteters for autoconvergence\n\t");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_EFFECTS);
if (NULL != valstr) {
strcpy(effectssStr, valstr);
getSupportedParameters(effectssStr, &numEffects, (char***)&effectss);
} else {
printf("Color effects are not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING);
if (NULL != valstr) {
strcpy(antibandStr, valstr);
getSupportedParameters(antibandStr, &numAntibanding, (char***)&antiband);
} else {
printf("Antibanding not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE);
if (NULL != valstr) {
strcpy(awbStr, valstr);
getSupportedParameters(awbStr, &numawb, (char***)&awb);
} else {
printf("White balance is not supported\n");
}
valstr = params.get(KEY_S3D_PRV_FRAME_LAYOUT_VALUES);
if ((NULL != valstr) && (0 != strcmp(valstr, "none"))) {
stereoMode = true;
strcpy(layoutstr, valstr);
getSupportedParameters(layoutstr,&numLay,(char***)&stereoLayout);
} else {
stereoMode = false;
printf("layout is not supported\n");
}
valstr = params.get(KEY_S3D_CAP_FRAME_LAYOUT_VALUES);
if ((NULL != valstr) && (0 != strcmp(valstr, "none"))) {
strcpy(capturelayoutstr, valstr);
getSupportedParameters(capturelayoutstr,&numCLay,(char***)&stereoCapLayout);
} else {
printf("capture layout is not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES);
if (NULL != valstr) {
strcpy(sceneStr, valstr);
getSupportedParameters(sceneStr, &numscene, (char***)&scene);
} else {
printf("Scene modes are not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES);
if (NULL != valstr) {
strcpy(focusStr, valstr);
getSupportedParameters(focusStr, &numfocus, (char***)&focus);
} else {
printf("Focus modes are not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
if (NULL != valstr) {
strcpy(flashStr, valstr);
getSupportedParameters(flashStr, &numflash, (char***)&flash);
} else {
printf("Flash modes are not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
if (NULL != valstr) {
strcpy(VcaptureSizeStr, valstr);
getSupportedParametersVideoCaptureSize(VcaptureSizeStr, &numVcaptureSize, VcaptureSize, lenght_Vcapture_size);
} else {
printf("Preview sizes are not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE);
if (NULL != valstr) {
strcpy(fpsstr, valstr);
getSupportedParametersfps(fpsstr, &numfps);
} else {
printf("Preview fps range is not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
if (NULL != valstr) {
strcpy(previewFormatStr, valstr);
getSupportedParameters(previewFormatStr, &numpreviewFormat, (char ***)&previewFormatArray);
} else {
printf("Preview formats are not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS);
if (NULL != valstr) {
strcpy(pictureFormatStr, valstr);
getSupportedParameters(pictureFormatStr, &numpictureFormat, (char ***)&pictureFormatArray);
} else {
printf("Picture formats are not supported\n");
}
valstr = params.get("exposure-mode-values");
if (NULL != valstr) {
strcpy(exposureModeStr, valstr);
getSupportedParameters(exposureModeStr, &numExposureMode, (char***)&exposureMode);
} else {
printf("Exposure modes are not supported\n");
}
valstr = params.get("iso-mode-values");
if (NULL != valstr) {
strcpy(isoModeStr, valstr);
getSupportedParameters(isoModeStr, &numisoMode , (char***)&isoMode);
} else {
printf("iso modes are not supported\n");
}
valstr = params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES);
if (NULL != valstr) {
strcpy(thumbnailSizeStr, valstr);
getSupportedParametersThumbnailSize(thumbnailSizeStr, &numthumbnailSize, thumbnailSize, length_thumbnailSize);
} else {
printf("Thumbnail sizes are not supported\n");
}
valstr = params.get(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED);
if (NULL != valstr) {
strcpy(vstabstr, valstr);
} else {
printf("VSTAB is not supported\n");
}
valstr = params.get("vnf-supported");
if (NULL != valstr) {
strcpy(vnfstr, valstr);
} else {
printf("VNF is not supported\n");
}
valstr = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED);
if (NULL != valstr) {
strcpy(AutoExposureLockstr, valstr);
} else {
printf("AutoExposureLock is not supported\n");
}
valstr = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED);
if (NULL != valstr) {
strcpy(AutoWhiteBalanceLockstr, valstr);
} else {
printf("AutoWhiteBalanceLock is not supported\n");
}
valstr = params.get(CameraParameters::KEY_ZOOM_SUPPORTED);
if (NULL != valstr) {
strcpy(zoomstr, valstr);
} else {
printf("Zoom is not supported\n");
}
valstr = params.get(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED);
if (NULL != valstr) {
strcpy(smoothzoomstr, valstr);
} else {
printf("SmoothZoom is not supported\n");
}
valstr = params.get("mode-values");
if (NULL != valstr) {
strcpy(modevaluesstr, valstr);
getSupportedParameters(modevaluesstr, &nummodevalues , (char***)&modevalues);
} else {
printf("Mode values is not supported\n");
}
valstr = params.get(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED);
if (NULL != valstr) {
strcpy(videosnapshotstr, valstr);
} else {
printf("Video Snapshot is not supported\n");
}
if (params.get(KEY_SUPPORTED_MANUAL_CONVERGENCE_MIN) != NULL) {
manualConvMin = params.getInt(KEY_SUPPORTED_MANUAL_CONVERGENCE_MIN);
} else {
printf("no supported parameteters for manual convergence min\n\t");
}
if (params.get(KEY_SUPPORTED_MANUAL_CONVERGENCE_MAX) != NULL) {
manualConvMax = params.getInt(KEY_SUPPORTED_MANUAL_CONVERGENCE_MAX);
} else {
printf("no supported parameteters for manual convergence max\n\t");
}
if (params.get(KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP) != NULL) {
manualConvStep = params.getInt(KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP);
} else {
printf("no supported parameteters for manual convergence step\n\t");
}
if (params.get(KEY_SUPPORTED_MANUAL_EXPOSURE_MIN) != NULL) {
manualExpMin = params.getInt(KEY_SUPPORTED_MANUAL_EXPOSURE_MIN);
} else {
printf("no supported parameteters for manual exposure min\n\t");
}
if (params.get(KEY_SUPPORTED_MANUAL_EXPOSURE_MAX) != NULL) {
manualExpMax = params.getInt(KEY_SUPPORTED_MANUAL_EXPOSURE_MAX);
} else {
printf("no supported parameteters for manual exposure max\n\t");
}
if (params.get(KEY_SUPPORTED_MANUAL_EXPOSURE_STEP) != NULL) {
manualExpStep = params.getInt(KEY_SUPPORTED_MANUAL_EXPOSURE_STEP);
} else {
printf("no supported parameteters for manual exposure step\n\t");
}
if (params.get(KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN) != NULL) {
manualGainMin = params.getInt(KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN);
} else {
printf("no supported parameteters for manual gain min\n\t");
}
if (params.get(KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX) != NULL) {
manualGainMax = params.getInt(KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX);
} else {
printf("no supported parameteters for manual gain max\n\t");
}
if (params.get(KEY_SUPPORTED_MANUAL_GAIN_ISO_STEP) != NULL) {
manualGainStep = params.getInt(KEY_SUPPORTED_MANUAL_GAIN_ISO_STEP);
} else {
printf("no supported parameteters for manual gain step\n\t");
}
return 0;
}
void getSizeParametersFromCapabilities() {
if(!stereoMode) {
if (params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES) != NULL) {
strcpy(captureSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
} else {
printf("Picture sizes are not supported\n");
}
if (params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES) != NULL) {
strcpy(previewSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
strcpy(VcaptureSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
} else {
printf("Preview sizes are not supported\n");
}
} else { //stereo
if(strcmp(stereoLayout[stereoLayoutIDX],"tb-full") == 0)
{
if (params.get(KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES) != NULL) {
strcpy(previewSizeStr, params.get(KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES));
strcpy(VcaptureSizeStr, params.get(KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES));
} else {
printf("Preview sizes are not supported\n");
}
}
else if(strcmp(stereoLayout[stereoLayoutIDX],"ss-full") == 0)
{
if (params.get(KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES) != NULL) {
strcpy(previewSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES));
strcpy(VcaptureSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES));
} else {
printf("Preview sizes are not supported\n");
}
}
else if(strcmp(stereoLayout[stereoLayoutIDX],"tb-subsampled") == 0)
{
if (params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES) != NULL) {
strcpy(previewSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
strcpy(VcaptureSizeStr, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
} else {
printf("Preview sizes are not supported\n");
}
}
else if(strcmp(stereoLayout[stereoLayoutIDX],"ss-subsampled") == 0)
{
if (params.get(KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES) != NULL) {
strcpy(previewSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES));
strcpy(VcaptureSizeStr, params.get(KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES));
} else {
printf("Preview sizes are not supported\n");
}
}
else
{
printf("Preview sizes are not supported\n");
}
if(strcmp(stereoCapLayout[stereoCapLayoutIDX],"tb-full") == 0)
{
if (params.get(KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES) != NULL) {
strcpy(captureSizeStr, params.get(KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES));
} else {
printf("Picture sizes are not supported\n");
}
}
else if(strcmp(stereoCapLayout[stereoCapLayoutIDX],"ss-full") == 0)
{
if (params.get(KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES) != NULL) {
strcpy(captureSizeStr, params.get(KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES));
} else {
printf("Picture sizes are not supported\n");
}
}
else
{
printf("Picture sizes are not supported\n");
}
}
getSupportedParametersCaptureSize(captureSizeStr, &numcaptureSize, captureSize, length_capture_Size);
getSupportedParametersPreviewSize(previewSizeStr, &numpreviewSize, previewSize, length_previewSize);
getSupportedParametersVideoCaptureSize(VcaptureSizeStr, &numVcaptureSize, VcaptureSize, lenght_Vcapture_size);
}
int getDefaultParameter(const char* val, int numOptions, char **array) {
int cnt = 0;
if ((NULL == val) || (NULL == array)) {
printf("Some default parameters are not valid");
return 0;
}
for(cnt=0;cnt<numOptions;cnt++) {
if (NULL == array[cnt]) {
printf("Some parameter arrays are not valid");
continue;
}
if (strcmp(val, array[cnt]) ==0 ) {
return cnt;
}
}
return 0;
}
int getDefaultParameterResol(const char* val, int numOptions, param_Array **array) {
int cnt = 0;
for(cnt=0;cnt<numOptions;cnt++) {
if (strcmp(val, array[cnt]->name) ==0 ) {
return cnt;
}
}
return 0;
}
int getSupportedParameters(char* parameters, int *optionsCount, char ***elem) {
str = new char [400];
param = new char [400];
int cnt = 0;
strcpy(str, parameters);
param = strtok(str, ",");
*elem = new char*[30];
while (param != NULL) {
(*elem)[cnt] = new char[strlen(param) + 1];
strcpy((*elem)[cnt], param);
param = strtok (NULL, ",");
cnt++;
}
*optionsCount = cnt;
return 0;
}
int getSupportedParametersfps(char* parameters, int *optionsCount) {
str = new char [400];
param = new char [400];
int cnt = 0;
constCnt = 0;
rangeCnt = 0;
strcpy(str, parameters);
fps_const_str = new char*[32];
fps_range_str = new char*[32];
rangeDescription = new char*[32];
fpsArray = new fps_Array[50];
param = strtok(str, "(,)");
while (param != NULL) {
fps_const_str[constCnt] = new char;
fps_range_str[rangeCnt] = new char;
rangeDescription[rangeCnt] = new char;
fpsArray[cnt].rangeMin = atoi(param);
param = strtok (NULL, "(,)");
fpsArray[cnt].rangeMax = atoi(param);
param = strtok (NULL, "(,)");
if (fpsArray[cnt].rangeMin == fpsArray[cnt].rangeMax) {
sprintf(fps_const_str[constCnt], "%d,%d", fpsArray[cnt].rangeMin, fpsArray[cnt].rangeMax);
constFramerate[constCnt] = fpsArray[cnt].rangeMin/1000;
sprintf(fps_range_str[rangeCnt], "%d,%d", fpsArray[cnt].rangeMin, fpsArray[cnt].rangeMax);
sprintf(rangeDescription[rangeCnt], "[%d:%d]", fpsArray[cnt].rangeMin/1000, fpsArray[cnt].rangeMax/1000);
constCnt ++;
rangeCnt ++;
} else {
sprintf(fps_range_str[rangeCnt], "%d,%d", fpsArray[cnt].rangeMin, fpsArray[cnt].rangeMax);
sprintf(rangeDescription[rangeCnt], "[%d:%d]", fpsArray[cnt].rangeMin/1000, fpsArray[cnt].rangeMax/1000);
rangeCnt ++;
}
cnt++;
}
*optionsCount = cnt;
return 0;
}
int getSupportedParametersCaptureSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
str = new char [400];
param = new char [400];
int cnt = 0;
strcpy(str, parameters);
param = strtok(str, ",x");
capture_Array = new param_Array*[50];
while (param != NULL) {
capture_Array[cnt] = new param_Array;
capture_Array[cnt]->width = atoi(param);
param = strtok (NULL, ",x");
capture_Array[cnt]->height = atoi(param);
param = strtok (NULL, ",x");
int x = getSupportedParametersNames(capture_Array[cnt]->width,
capture_Array[cnt]->height, array, arraySize);
if (x > -1) {
strcpy(capture_Array[cnt]->name, array[x].name);
} else {
strcpy(capture_Array[cnt]->name, "Needs to be added/Not supported");
}
cnt++;
}
*optionsCount = cnt;
return 0;
}
int getSupportedParametersVideoCaptureSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
str = new char [800];
param = new char [800];
int cnt = 0;
strcpy(str, parameters);
param = strtok(str, ",x");
Vcapture_Array = new param_Array*[100];
while (param != NULL) {
Vcapture_Array[cnt] = new param_Array;
Vcapture_Array[cnt]->width = atoi(param);
param = strtok (NULL, ",x");
Vcapture_Array[cnt]->height = atoi(param);
param = strtok (NULL, ",x");
int x = getSupportedParametersNames(Vcapture_Array[cnt]->width,
Vcapture_Array[cnt]->height, array, arraySize);
if (x > -1) {
strcpy(Vcapture_Array[cnt]->name, array[x].name);
} else {
strcpy(Vcapture_Array[cnt]->name, "Needs to be added/Not supported");
}
cnt++;
}
*optionsCount = cnt;
return 0;
}
int getSupportedParametersPreviewSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
str = new char [500];
param = new char [500];
int cnt = 0;
strcpy(str, parameters);
param = strtok(str, ",x");
preview_Array = new param_Array*[60];
while (param != NULL) {
preview_Array[cnt] = new param_Array;
preview_Array[cnt]->width = atoi(param);
param = strtok (NULL, ",x");
preview_Array[cnt]->height = atoi(param);
param = strtok (NULL, ",x");
int x = getSupportedParametersNames(preview_Array[cnt]->width,
preview_Array[cnt]->height, array, arraySize);
if (x > -1) {
strcpy(preview_Array[cnt]->name, array[x].name);
} else {
strcpy(preview_Array[cnt]->name, "Needs to be added/Not supported");
}
cnt++;
}
*optionsCount = cnt;
return 0;
}
int getSupportedParametersThumbnailSize(char* parameters, int *optionsCount, param_Array array[], int arraySize) {
str = new char [500];
param = new char [500];
int cnt = 0;
strcpy(str, parameters);
param = strtok(str, ",x");
thumbnail_Array = new param_Array*[60];
while (param != NULL) {
thumbnail_Array[cnt] = new param_Array;
thumbnail_Array[cnt]->width = atoi(param);
param = strtok (NULL, ",x");
thumbnail_Array[cnt]->height = atoi(param);
param = strtok (NULL, ",x");
int x = getSupportedParametersNames(thumbnail_Array[cnt]->width,
thumbnail_Array[cnt]->height, array, arraySize);
if (x > -1) {
strcpy(thumbnail_Array[cnt]->name, array[x].name);
} else {
strcpy(thumbnail_Array[cnt]->name, "Needs to be added/Not supported");
}
cnt++;
}
*optionsCount = cnt;
return 0;
}
int getSupportedParametersNames(int width, int height, param_Array array[], int arraySize) {
for (int i = 0; i<arraySize; i++) {
if ((width == array[i].width) && (height == array[i].height)) {
return (i);
}
}
return -1;
}
int deleteAllocatedMemory() {
int i;
for (i=0; i<numAntibanding; i++){
delete [] antiband[i];
}
for (i=0; i<numEffects; i++){
delete [] effectss[i];
}
for (i=0; i<numExposureMode; i++){
delete [] exposureMode[i];
}
for (i=0; i<numawb; i++) {
delete [] awb[i];
}
for (i=0; i<numscene; i++){
delete [] scene[i];
}
for (i=0; i<numfocus; i++){
delete [] focus[i];
}
for (i=0; i<numflash; i++){
delete [] flash[i];
}
for (i=0; i<numpreviewSize; i++){
delete [] preview_Array[i];
}
for (i=0; i<numcaptureSize; i++){
delete [] capture_Array[i];
}
for (i=0; i<numVcaptureSize; i++){
delete [] Vcapture_Array[i];
}
for (i=0; i<numthumbnailSize; i++){
delete [] thumbnail_Array[i];
}
for (i=0; i<constCnt; i++){
delete [] fps_const_str[i];
}
for (i=0; i<rangeCnt; i++){
delete [] fps_range_str[i];
}
for (i=0; i<rangeCnt; i++){
delete [] rangeDescription[i];
}
for (i=0; i<numpreviewFormat; i++){
delete [] previewFormatArray[i];
}
for (i=0; i<numpictureFormat; i++){
delete [] pictureFormatArray[i];
}
for (i=0; i<nummodevalues; i++){
delete [] modevalues[i];
}
if (numLay) {
for (i = 0; i < numLay; i++) {
delete [] stereoLayout[i];
}
numLay = 0;
}
if (numCLay) {
for (i = 0; i < numCLay; i++) {
delete [] stereoCapLayout[i];
}
numCLay = 0;
}
delete [] antibandStr;
delete [] effectssStr;
delete [] exposureModeStr;
delete [] awbStr;
delete [] sceneStr;
delete [] focusStr;
delete [] flashStr;
delete [] previewSizeStr;
delete [] captureSizeStr;
delete [] VcaptureSizeStr;
delete [] thumbnailSizeStr;
delete [] fpsstr;
delete [] previewFormatStr;
delete [] pictureFormatStr;
delete [] fpsArray;
delete [] vstabstr;
delete [] vnfstr;
delete [] isoModeStr;
delete [] AutoExposureLockstr;
delete [] AutoWhiteBalanceLockstr;
delete [] zoomstr;
delete [] smoothzoomstr;
delete [] modevaluesstr;
delete [] videosnapshotstr;
delete [] autoconvergencestr;
delete [] layoutstr;
delete [] capturelayoutstr;
// Release buffer sources if any
if (bufferSourceOutputThread.get()) {
bufferSourceOutputThread->requestExit();
bufferSourceOutputThread.clear();
}
if ( bufferSourceInput.get() ) {
bufferSourceInput.clear();
}
return 0;
}
int trySetVideoStabilization(bool toggle) {
if (strcmp(vstabstr, "true") == 0) {
params.set(params.KEY_VIDEO_STABILIZATION, toggle ? params.TRUE : params.FALSE);
return 0;
}
return 0;
}
int trySetVideoNoiseFilter(bool toggle) {
if (strcmp(vnfstr, "true") == 0) {
params.set("vnf", toggle ? params.TRUE : params.FALSE);
return 0;
}
return 0;
}
int trySetAutoExposureLock(bool toggle) {
if (strcmp(AutoExposureLockstr, "true") == 0) {
params.set(KEY_AUTO_EXPOSURE_LOCK, toggle ? params.TRUE : params.FALSE);
return 0;
}
return 0;
}
int trySetAutoWhiteBalanceLock(bool toggle) {
if (strcmp(AutoWhiteBalanceLockstr, "true") == 0) {
params.set(KEY_AUTO_WHITEBALANCE_LOCK, toggle ? params.TRUE : params.FALSE);
return 0;
}
return 0;
}
bool isRawPixelFormat (const char *format) {
bool ret = false;
if ((0 == strcmp (format, CameraParameters::PIXEL_FORMAT_YUV422I)) ||
(0 == strcmp (format, CameraParameters::PIXEL_FORMAT_YUV420SP)) ||
(0 == strcmp (format, CameraParameters::PIXEL_FORMAT_RGB565)) ||
(0 == strcmp (format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB))) {
ret = true;
}
return ret;
}
void stopPreview() {
if ( hardwareActive ) {
camera->stopPreview();
destroyPreviewSurface();
previewRunning = false;
reSizePreview = true;
}
}
void initDefaults() {
struct CameraInfo cameraInfo;
camera->getCameraInfo(camera_index, &cameraInfo);
if (cameraInfo.facing == CAMERA_FACING_FRONT) {
rotation = cameraInfo.orientation;
} else { // back-facing
rotation = cameraInfo.orientation;
}
antibanding_mode = getDefaultParameter("off", numAntibanding, antiband);
focus_mode = getDefaultParameter("auto", numfocus, focus);
fpsRangeIdx = getDefaultParameter("5000,30000", rangeCnt, fps_range_str);
afTimeoutIdx = 0;
previewSizeIDX = getDefaultParameterResol("VGA", numpreviewSize, preview_Array);
captureSizeIDX = getDefaultParameterResol("12MP", numcaptureSize, capture_Array);
frameRateIDX = getDefaultParameter("30000,30000", constCnt, fps_const_str);
VcaptureSizeIDX = getDefaultParameterResol("HD", numVcaptureSize, Vcapture_Array);
VbitRateIDX = 0;
thumbSizeIDX = getDefaultParameterResol("VGA", numthumbnailSize, thumbnail_Array);
compensation = 0.0;
awb_mode = getDefaultParameter("auto", numawb, awb);
effects_mode = getDefaultParameter("none", numEffects, effectss);
scene_mode = getDefaultParameter("auto", numscene, scene);
caf_mode = 0;
shotConfigFlush = false;
streamCapture = false;
vstabtoggle = false;
vnftoggle = false;
AutoExposureLocktoggle = false;
AutoWhiteBalanceLocktoggle = false;
faceDetectToggle = false;
metaDataToggle = false;
expBracketIdx = BRACKETING_IDX_DEFAULT;
flashIdx = getDefaultParameter("off", numflash, flash);
previewRotation = 0;
zoomIDX = 0;
videoCodecIDX = 0;
gbceIDX = 0;
glbceIDX = 0;
contrast = 100;
#ifdef TARGET_OMAP4
///Temporary fix until OMAP3 and OMAP4 3A values are synced
brightness = 50;
sharpness = 100;
#else
brightness = 100;
sharpness = 0;
#endif
saturation = 100;
iso_mode = getDefaultParameter("auto", numisoMode, isoMode);
capture_mode = getDefaultParameter("high-quality", nummodevalues, modevalues);
exposure_mode = getDefaultParameter("auto", numExposureMode, exposureMode);
ippIDX = 0;
ippIDX_old = ippIDX;
jpegQuality = 85;
bufferStarvationTest = 0;
meter_mode = 0;
previewFormat = getDefaultParameter("yuv420sp", numpreviewFormat, previewFormatArray);
pictureFormat = getDefaultParameter("jpeg", numpictureFormat, pictureFormatArray);
stereoCapLayoutIDX = 0;
stereoLayoutIDX = 1;
manualConv = 0;
manualExp = manualExpMin;
manualGain = manualGainMin;
algoFixedGammaIDX = 1;
algoNSF1IDX = 1;
algoNSF2IDX = 1;
algoSharpeningIDX = 1;
algoThreeLinColorMapIDX = 1;
algoGICIDX = 1;
params.set(params.KEY_VIDEO_STABILIZATION, params.FALSE);
params.set("vnf", params.FALSE);
params.setPreviewSize(preview_Array[previewSizeIDX]->width, preview_Array[previewSizeIDX]->height);
params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
params.set(CameraParameters::KEY_ROTATION, rotation);
params.set(KEY_SENSOR_ORIENTATION, previewRotation);
params.set(KEY_COMPENSATION, (int) (compensation * 10));
params.set(params.KEY_WHITE_BALANCE, awb[awb_mode]);
params.set(KEY_MODE, (modevalues[capture_mode]));
params.set(params.KEY_SCENE_MODE, scene[scene_mode]);
params.set(KEY_CAF, caf_mode);
params.set(KEY_ISO, isoMode[iso_mode]);
params.set(KEY_GBCE, gbce[gbceIDX]);
params.set(KEY_GLBCE, gbce[glbceIDX]);
params.set(KEY_SHARPNESS, sharpness);
params.set(KEY_CONTRAST, contrast);
params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
params.set(KEY_EXPOSURE, exposureMode[exposure_mode]);
params.set(KEY_BRIGHTNESS, brightness);
params.set(KEY_SATURATION, saturation);
params.set(params.KEY_EFFECT, effectss[effects_mode]);
params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
params.set(params.KEY_ANTIBANDING, antiband[antibanding_mode]);
params.set(params.KEY_FOCUS_MODE, focus[focus_mode]);
params.set(KEY_IPP, ipp_mode[ippIDX]);
params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
params.setPreviewFormat(previewFormatArray[previewFormat]);
params.setPictureFormat(pictureFormatArray[pictureFormat]);
params.set(KEY_BUFF_STARV, bufferStarvationTest);
params.set(KEY_METERING_MODE, metering[meter_mode]);
params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, thumbnail_Array[thumbSizeIDX]->width);
params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, thumbnail_Array[thumbSizeIDX]->height);
params.set(KEY_MANUAL_CONVERGENCE, manualConv);
params.set(KEY_MANUAL_EXPOSURE, manualExp);
params.set(KEY_MANUAL_GAIN_ISO, manualGain);
params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
params.set(KEY_S3D2D_PREVIEW_MODE, "off");
params.set(KEY_EXIF_MODEL, MODEL);
params.set(KEY_EXIF_MAKE, MAKE);
setDefaultExpGainPreset(shotParams, expBracketIdx);
}
void setDefaultExpGainPreset(ShotParameters ¶ms, int idx) {
if ( ((int)ARRAY_SIZE(expBracketing) > idx) && (0 <= idx) ) {
setExpGainPreset(params, expBracketing[idx].value, false, expBracketing[idx].param_type, shotConfigFlush);
} else {
printf("setDefaultExpGainPreset: Index (%d) is out of range 0 ~ %u\n", idx, ARRAY_SIZE(expBracketing) - 1);
}
}
void setSingleExpGainPreset(ShotParameters ¶ms, int idx, int exp, int gain) {
String8 val;
if (PARAM_EXP_BRACKET_PARAM_PAIR == expBracketing[idx].param_type) {
val.append("(");
}
if (PARAM_EXP_BRACKET_VALUE_REL == expBracketing[idx].value_type) {
val.appendFormat("%+d", exp);
} else {
val.appendFormat("%u", (unsigned int) exp);
}
if (PARAM_EXP_BRACKET_PARAM_PAIR == expBracketing[idx].param_type) {
if (PARAM_EXP_BRACKET_VALUE_REL == expBracketing[idx].value_type) {
val.appendFormat(",%+d)", gain);
} else {
val.appendFormat(",%u)", (unsigned int) gain);
}
}
if (PARAM_EXP_BRACKET_APPLY_FORCED == expBracketing[idx].apply_type) {
val.append("F");
}
setExpGainPreset(params, val, false, expBracketing[idx].param_type, false);
}
void setExpGainPreset(ShotParameters ¶ms, const char *input, bool force, param_ExpBracketParamType_t type, bool flush) {
const char *startPtr = NULL;
size_t i = 0;
if (NULL == input) {
printf("setExpGainPreset: missing input string\n");
} else if ( (force && (NULL == strpbrk(input, "()"))) ||
(PARAM_EXP_BRACKET_PARAM_COMP == type) ) {
// parse for the number of inputs (count the number of ',' + 1)
startPtr = strchr(input, ',');
while (startPtr != NULL) {
i++;
startPtr = strchr(startPtr + 1, ',');
}
i++;
printf("relative EV input: \"%s\"\nnumber of relative EV values: %d (%s)\n",
input, i, flush ? "reset" : "append");
burst = i;
burstCount = i;
params.set(ShotParameters::KEY_BURST, burst);
params.set(ShotParameters::KEY_EXP_COMPENSATION, input);
params.remove(ShotParameters::KEY_EXP_GAIN_PAIRS);
params.set(ShotParameters::KEY_FLUSH_CONFIG,
flush ? ShotParameters::TRUE : ShotParameters::FALSE);
} else if ( force || (PARAM_EXP_BRACKET_PARAM_PAIR == type) ) {
// parse for the number of inputs (count the number of '(')
startPtr = strchr(input, '(');
while (startPtr != NULL) {
i++;
startPtr = strchr(startPtr + 1, '(');
}
printf("absolute exposure,gain input: \"%s\"\nNumber of brackets: %d (%s)\n",
input, i, flush ? "reset" : "append");
burst = i;
burstCount = i;
params.set(ShotParameters::KEY_BURST, burst);
params.set(ShotParameters::KEY_EXP_GAIN_PAIRS, input);
params.remove(ShotParameters::KEY_EXP_COMPENSATION);
params.set(ShotParameters::KEY_FLUSH_CONFIG,
flush ? ShotParameters::TRUE : ShotParameters::FALSE);
} else {
printf("no bracketing input: \"%s\"\n", input);
params.remove(ShotParameters::KEY_EXP_GAIN_PAIRS);
params.remove(ShotParameters::KEY_EXP_COMPENSATION);
params.remove(ShotParameters::KEY_BURST);
params.remove(ShotParameters::KEY_FLUSH_CONFIG);
}
}
void calcNextSingleExpGainPreset(int idx, int &exp, int &gain) {
if (PARAM_EXP_BRACKET_VALUE_ABS == expBracketing[idx].value_type) {
// absolute
if ( (0 == exp) && (0 == gain) ) {
exp=100;
gain = 150;
printf("Streaming: Init default absolute exp./gain: %d,%d\n", exp, gain);
}
exp *= 2;
if (1000000 < exp) {
exp = 100;
gain += 50;
if(400 < gain) {
gain = 50;
}
}
} else {
// relative
exp += 50;
if (200 < exp) {
exp = -200;
gain += 50;
if(200 < gain) {
gain = -200;
}
}
}
}
void updateShotConfigFlushParam() {
// Will update flush shot config parameter if already present
// Otherwise, keep empty (will be set later in setExpGainPreset())
if (NULL != shotParams.get(ShotParameters::KEY_FLUSH_CONFIG)) {
shotParams.set(ShotParameters::KEY_FLUSH_CONFIG,
shotConfigFlush ? ShotParameters::TRUE : ShotParameters::FALSE);
}
}
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':
return -1;
default:
print_menu = 0;
break;
}
return 0;
}
int menu_algo() {
char ch;
if (print_menu) {
printf("\n\n== ALGO ENABLE/DISABLE MENU ============\n\n");
printf(" a. Fixed Gamma: %s\n", algoFixedGamma[algoFixedGammaIDX]);
printf(" s. NSF1: %s\n", algoNSF1[algoNSF1IDX]);
printf(" d. NSF2: %s\n", algoNSF2[algoNSF2IDX]);
printf(" f. Sharpening: %s\n", algoSharpening[algoSharpeningIDX]);
printf(" g. Color Conversion: %s\n", algoThreeLinColorMap[algoThreeLinColorMapIDX]);
printf(" h. Green Inballance Correction: %s\n", algoGIC[algoGICIDX]);
printf("\n");
printf(" q. Return to main menu\n");
printf("\n");
printf(" Choice: ");
}
ch = getchar();
printf("%c", ch);
print_menu = 1;
switch (ch) {
case 'a':
case 'A':
algoFixedGammaIDX++;
algoFixedGammaIDX %= ARRAY_SIZE(algoFixedGamma);
params.set(KEY_ALGO_FIXED_GAMMA, (algoFixedGamma[algoFixedGammaIDX]));
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 's':
case 'S':
algoNSF1IDX++;
algoNSF1IDX %= ARRAY_SIZE(algoNSF1);
params.set(KEY_ALGO_NSF1, (algoNSF1[algoNSF1IDX]));
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'd':
case 'D':
algoNSF2IDX++;
algoNSF2IDX %= ARRAY_SIZE(algoNSF2);
params.set(KEY_ALGO_NSF2, (algoNSF2[algoNSF2IDX]));
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'f':
case 'F':
algoSharpeningIDX++;
algoSharpeningIDX %= ARRAY_SIZE(algoSharpening);
params.set(KEY_ALGO_SHARPENING, (algoSharpening[algoSharpeningIDX]));
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'g':
case 'G':
algoThreeLinColorMapIDX++;
algoThreeLinColorMapIDX %= ARRAY_SIZE(algoThreeLinColorMap);
params.set(KEY_ALGO_THREELINCOLORMAP, (algoThreeLinColorMap[algoThreeLinColorMapIDX]));
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'h':
case 'H':
algoGICIDX++;
algoGICIDX %= ARRAY_SIZE(algoGIC);
params.set(KEY_ALGO_GIC, (algoGIC[algoGICIDX]));
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;
char area1[MAX_LINES][MAX_SYMBOLS+1];
char area2[MAX_LINES][MAX_SYMBOLS+1];
int j = 0;
int k = 0;
const char *valstr = NULL;
struct CameraInfo cameraInfo;
bool queueEmpty = true;
memset(area1, '\0', MAX_LINES*(MAX_SYMBOLS+1));
memset(area2, '\0', MAX_LINES*(MAX_SYMBOLS+1));
if (print_menu) {
printf("\n========================================= FUNCTIONAL TEST MENU =========================================\n");
snprintf(area1[j++], MAX_SYMBOLS, " START / STOP / GENERAL SERVICES");
snprintf(area1[j++], MAX_SYMBOLS, " -----------------------------");
snprintf(area1[j++], MAX_SYMBOLS, "A Select Camera %s", cameras[camera_index]);
snprintf(area1[j++], MAX_SYMBOLS, "[. Resume Preview after capture");
snprintf(area1[j++], MAX_SYMBOLS, "0. Reset to defaults");
snprintf(area1[j++], MAX_SYMBOLS, "q. Quit");
snprintf(area1[j++], MAX_SYMBOLS, "@. Disconnect and Reconnect to CameraService");
snprintf(area1[j++], MAX_SYMBOLS, "/. Enable/Disable showfps: %s", ((showfps)? "Enabled":"Disabled"));
snprintf(area1[j++], MAX_SYMBOLS, "a. GEO tagging settings menu");
snprintf(area1[j++], MAX_SYMBOLS, "E. Camera Capability Dump");
snprintf(area1[j++], MAX_SYMBOLS, " PREVIEW SUB MENU");
snprintf(area1[j++], MAX_SYMBOLS, " -----------------------------");
snprintf(area1[j++], MAX_SYMBOLS, "1. Start Preview");
snprintf(area1[j++], MAX_SYMBOLS, "2. Stop Preview");
snprintf(area1[j++], MAX_SYMBOLS, "~. Preview format %s", previewFormatArray[previewFormat]);
#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
snprintf(area1[j++], MAX_SYMBOLS, "4. Preview size: %4d x %4d - %s",preview_Array[previewSizeIDX]->width, preview_Array[previewSizeIDX]->height, preview_Array[previewSizeIDX]->name);
#else
snprintf(area1[j++], MAX_SYMBOLS, "4. Preview size: %4d x %4d - %s",preview_Array[previewSizeIDX]->width, stereoMode ? preview_Array[previewSizeIDX]->height*2 : preview_Array[previewSizeIDX]->height, preview_Array[previewSizeIDX]->name);
#endif
snprintf(area1[j++], MAX_SYMBOLS, "R. Preview framerate range: %s", rangeDescription[fpsRangeIdx]);
snprintf(area1[j++], MAX_SYMBOLS, "&. Dump a preview frame");
if (stereoMode) {
snprintf(area1[j++], MAX_SYMBOLS, "_. Auto Convergence mode: %s", autoconvergencemode[AutoConvergenceModeIDX]);
snprintf(area1[j++], MAX_SYMBOLS, "^. Manual Convergence Value: %d\n", manualConv);
snprintf(area1[j++], MAX_SYMBOLS, "L. Stereo Preview Layout: %s\n", stereoLayout[stereoLayoutIDX]);
snprintf(area1[j++], MAX_SYMBOLS, ". Stereo Capture Layout: %s\n", stereoCapLayout[stereoCapLayoutIDX]);
}
snprintf(area1[j++], MAX_SYMBOLS, "{. 2D Preview in 3D Stereo Mode: %s", params.get(KEY_S3D2D_PREVIEW_MODE));
snprintf(area1[j++], MAX_SYMBOLS, " IMAGE CAPTURE SUB MENU");
snprintf(area1[j++], MAX_SYMBOLS, " -----------------------------");
snprintf(area1[j++], MAX_SYMBOLS, "p. Take picture/Full Press");
snprintf(area1[j++], MAX_SYMBOLS, "n. Flush shot config queue: %s", shotConfigFlush ? "On" : "Off");
snprintf(area1[j++], MAX_SYMBOLS, "H. Exposure Bracketing: %s", expBracketing[expBracketIdx].desc);
snprintf(area1[j++], MAX_SYMBOLS, "U. Temporal Bracketing: %s", tempBracketing[tempBracketIdx]);
snprintf(area1[j++], MAX_SYMBOLS, "W. Temporal Bracketing Range: [-%d;+%d]", tempBracketRange, tempBracketRange);
snprintf(area1[j++], MAX_SYMBOLS, "$. Picture Format: %s", pictureFormatArray[pictureFormat]);
snprintf(area1[j++], MAX_SYMBOLS, "3. Picture Rotation: %3d degree", rotation );
snprintf(area1[j++], MAX_SYMBOLS, "V. Preview Rotation: %3d degree", previewRotation );
snprintf(area1[j++], MAX_SYMBOLS, "5. Picture size: %4d x %4d - %s",capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height, capture_Array[captureSizeIDX]->name);
snprintf(area1[j++], MAX_SYMBOLS, "i. ISO mode: %s", isoMode[iso_mode]);
snprintf(area1[j++], MAX_SYMBOLS, ", Manual gain iso value = %d\n", manualGain);
snprintf(area1[j++], MAX_SYMBOLS, "u. Capture Mode: %s", modevalues[capture_mode]);
snprintf(area1[j++], MAX_SYMBOLS, "k. IPP Mode: %s", ipp_mode[ippIDX]);
snprintf(area1[j++], MAX_SYMBOLS, "K. GBCE: %s", gbce[gbceIDX]);
snprintf(area1[j++], MAX_SYMBOLS, "O. GLBCE %s", gbce[glbceIDX]);
snprintf(area1[j++], MAX_SYMBOLS, "o. Jpeg Quality: %d", jpegQuality);
snprintf(area1[j++], MAX_SYMBOLS, "#. Burst Images: %3d", burst);
snprintf(area1[j++], MAX_SYMBOLS, ":. Thumbnail Size: %4d x %4d - %s",thumbnail_Array[thumbSizeIDX]->width, thumbnail_Array[thumbSizeIDX]->height, thumbnail_Array[thumbSizeIDX]->name);
snprintf(area1[j++], MAX_SYMBOLS, "': Thumbnail Quality %d", thumbQuality);
snprintf(area2[k++], MAX_SYMBOLS, " VIDEO CAPTURE SUB MENU");
snprintf(area2[k++], MAX_SYMBOLS, " -----------------------------");
snprintf(area2[k++], MAX_SYMBOLS, "6. Start Video Recording");
snprintf(area2[k++], MAX_SYMBOLS, "2. Stop Recording");
snprintf(area2[k++], MAX_SYMBOLS, "l. Video Capture resolution: %4d x %4d - %s",Vcapture_Array[VcaptureSizeIDX]->width,Vcapture_Array[VcaptureSizeIDX]->height, Vcapture_Array[VcaptureSizeIDX]->name);
snprintf(area2[k++], MAX_SYMBOLS, "]. Video Bit rate : %s", VbitRate[VbitRateIDX].desc);
snprintf(area2[k++], MAX_SYMBOLS, "9. Video Codec: %s", videoCodecs[videoCodecIDX].desc);
snprintf(area2[k++], MAX_SYMBOLS, "D. Audio Codec: %s", audioCodecs[audioCodecIDX].desc);
snprintf(area2[k++], MAX_SYMBOLS, "v. Output Format: %s", outputFormat[outputFormatIDX].desc);
snprintf(area2[k++], MAX_SYMBOLS, "r. Framerate: %d", constFramerate[frameRateIDX]);
snprintf(area2[k++], MAX_SYMBOLS, "*. Start Video Recording dump ( 1 raw frame )");
snprintf(area2[k++], MAX_SYMBOLS, "B VNF %s", vnftoggle? "On" : "Off");
snprintf(area2[k++], MAX_SYMBOLS, "C VSTAB %s", vstabtoggle? "On" : "Off");
snprintf(area2[k++], MAX_SYMBOLS, " 3A SETTING SUB MENU");
snprintf(area2[k++], MAX_SYMBOLS, " -----------------------------");
snprintf(area2[k++], MAX_SYMBOLS, "M. Measurement Data: %s", measurement[measurementIdx]);
snprintf(area2[k++], MAX_SYMBOLS, "F. Toggle face detection: %s", faceDetectToggle ? "On" : "Off");
snprintf(area2[k++], MAX_SYMBOLS, "T. Toggle metadata: %s", metaDataToggle ? "On" : "Off");
snprintf(area2[k++], MAX_SYMBOLS, "G. Touch/Focus area AF");
snprintf(area2[k++], MAX_SYMBOLS, "y. Metering area");
snprintf(area2[k++], MAX_SYMBOLS, "Y. Metering area center");
snprintf(area2[k++], MAX_SYMBOLS, "N. Metering area average");
snprintf(area2[k++], MAX_SYMBOLS, "f. Auto Focus/Half Press");
snprintf(area2[k++], MAX_SYMBOLS, "I. AF Timeout %s", afTimeout[afTimeoutIdx]);
snprintf(area2[k++], MAX_SYMBOLS, "J.Flash: %s", flash[flashIdx]);
snprintf(area2[k++], MAX_SYMBOLS, "7. EV offset: %4.1f", compensation);
snprintf(area2[k++], MAX_SYMBOLS, "8. AWB mode: %s", awb[awb_mode]);
snprintf(area2[k++], MAX_SYMBOLS, "z. Zoom %s", zoom[zoomIDX].zoom_description);
snprintf(area2[k++], MAX_SYMBOLS, "Z. Smooth Zoom %s", zoom[zoomIDX].zoom_description);
snprintf(area2[k++], MAX_SYMBOLS, "j. Exposure %s", exposureMode[exposure_mode]);
snprintf(area2[k++], MAX_SYMBOLS, "Q. manual exposure value = %d\n", manualExp);
snprintf(area2[k++], MAX_SYMBOLS, "e. Effect: %s", effectss[effects_mode]);
snprintf(area2[k++], MAX_SYMBOLS, "w. Scene: %s", scene[scene_mode]);
snprintf(area2[k++], MAX_SYMBOLS, "s. Saturation: %d", saturation);
snprintf(area2[k++], MAX_SYMBOLS, "c. Contrast: %d", contrast);
snprintf(area2[k++], MAX_SYMBOLS, "h. Sharpness: %d", sharpness);
snprintf(area2[k++], MAX_SYMBOLS, "b. Brightness: %d", brightness);
snprintf(area2[k++], MAX_SYMBOLS, "x. Antibanding: %s", antiband[antibanding_mode]);
snprintf(area2[k++], MAX_SYMBOLS, "g. Focus mode: %s", focus[focus_mode]);
snprintf(area2[k++], MAX_SYMBOLS, "m. Metering mode: %s" , metering[meter_mode]);
snprintf(area2[k++], MAX_SYMBOLS, "<. Exposure Lock: %s", AutoExposureLocktoggle ? "On" : "Off");
snprintf(area2[k++], MAX_SYMBOLS, ">. WhiteBalance Lock: %s",AutoWhiteBalanceLocktoggle ? "On": "Off");
snprintf(area2[k++], MAX_SYMBOLS, "). Mechanical Misalignment Correction: %s",misalignmentCorrection[enableMisalignmentCorrectionIdx]);
snprintf(area2[k++], MAX_SYMBOLS, "d. Algo enable/disable functions menu");
printf("\n");
for (int i=0; (i<j || i < k) && i<MAX_LINES; i++) {
printf("%-65s \t %-65s\n", area1[i], area2[i]);
}
printf(" Choice:");
}
ch = getchar();
printf("%c", ch);
print_menu = 1;
switch (ch) {
case '_':
AutoConvergenceModeIDX++;
AutoConvergenceModeIDX %= numAutoConvergence;
params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], "manual") == 0) {
params.set(KEY_MANUAL_CONVERGENCE, manualConv);
} else {
if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], "touch") == 0) {
params.set(CameraParameters::KEY_METERING_AREAS, MeteringAreas);
}
manualConv = 0;
params.set(KEY_MANUAL_CONVERGENCE, manualConv);
}
camera->setParameters(params.flatten());
break;
case '^':
if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], "manual") == 0) {
manualConv += manualConvStep;
if( manualConv > manualConvMax) {
manualConv = manualConvMin;
}
params.set(KEY_MANUAL_CONVERGENCE, manualConv);
camera->setParameters(params.flatten());
}
break;
case 'A':
camera_index++;
camera_index %= numCamera;
firstTime = true;
closeCamera();
openCamera();
initDefaults();
break;
case '[':
if ( hardwareActive ) {
camera->setParameters(params.flatten());
camera->startPreview();
}
break;
case '0':
initDefaults();
camera_index = 0;
break;
case '1':
if ( startPreview() < 0 ) {
printf("Error while starting preview\n");
return -1;
}
break;
case '2':
if ( recordingMode ) {
stopRecording();
stopPreview();
closeRecorder();
camera->disconnect();
camera.clear();
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;
} else {
stopPreview();
}
break;
case '3':
rotation += 90;
rotation %= 360;
params.set(CameraParameters::KEY_ROTATION, rotation);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'V':
previewRotation += 90;
previewRotation %= 360;
params.set(KEY_SENSOR_ORIENTATION, previewRotation);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case '4':
previewSizeIDX += 1;
previewSizeIDX %= numpreviewSize;
params.setPreviewSize(preview_Array[previewSizeIDX]->width, preview_Array[previewSizeIDX]->height);
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 %= numcaptureSize;
printf("CaptureSizeIDX %d \n", captureSizeIDX);
params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
if ( hardwareActive )
camera->setParameters(params.flatten());
requestBufferSourceReset();
break;
case 'l':
VcaptureSizeIDX++;
VcaptureSizeIDX %= numVcaptureSize;
break;
case 'L' :
stereoLayoutIDX++;
stereoLayoutIDX %= numLay;
if (stereoMode) {
firstTimeStereo = false;
params.set(KEY_S3D_PRV_FRAME_LAYOUT, stereoLayout[stereoLayoutIDX]);
}
getSizeParametersFromCapabilities();
if (hardwareActive && previewRunning) {
stopPreview();
camera->setParameters(params.flatten());
startPreview();
} else if (hardwareActive) {
camera->setParameters(params.flatten());
}
break;
case '.' :
stereoCapLayoutIDX++;
stereoCapLayoutIDX %= numCLay;
if (stereoMode) {
firstTimeStereo = false;
params.set(KEY_S3D_CAP_FRAME_LAYOUT, stereoCapLayout[stereoCapLayoutIDX]);
}
getSizeParametersFromCapabilities();
if (hardwareActive && previewRunning) {
stopPreview();
camera->setParameters(params.flatten());
startPreview();
} else if (hardwareActive) {
camera->setParameters(params.flatten());
}
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 %= numawb;
params.set(params.KEY_WHITE_BALANCE, awb[awb_mode]);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case '9':
videoCodecIDX++;
videoCodecIDX %= ARRAY_SIZE(videoCodecs);
break;
case '~':
previewFormat += 1;
previewFormat %= numpreviewFormat;
params.setPreviewFormat(previewFormatArray[previewFormat]);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case '$':
pictureFormat += 1;
pictureFormat %= numpictureFormat;
printf("pictureFormat %d\n", pictureFormat);
printf("numpreviewFormat %d\n", numpictureFormat);
params.setPictureFormat(pictureFormatArray[pictureFormat]);
queueEmpty = true;
if ( bufferSourceOutputThread.get() ) {
if ( 0 < bufferSourceOutputThread->hasBuffer() ) {
queueEmpty = false;
}
}
if ( hardwareActive && queueEmpty )
camera->setParameters(params.flatten());
break;
case ':':
thumbSizeIDX += 1;
thumbSizeIDX %= numthumbnailSize;
printf("ThumbnailSizeIDX %d \n", thumbSizeIDX);
params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, thumbnail_Array[thumbSizeIDX]->width);
params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,thumbnail_Array[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' :
if(strcmp(vnfstr, "true") == 0) {
if(vnftoggle == false) {
trySetVideoNoiseFilter(true);
vnftoggle = true;
} else {
trySetVideoNoiseFilter(false);
vnftoggle = false;
}
}else {
trySetVideoNoiseFilter(false);
vnftoggle = false;
printf("VNF is not supported\n");
}
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'C' :
if(strcmp(vstabstr, "true") == 0) {
if(vstabtoggle == false) {
trySetVideoStabilization(true);
vstabtoggle = true;
} else {
trySetVideoStabilization(false);
vstabtoggle = false;
}
} else {
trySetVideoStabilization(false);
vstabtoggle = false;
printf("VSTAB is not supported\n");
}
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;
params.set(KEY_IPP, ipp_mode[ippIDX]);
if ( hardwareActive )
camera->setParameters(params.flatten());
requestBufferSourceReset();
break;
case 'K':
gbceIDX+= 1;
gbceIDX %= ARRAY_SIZE(gbce);
params.set(KEY_GBCE, gbce[gbceIDX]);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'O':
glbceIDX+= 1;
glbceIDX %= ARRAY_SIZE(gbce);
params.set(KEY_GLBCE, gbce[glbceIDX]);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'F':
faceDetectToggle = !faceDetectToggle;
if ( hardwareActive ) {
if (faceDetectToggle)
camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0);
else
camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0);
}
break;
case 'I':
afTimeoutIdx++;
afTimeoutIdx %= ARRAY_SIZE(afTimeout);
params.set(KEY_AF_TIMEOUT, afTimeout[afTimeoutIdx]);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'T':
metaDataToggle = !metaDataToggle;
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;
}
burstCount = burst;
params.set(KEY_TI_BURST, burst);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'J':
flashIdx++;
flashIdx %= numflash;
params.set(CameraParameters::KEY_FLASH_MODE, (flash[flashIdx]));
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'u':
capture_mode++;
capture_mode %= nummodevalues;
// HQ should always be in ldc-nsf
// if not HQ, then return the ipp to its previous state
if( !strcmp(modevalues[capture_mode], "high-quality") ) {
ippIDX_old = ippIDX;
ippIDX = 3;
params.set(KEY_IPP, ipp_mode[ippIDX]);
params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
previewRotation = 0;
params.set(KEY_SENSOR_ORIENTATION, previewRotation);
} else if ( !strcmp(modevalues[capture_mode], "video-mode") ) {
params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);
camera->getCameraInfo(camera_index, &cameraInfo);
previewRotation = ((360-cameraInfo.orientation)%360);
if (previewRotation >= 0 || previewRotation <=360) {
params.set(KEY_SENSOR_ORIENTATION, previewRotation);
}
} else {
ippIDX = ippIDX_old;
params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::FALSE);
previewRotation = 0;
params.set(KEY_SENSOR_ORIENTATION, previewRotation);
}
params.set(KEY_MODE, (modevalues[capture_mode]));
if ( hardwareActive ) {
if (previewRunning) {
stopPreview();
}
camera->setParameters(params.flatten());
// Get parameters from capabilities for the new capture mode
params = camera->getParameters();
getSizeParametersFromCapabilities();
getParametersFromCapabilities();
// Set framerate 30fps and 12MP capture resolution if available for the new capture mode.
// If not available set framerate and capture mode under index 0 from fps_const_str and capture_Array.
frameRateIDX = getDefaultParameter("30000,30000", constCnt, fps_const_str);
captureSizeIDX = getDefaultParameterResol("12MP", numcaptureSize, capture_Array);
params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
params.setPictureSize(capture_Array[captureSizeIDX]->width, capture_Array[captureSizeIDX]->height);
camera->setParameters(params.flatten());
}
requestBufferSourceReset();
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);
setDefaultExpGainPreset(shotParams, expBracketIdx);
break;
case 'n':
if (shotConfigFlush)
shotConfigFlush = false;
else
shotConfigFlush = true;
updateShotConfigFlushParam();
break;
case '(':
{
char input[256];
input[0] = ch;
scanf("%254s", input+1);
setExpGainPreset(shotParams, input, true, PARAM_EXP_BRACKET_PARAM_NONE, shotConfigFlush);
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 %= numscene;
params.set(params.KEY_SCENE_MODE, scene[scene_mode]);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'i':
iso_mode++;
iso_mode %= numisoMode;
params.set(KEY_ISO, isoMode[iso_mode]);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'h':
#ifdef TARGET_OMAP4
if ( sharpness >= 200)
#else
if ( sharpness >= 100)
#endif
{
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':
if(strcmp(zoomstr, "true") == 0) {
zoomIDX++;
zoomIDX %= ARRAY_SIZE(zoom);
params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
if ( hardwareActive )
camera->setParameters(params.flatten());
}
break;
case 'Z':
if(strcmp(smoothzoomstr, "true") == 0) {
zoomIDX++;
zoomIDX %= ARRAY_SIZE(zoom);
if ( hardwareActive )
camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, zoom[zoomIDX].idx, 0);
}
break;
case 'j':
exposure_mode++;
exposure_mode %= numExposureMode;
params.set(KEY_EXPOSURE, exposureMode[exposure_mode]);
if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
params.set(KEY_MANUAL_EXPOSURE, manualExp);
params.set(KEY_MANUAL_GAIN_ISO, manualGain);
params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
}
else
{
manualExp = manualExpMin;
params.set(KEY_MANUAL_EXPOSURE, manualExp);
params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
manualGain = manualGainMin;
params.set(KEY_MANUAL_GAIN_ISO, manualGain);
params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
}
if ( hardwareActive ) {
camera->setParameters(params.flatten());
}
break;
case 'Q':
if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
manualExp += manualExpStep;
if( manualExp > manualExpMax) {
manualExp = manualExpMin;
}
params.set(KEY_MANUAL_EXPOSURE, manualExp);
params.set(KEY_MANUAL_EXPOSURE_RIGHT, manualExp);
camera->setParameters(params.flatten());
}
break;
case ',':
if ( strcmp (exposureMode[exposure_mode], "manual") == 0) {
manualGain += manualGainStep;
if( manualGain > manualGainMax) {
manualGain = manualGainMin;
}
params.set(KEY_MANUAL_GAIN_ISO, manualGain);
params.set(KEY_MANUAL_GAIN_ISO_RIGHT, manualGain);
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':
#ifdef TARGET_OMAP4
if ( brightness >= 100)
#else
if ( brightness >= 200)
#endif
{
brightness = 0;
} else {
brightness += 10;
}
params.set(KEY_BRIGHTNESS, brightness);
if ( hardwareActive ) {
camera->setParameters(params.flatten());
}
break;
case 's':
if ( saturation >= 200) {
saturation = 0;
} else {
saturation += 10;
}
params.set(KEY_SATURATION, saturation);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'e':
effects_mode++;
effects_mode %= numEffects;
printf("%d", numEffects);
params.set(params.KEY_EFFECT, effectss[effects_mode]);
printf("Effects_mode %d", effects_mode);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'r':
frameRateIDX++;
frameRateIDX %= constCnt;
params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_const_str[frameRateIDX]);
printf("fps_const_str[frameRateIDX] %s\n", fps_const_str[frameRateIDX]);
if ( hardwareActive ) {
camera->setParameters(params.flatten());
}
break;
case 'R':
fpsRangeIdx += 1;
fpsRangeIdx %= rangeCnt;
params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fps_range_str[fpsRangeIdx]);
printf("fps_range_str[fpsRangeIdx] %s\n", fps_range_str[fpsRangeIdx]);
if ( hardwareActive ) {
camera->setParameters(params.flatten());
}
break;
case 'x':
antibanding_mode++;
antibanding_mode %= numAntibanding;
printf("%d", numAntibanding);
params.set(params.KEY_ANTIBANDING, antiband[antibanding_mode]);
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'g':
focus_mode++;
focus_mode %= numfocus;
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());
break;
case 'y':
params.set(CameraParameters::KEY_METERING_AREAS, TEST_METERING_AREA);
if ( hardwareActive ) {
camera->setParameters(params.flatten());
}
break;
case 'Y':
params.set(CameraParameters::KEY_METERING_AREAS, TEST_METERING_AREA_CENTER);
if ( hardwareActive ) {
camera->setParameters(params.flatten());
}
break;
case 'N':
params.set(CameraParameters::KEY_METERING_AREAS, TEST_METERING_AREA_AVERAGE);
if ( hardwareActive ) {
camera->setParameters(params.flatten());
}
break;
case 'f':
gettimeofday(&autofocus_start, 0);
if ( hardwareActive )
camera->autoFocus();
break;
case 'p':
{
int msgType = 0;
if((0 == strcmp(modevalues[capture_mode], "video-mode")) &&
(0 != strcmp(videosnapshotstr, "true"))) {
printf("Video Snapshot is not supported\n");
} else if ( hardwareActive ) {
if(isRawPixelFormat(pictureFormatArray[pictureFormat])) {
createBufferOutputSource();
if (bufferSourceOutputThread.get()) {
bufferSourceOutputThread->setBuffer(shotParams);
bufferSourceOutputThread->setStreamCapture(streamCapture, expBracketIdx);
}
} else {
msgType = CAMERA_MSG_COMPRESSED_IMAGE |
CAMERA_MSG_RAW_IMAGE;
#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
msgType |= CAMERA_MSG_RAW_BURST;
#endif
}
gettimeofday(&picture_start, 0);
camera->setParameters(params.flatten());
camera->takePictureWithParameters(msgType, shotParams.flatten());
}
break;
}
case 'S':
{
if (streamCapture) {
streamCapture = false;
setDefaultExpGainPreset(shotParams, expBracketIdx);
// Stop streaming
if (bufferSourceOutputThread.get()) {
bufferSourceOutputThread->setStreamCapture(streamCapture, expBracketIdx);
}
} else {
streamCapture = true;
setSingleExpGainPreset(shotParams, expBracketIdx, 0, 0);
// Queue more frames initially
shotParams.set(ShotParameters::KEY_BURST, BRACKETING_STREAM_BUFFERS);
}
break;
}
case 'P':
{
int msgType = CAMERA_MSG_COMPRESSED_IMAGE;
ShotParameters reprocParams;
gettimeofday(&picture_start, 0);
createBufferInputSource();
if (bufferSourceOutputThread.get() &&
bufferSourceOutputThread->hasBuffer())
{
bufferSourceOutputThread->setStreamCapture(false, expBracketIdx);
if (hardwareActive) camera->setParameters(params.flatten());
if (bufferSourceInput.get()) {
buffer_info_t info = bufferSourceOutputThread->popBuffer();
bufferSourceInput->setInput(info, pictureFormatArray[pictureFormat], reprocParams);
if (hardwareActive) camera->reprocess(msgType, reprocParams.flatten());
}
}
break;
}
case '&':
printf("Enabling Preview Callback");
dump_preview = 1;
if ( hardwareActive )
camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
break;
case '{':
valstr = params.get(KEY_S3D2D_PREVIEW_MODE);
if ( (NULL != valstr) && (0 == strcmp(valstr, "on")) )
{
params.set(KEY_S3D2D_PREVIEW_MODE, "off");
}
else
{
params.set(KEY_S3D2D_PREVIEW_MODE, "on");
}
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case 'a':
while (1) {
if ( menu_gps() < 0)
break;
};
break;
case 'q':
stopPreview();
deleteAllocatedMemory();
return -1;
case '/':
{
if (showfps)
{
property_set("debug.image.showfps", "0");
showfps = false;
}
else
{
property_set("debug.image.showfps", "1");
showfps = true;
}
break;
}
case '<':
if(strcmp(AutoExposureLockstr, "true") == 0) {
if(AutoExposureLocktoggle == false) {
trySetAutoExposureLock(true);
AutoExposureLocktoggle = true;
} else {
trySetAutoExposureLock(false);
AutoExposureLocktoggle = false;
printf("ExposureLock is not supported\n");
}
}
if ( hardwareActive )
camera->setParameters(params.flatten());
break;
case '>':
if(strcmp(AutoWhiteBalanceLockstr, "true") == 0) {
if(AutoWhiteBalanceLocktoggle == false) {
trySetAutoWhiteBalanceLock(true);
AutoWhiteBalanceLocktoggle = true;
} else {
trySetAutoWhiteBalanceLock(false);
AutoWhiteBalanceLocktoggle = false;
printf("ExposureLock is not supported\n");
}
}
if ( hardwareActive ) {
camera->setParameters(params.flatten());
}
break;
case ')':
enableMisalignmentCorrectionIdx++;
enableMisalignmentCorrectionIdx %= ARRAY_SIZE(misalignmentCorrection);
params.set(KEY_MECHANICAL_MISALIGNMENT_CORRECTION, misalignmentCorrection[enableMisalignmentCorrectionIdx]);
if ( hardwareActive ) {
camera->setParameters(params.flatten());
}
break;
case 'd':
while (1) {
if ( menu_algo() < 0)
break;
}
break;
default:
print_menu = 0;
break;
}
return 0;
}
void print_usage() {
printf(" USAGE: camera_test <options>\n");
printf(" <options> (case insensitive)\n");
printf("-----------\n");
printf(" -f -> Functional tests.\n");
printf(" -a -> API tests.\n");
printf(" -e [<script>] -> Error scenario tests. If no script file is provided\n");
printf(" the test is run in interactive mode.\n");
printf(" -s <script> -c <sensorID> -> Stress / regression tests.\n");
printf(" -l [<flags>] -> Enable different kinds of logging capture. Multiple flags\n");
printf(" should be combined into a string. If flags are not provided\n");
printf(" no logs are captured.\n");
printf(" <flags>\n");
printf(" ---------\n");
printf(" l -> logcat [default]\n");
printf(" s -> syslink [default]\n");
printf(" -o <path> -> Output directory to store the test results. Image and video\n");
printf(" files are stored in corresponding sub-directories.\n");
printf(" -p <platform> -> Target platform. Only for stress tests.\n");
printf(" <platform>\n");
printf(" ------------\n");
printf(" blaze or B -> BLAZE\n");
printf(" tablet1 or T1 -> Blaze TABLET-1\n");
printf(" tablet2 or T2 -> Blaze TABLET-2 [default]\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() {
printf("+++Restarting Camera After Error+++\n");
stopPreview();
if (recordingMode) {
stopRecording();
closeRecorder();
recordingMode = false;
}
sleep(3); //Wait a bit before restarting
restartCount++;
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 parseCommandLine(int argc, char *argv[], cmd_args_t *cmd_args) {
if (argc < 2) {
printf("Please enter at least 1 argument\n");
return -2;
}
// Set defaults
memset(cmd_args, 0, sizeof(*cmd_args));
cmd_args->logging = LOGGING_LOGCAT | LOGGING_SYSLINK;
cmd_args->platform_id = BLAZE_TABLET2;
for (int a = 1; a < argc; a++) {
const char * const arg = argv[a];
if (arg[0] != '-') {
printf("Error: Invalid argument \"%s\"\n", arg);
return -2;
}
switch (arg[1]) {
case 's':
cmd_args->test_type = TEST_TYPE_REGRESSION;
if (a < argc - 1) {
cmd_args->script_file_name = argv[++a];
} else {
printf("Error: No script is specified for stress / regression test.\n");
return -2;
}
break;
case 'f':
cmd_args->test_type = TEST_TYPE_FUNCTIONAL;
break;
case 'a':
cmd_args->test_type = TEST_TYPE_API;
break;
case 'e':
cmd_args->test_type = TEST_TYPE_ERROR;
if (a < argc - 1) {
cmd_args->script_file_name = argv[++a];
}
break;
case 'l':
cmd_args->logging = 0;
if (a < argc - 1 && argv[a + 1][0] != '-') {
const char *flags = argv[++a];
while (*flags) {
char flag = *flags++;
switch (flag) {
case 'l':
cmd_args->logging |= LOGGING_LOGCAT;
break;
case 's':
cmd_args->logging |= LOGGING_SYSLINK;
break;
default:
printf("Error: Unknown logging type \"%c\"\n", flag);
return -2;
}
}
}
break;
case 'p':
if (a < argc - 1) {
const char *platform = argv[++a];
if( strcasecmp(platform,"blaze") == 0 || strcasecmp(platform,"B") == 0 ){
cmd_args->platform_id = BLAZE;
}
else if( (strcasecmp(platform,"tablet1") == 0) || (strcasecmp(platform,"T1") == 0) ) {
cmd_args->platform_id = BLAZE_TABLET1;
}
else if( (strcasecmp(platform,"tablet2") == 0) || (strcasecmp(platform,"T2") == 0) ) {
cmd_args->platform_id = BLAZE_TABLET2;
}
else {
printf("Error: Unknown argument for platform ID.\n");
return -2;
}
} else {
printf("Error: No argument is specified for platform ID.\n");
return -2;
}
break;
case 'o':
if (a < argc - 1) {
cmd_args->output_path = argv[++a];
} else {
printf("Error: No output path is specified.\n");
return -2;
}
break;
case 'c':
if (a < argc -1) {
camera_index = atoi(argv[++a]);
} else {
printf("Error: No sensorID is specified.\n");
return -2;
}
break;
default:
printf("Error: Unknown option \"%s\"\n", argv[a]);
return -2;
}
}
return 0;
}
int setOutputDirPath(cmd_args_t *cmd_args, int restart_count) {
if ((cmd_args->output_path != NULL) &&
(strlen(cmd_args->output_path) < sizeof(output_dir_path))) {
strcpy(output_dir_path, cmd_args->output_path);
} else {
strcpy(output_dir_path, SDCARD_PATH);
if (cmd_args->script_file_name != NULL) {
const char *config = cmd_args->script_file_name;
char dir_name[40];
size_t count = 0;
char *p;
// remove just the '.txt' part of the config
while ((config[count] != '.') && ((count + 1) < sizeof(dir_name))) {
count++;
}
strncpy(dir_name, config, count);
dir_name[count] = NULL;
p = dir_name;
while (*p != '\0') {
if (*p == '/') {
printf("SDCARD_PATH is not added to the output directory.\n");
// Needed when camera_test script is executed using the OTC
strcpy(output_dir_path, "");
break;
}
}
strcat(output_dir_path, dir_name);
if (camera_index == 1) {
strcat(output_dir_path, SECONDARY_SENSOR);
}else if (camera_index == 2) {
strcat(output_dir_path, S3D_SENSOR);
}
}
}
if (restart_count && (strlen(output_dir_path) + 16) < sizeof(output_dir_path)) {
char count[16];
sprintf(count, "_%d", restart_count);
strcat(output_dir_path, count);
}
if (access(output_dir_path, F_OK) == -1) {
if (mkdir(output_dir_path, 0777) == -1) {
printf("\nError: Output directory \"%s\" was not created\n", output_dir_path);
return -1;
}
}
sprintf(videos_dir_path, "%s/videos", output_dir_path);
if (access(videos_dir_path, F_OK) == -1) {
if (mkdir(videos_dir_path, 0777) == -1) {
printf("\nError: Videos directory \"%s\" was not created\n", videos_dir_path);
return -1;
}
}
sprintf(images_dir_path, "%s/images", output_dir_path);
if (access(images_dir_path, F_OK) == -1) {
if (mkdir(images_dir_path, 0777) == -1) {
printf("\nError: Images directory \"%s\" was not created\n", images_dir_path);
return -1;
}
}
return 0;
}
int startTest() {
ProcessState::self()->startThreadPool();
if (openCamera() < 0) {
printf("Camera initialization failed\n");
return -1;
}
initDefaults();
return 0;
}
int runRegressionTest(cmd_args_t *cmd_args) {
char *cmd;
int pid;
platformID = cmd_args->platform_id;
int res = startTest();
if (res != 0) {
return res;
}
cmd = load_script(cmd_args->script_file_name);
if (cmd != NULL) {
start_logging(cmd_args->logging, pid);
stressTest = true;
while (1) {
if (execute_functional_script(cmd) == 0) {
break;
}
printf("CameraTest Restarting Camera...\n");
free(cmd);
cmd = NULL;
if ( (restartCamera() != 0) || ((cmd = load_script(cmd_args->script_file_name)) == NULL) ) {
printf("ERROR::CameraTest Restarting Camera...\n");
res = -1;
break;
}
res = setOutputDirPath(cmd_args, restartCount);
if (res != 0) {
break;
}
}
free(cmd);
stop_logging(cmd_args->logging, pid);
}
return 0;
}
int runFunctionalTest() {
int res = startTest();
if (res != 0) {
return res;
}
print_menu = 1;
while (1) {
if (functional_menu() < 0) {
break;
}
}
return 0;
}
int runApiTest() {
printf("API level test cases coming soon ... \n");
return 0;
}
int runErrorTest(cmd_args_t *cmd_args) {
int res = startTest();
if (res != 0) {
return res;
}
if (cmd_args->script_file_name != NULL) {
char *cmd;
int pid;
cmd = load_script(cmd_args->script_file_name);
if (cmd != NULL) {
start_logging(cmd_args->logging, pid);
execute_error_script(cmd);
free(cmd);
stop_logging(cmd_args->logging, pid);
}
} else {
print_menu = 1;
while (1) {
if (error_scenario() < 0) {
break;
}
}
}
return 0;
}
int main(int argc, char *argv[]) {
sp<ProcessState> proc(ProcessState::self());
unsigned long long st, end, delay;
timeval current_time;
cmd_args_t cmd_args;
int res;
res = parseCommandLine(argc, argv, &cmd_args);
if (res != 0) {
print_usage();
return res;
}
res = setOutputDirPath(&cmd_args, 0);
if (res != 0) {
return res;
}
gettimeofday(¤t_time, 0);
st = current_time.tv_sec * 1000000 + current_time.tv_usec;
system("echo camerahal_test > /sys/power/wake_lock");
switch (cmd_args.test_type) {
case TEST_TYPE_REGRESSION:
res = runRegressionTest(&cmd_args);
break;
case TEST_TYPE_FUNCTIONAL:
res = runFunctionalTest();
break;
case TEST_TYPE_API:
res = runApiTest();
break;
case TEST_TYPE_ERROR:
res = runErrorTest(&cmd_args);
break;
}
system("echo camerahal_test > /sys/power/wake_unlock");
gettimeofday(¤t_time, 0);
end = current_time.tv_sec * 1000000 + current_time.tv_usec;
delay = end - st;
printf("Application closed after: %llu ms\n", delay);
return res;
}