392 lines
9.5 KiB
C++
Executable file
392 lines
9.5 KiB
C++
Executable file
|
|
#include "CameraDebug.h"
|
|
#if DBG_CAMERA_CONFIG
|
|
#define LOG_NDEBUG 0
|
|
#endif
|
|
#define LOG_TAG "CCameraConfig"
|
|
#include <cutils/log.h>
|
|
|
|
#include "CCameraConfig.h"
|
|
|
|
#define READ_KEY_VALUE(key, val) \
|
|
val = (char*)::malloc(KEY_LENGTH); \
|
|
if (val == 0){ \
|
|
LOGE("malloc %s failed", val); \
|
|
} \
|
|
memset(val, 0, KEY_LENGTH); \
|
|
if (readKey(key, val)){ \
|
|
/*LOGV("read key: %s = %s", key, val);*/ \
|
|
}
|
|
|
|
#define INIT_PARAMETER(KEY, key) \
|
|
memcpy(mUsed##key, "0\0", 2); \
|
|
mSupport##key##Value = 0; \
|
|
mDefault##key##Value = 0; \
|
|
if (readKey(kUSED_##KEY, mUsed##key)) \
|
|
{ \
|
|
if (usedKey(mUsed##key)) \
|
|
{ \
|
|
READ_KEY_VALUE(kSUPPORT_##KEY, mSupport##key##Value) \
|
|
READ_KEY_VALUE(kDEFAULT_##KEY, mDefault##key##Value) \
|
|
} \
|
|
else \
|
|
{ \
|
|
/*LOGV("\"%s\" not support", kUSED_##KEY);*/ \
|
|
} \
|
|
}
|
|
|
|
#define CHECK_FREE_POINTER(key) \
|
|
if(mSupport##key##Value != 0){ \
|
|
::free(mSupport##key##Value); \
|
|
mSupport##key##Value = 0; \
|
|
} \
|
|
if(mDefault##key##Value != 0){ \
|
|
::free(mDefault##key##Value); \
|
|
mDefault##key##Value = 0; \
|
|
}
|
|
|
|
|
|
#define _DUMP_PARAMETERS(key, value) \
|
|
if (value != 0){ \
|
|
LOGV("%s = %s", key, value); \
|
|
}else{ \
|
|
LOGV("%s not support", key); \
|
|
}
|
|
|
|
#define DUMP_PARAMETERS(kused, key) \
|
|
_DUMP_PARAMETERS(kUSED_##kused, mUsed##key) \
|
|
_DUMP_PARAMETERS(kSUPPORT_##kused, mSupport##key##Value) \
|
|
_DUMP_PARAMETERS(kDEFAULT_##kused, mDefault##key##Value)
|
|
|
|
#define MEMBER_FUNCTION(fun) \
|
|
bool CCameraConfig::support##fun(){ \
|
|
return usedKey(mUsed##fun); \
|
|
}; \
|
|
char *CCameraConfig::support##fun##Value(){ \
|
|
return mSupport##fun##Value; \
|
|
}; \
|
|
char *CCameraConfig::default##fun##Value(){ \
|
|
return mDefault##fun##Value; \
|
|
};
|
|
|
|
MEMBER_FUNCTION(PreviewSize)
|
|
MEMBER_FUNCTION(PictureSize)
|
|
MEMBER_FUNCTION(FlashMode)
|
|
MEMBER_FUNCTION(ColorEffect)
|
|
MEMBER_FUNCTION(FrameRate)
|
|
MEMBER_FUNCTION(FocusMode)
|
|
MEMBER_FUNCTION(SceneMode)
|
|
MEMBER_FUNCTION(WhiteBalance)
|
|
|
|
CCameraConfig::CCameraConfig(int id)
|
|
:mhKeyFile(0)
|
|
,mConstructOk(false)
|
|
,mCurCameraId(id)
|
|
,mNumberOfCamera(0)
|
|
,mCameraFacing(0)
|
|
,mOrientation(0)
|
|
,mDeviceID(0)
|
|
,mFastPictureMode(false)
|
|
{
|
|
mhKeyFile = ::fopen(CAMERA_KEY_CONFIG_PATH, "rb");
|
|
if (mhKeyFile <= 0)
|
|
{
|
|
LOGV("open file %s failed", CAMERA_KEY_CONFIG_PATH);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
LOGV("open file %s OK", CAMERA_KEY_CONFIG_PATH);
|
|
}
|
|
|
|
// exif
|
|
readKey(kCAMERA_EXIF_MAKE, mCameraMake);
|
|
readKey(kCAMERA_EXIF_MODEL, mCameraModel);
|
|
LOGV("exif, make: %s, model: %s", mCameraMake, mCameraModel);
|
|
|
|
// get number of camera
|
|
char numberOfCamera[2];
|
|
if(readKey(kNUMBER_OF_CAMERA, numberOfCamera))
|
|
{
|
|
mNumberOfCamera = atoi(numberOfCamera);
|
|
LOGV("read number: %d", mNumberOfCamera);
|
|
}
|
|
|
|
if (mCurCameraId + 1 > mNumberOfCamera)
|
|
{
|
|
LOGV("should not read camera id: %d, there are %d camera(s)", mCurCameraId, mNumberOfCamera);
|
|
return;
|
|
}
|
|
|
|
// get camera facing
|
|
char cameraFacing[2];
|
|
if(readKey(kCAMERA_FACING, cameraFacing))
|
|
{
|
|
mCameraFacing = atoi(cameraFacing);
|
|
// LOGV("camera facing %s", (mCameraFacing == 0) ? "back" : "front");
|
|
}
|
|
|
|
// get camera device driver
|
|
memset(mCameraDevice, 0, sizeof(mCameraDevice));
|
|
if(readKey(kCAMERA_DEVICE, mCameraDevice))
|
|
{
|
|
// LOGV("camera device %s", mCameraDevice);
|
|
}
|
|
|
|
// get device id
|
|
char deviceID[2];
|
|
if(readKey(kDEVICE_ID, deviceID))
|
|
{
|
|
mDeviceID = atoi(deviceID);
|
|
// LOGV("camera device id %d", mDeviceID);
|
|
}
|
|
|
|
// get camera orientation
|
|
char str[4];
|
|
if(readKey(kCAMERA_ORIENTATION, str))
|
|
{
|
|
mOrientation = atoi(str);
|
|
// LOGV("camera orientation %d", mOrientation);
|
|
}
|
|
|
|
//init other parameters
|
|
initParameters();
|
|
|
|
mConstructOk = true;
|
|
}
|
|
|
|
CCameraConfig::~CCameraConfig()
|
|
{
|
|
CHECK_FREE_POINTER(PreviewSize)
|
|
CHECK_FREE_POINTER(PictureSize)
|
|
CHECK_FREE_POINTER(FlashMode)
|
|
CHECK_FREE_POINTER(ColorEffect)
|
|
CHECK_FREE_POINTER(FrameRate)
|
|
CHECK_FREE_POINTER(FocusMode)
|
|
CHECK_FREE_POINTER(SceneMode)
|
|
CHECK_FREE_POINTER(WhiteBalance)
|
|
|
|
if (mhKeyFile != 0)
|
|
{
|
|
::fclose(mhKeyFile);
|
|
mhKeyFile = 0;
|
|
}
|
|
}
|
|
|
|
bool CCameraConfig::usedKey(char *value)
|
|
{
|
|
return strcmp(value, "1") ? false : true;
|
|
}
|
|
|
|
void CCameraConfig::initParameters()
|
|
{
|
|
if (!mConstructOk)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (mhKeyFile == 0)
|
|
{
|
|
LOGW("invalid camera config file hadle");
|
|
return ;
|
|
}
|
|
|
|
// fast picture mode
|
|
char str[10];
|
|
if(readKey(kFAST_PICTURE_MODE, str))
|
|
{
|
|
mFastPictureMode = (atoi(str) == 1) ? true : false;
|
|
// LOGV("%s support fast picture mode", mFastPictureMode ? "" : "do not");
|
|
}
|
|
else if(readKey(kUSE_BUILTIN_ISP, str))
|
|
{
|
|
mFastPictureMode = (atoi(str) == 1) ? true : false;
|
|
}
|
|
|
|
INIT_PARAMETER(PREVIEW_SIZE, PreviewSize)
|
|
INIT_PARAMETER(PICTURE_SIZE, PictureSize)
|
|
INIT_PARAMETER(FLASH_MODE, FlashMode)
|
|
INIT_PARAMETER(COLOR_EFFECT, ColorEffect)
|
|
INIT_PARAMETER(FRAME_RATE, FrameRate)
|
|
INIT_PARAMETER(FOCUS_MODE, FocusMode)
|
|
INIT_PARAMETER(SCENE_MODE, SceneMode)
|
|
INIT_PARAMETER(WHITE_BALANCE, WhiteBalance)
|
|
|
|
// exposure compensation
|
|
memcpy(mUsedExposureCompensation, "0\0", 2);
|
|
memset(mMaxExposureCompensation, 0, 4);
|
|
memset(mMinExposureCompensation, 0, 4);
|
|
memset(mStepExposureCompensation, 0, 4);
|
|
memset(mDefaultExposureCompensation, 0, 4);
|
|
if (readKey(kUSED_EXPOSURE_COMPENSATION, mUsedExposureCompensation))
|
|
{
|
|
if (usedKey(mUsedExposureCompensation))
|
|
{
|
|
readKey(kMIN_EXPOSURE_COMPENSATION, mMinExposureCompensation);
|
|
readKey(kMAX_EXPOSURE_COMPENSATION, mMaxExposureCompensation);
|
|
readKey(kSTEP_EXPOSURE_COMPENSATION, mStepExposureCompensation);
|
|
readKey(kDEFAULT_EXPOSURE_COMPENSATION, mDefaultExposureCompensation);
|
|
}
|
|
else
|
|
{
|
|
// LOGV("\"%s\" not support", kUSED_EXPOSURE_COMPENSATION);
|
|
}
|
|
}
|
|
|
|
// zoom
|
|
memcpy(mUsedZoom, "0\0", 2);
|
|
memset(mZoomSupported, 0, 8);
|
|
memset(mSmoothZoomSupported, 0, 4);
|
|
memset(mZoomRatios, 0, KEY_LENGTH);
|
|
memset(mMaxZoom, 0, 4);
|
|
memset(mDefaultZoom, 0, 4);
|
|
if (readKey(kUSED_ZOOM, mUsedZoom))
|
|
{
|
|
if (usedKey(mUsedZoom))
|
|
{
|
|
readKey(kZOOM_SUPPORTED, mZoomSupported);
|
|
readKey(kSMOOTH_ZOOM_SUPPORTED, mSmoothZoomSupported);
|
|
readKey(kZOOM_RATIOS, mZoomRatios);
|
|
readKey(kMAX_ZOOM, mMaxZoom);
|
|
readKey(kDEFAULT_ZOOM, mDefaultZoom);
|
|
}
|
|
else
|
|
{
|
|
// LOGV("\"%s\" not support", kUSED_ZOOM);
|
|
}
|
|
}
|
|
readKey(KHORIZONTAL_VIEW_ANGLE, str);
|
|
mHorizonalViewAngle = atof(str);
|
|
readKey(KVERTICAL_VIEW_ANGLE, str);
|
|
mVerticalViewAngle = atof(str);
|
|
}
|
|
|
|
void CCameraConfig::dumpParameters()
|
|
{
|
|
if (!mConstructOk)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (mhKeyFile == 0)
|
|
{
|
|
LOGW("invalid camera config file hadle");
|
|
return ;
|
|
}
|
|
|
|
LOGV("/*------------------------------------------------------*/");
|
|
LOGV("camrea id: %d", mCurCameraId);
|
|
LOGV("camera facing %s", (mCameraFacing == 0) ? "back" : "front");
|
|
LOGV("%s support fast picture mode", mFastPictureMode ? "" : "do not");
|
|
LOGV("camera orientation %d", mOrientation);
|
|
LOGV("camera device %s", mCameraDevice);
|
|
DUMP_PARAMETERS(PREVIEW_SIZE, PreviewSize)
|
|
DUMP_PARAMETERS(PICTURE_SIZE, PictureSize)
|
|
DUMP_PARAMETERS(FLASH_MODE, FlashMode)
|
|
DUMP_PARAMETERS(COLOR_EFFECT, ColorEffect)
|
|
DUMP_PARAMETERS(FRAME_RATE, FrameRate)
|
|
DUMP_PARAMETERS(FOCUS_MODE, FocusMode)
|
|
DUMP_PARAMETERS(SCENE_MODE, SceneMode)
|
|
DUMP_PARAMETERS(WHITE_BALANCE, WhiteBalance)
|
|
|
|
_DUMP_PARAMETERS(kUSED_EXPOSURE_COMPENSATION, mUsedExposureCompensation)
|
|
_DUMP_PARAMETERS(kMIN_EXPOSURE_COMPENSATION, mMinExposureCompensation)
|
|
_DUMP_PARAMETERS(kMAX_EXPOSURE_COMPENSATION, mMaxExposureCompensation)
|
|
_DUMP_PARAMETERS(kSTEP_EXPOSURE_COMPENSATION, mStepExposureCompensation)
|
|
_DUMP_PARAMETERS(kDEFAULT_EXPOSURE_COMPENSATION, mDefaultExposureCompensation)
|
|
|
|
_DUMP_PARAMETERS(kUSED_ZOOM, mUsedZoom)
|
|
_DUMP_PARAMETERS(kZOOM_SUPPORTED, mZoomSupported)
|
|
_DUMP_PARAMETERS(kSMOOTH_ZOOM_SUPPORTED, mSmoothZoomSupported)
|
|
_DUMP_PARAMETERS(kZOOM_RATIOS, mZoomRatios)
|
|
_DUMP_PARAMETERS(kMAX_ZOOM, mMaxZoom)
|
|
_DUMP_PARAMETERS(kDEFAULT_ZOOM, mDefaultZoom)
|
|
LOGV("/*------------------------------------------------------*/");
|
|
}
|
|
|
|
void CCameraConfig::getValue(char *line, char *value)
|
|
{
|
|
char * ptemp = line;
|
|
while(*ptemp)
|
|
{
|
|
if (*ptemp++ == '=')
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
char *pval = ptemp;
|
|
char *seps = " \n\r\t";
|
|
int offset = 0;
|
|
pval = strtok(pval, seps);
|
|
while (pval != NULL)
|
|
{
|
|
strncpy(value + offset, pval, strlen(pval));
|
|
offset += strlen(pval);
|
|
pval = strtok(NULL, seps);
|
|
}
|
|
*(value + offset) = 0;
|
|
}
|
|
|
|
bool CCameraConfig::readKey(char *key, char *value)
|
|
{
|
|
bool bRet = false;
|
|
bool bFlagBegin = false;
|
|
char strId[2];
|
|
char str[KEY_LENGTH];
|
|
|
|
if (key == 0 || value == 0)
|
|
{
|
|
LOGV("error input para");
|
|
return false;
|
|
}
|
|
|
|
if (mhKeyFile == 0)
|
|
{
|
|
LOGV("error key file handle");
|
|
return false;
|
|
}
|
|
|
|
fseek(mhKeyFile, 0L, SEEK_SET);
|
|
|
|
memset(str, 0, KEY_LENGTH);
|
|
while (fgets(str, KEY_LENGTH , mhKeyFile))
|
|
{
|
|
if (!strcmp(key, kNUMBER_OF_CAMERA)
|
|
|| !strcmp(key, kCAMERA_EXIF_MAKE)
|
|
|| !strcmp(key, kCAMERA_EXIF_MODEL))
|
|
{
|
|
bFlagBegin = true;
|
|
}
|
|
|
|
if (!bFlagBegin)
|
|
{
|
|
if (!strncmp(str, "camera_id", strlen("camera_id")))
|
|
{
|
|
getValue(str, strId);
|
|
if (atoi(strId) == mCurCameraId)
|
|
{
|
|
bFlagBegin = true;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (!strncmp(str, "camera_id", strlen("camera_id")))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (!strncmp(key, str, strlen(key)))
|
|
{
|
|
getValue(str, value);
|
|
|
|
bRet = true;
|
|
break;
|
|
}
|
|
memset(str, 0, KEY_LENGTH);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|