/*
|
* Copyright (c) 2021 by Allwinnertech Co., Ltd.
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#define LOG_TAG "CCameraConfig"
|
#include "camera_config.h"
|
|
#include <cutils/properties.h>
|
|
#include "v4l2_log.h"
|
|
#define READ_KEY_VALUE(key, val) \
|
val = reinterpret_cast<char*>(::malloc(KEY_LENGTH)); \
|
if (val == 0) { \
|
HAL_LOGE("malloc %s failed", val); \
|
} \
|
memset(val, 0, KEY_LENGTH); \
|
if (readKey(key, val)) { \
|
HAL_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 { \
|
HAL_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) { \
|
HAL_LOGV("%s = %s", key, value); \
|
} else { \
|
HAL_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(InterpolationSize)
|
MEMBER_FUNCTION(ReducecallnumSize)
|
MEMBER_FUNCTION(FlashMode)
|
MEMBER_FUNCTION(ColorEffect)
|
MEMBER_FUNCTION(FrameRate)
|
MEMBER_FUNCTION(FocusMode)
|
MEMBER_FUNCTION(SceneMode)
|
MEMBER_FUNCTION(WhiteBalance)
|
|
/*
|
* Initialize static members of CCameraConfig.
|
*/
|
FILE* CCameraConfig::mhKeyFile = ::fopen(CAMERA_KEY_CONFIG_PATH, "rb");
|
int CCameraConfig::mNumberOfCamera = 0;
|
int CCameraConfig::mCameraMultiplexing = 0;
|
char CCameraConfig::mCameraMake[64] = {0};
|
char CCameraConfig::mCameraModel[64] = {0};
|
|
CCameraConfig::CCameraConfig(int id)
|
:mConstructOk(false),
|
mCurCameraId(id),
|
mCameraFacing(0),
|
mOrientation(0),
|
mSupportFrameRate(0),
|
mDeviceID(0),
|
mFastPictureMode(false) {
|
// get camera facing
|
char cameraFacing[2];
|
if (readKey(kCAMERA_FACING, cameraFacing)) {
|
mCameraFacing = atoi(cameraFacing);
|
HAL_LOGV("camera facing %s", (mCameraFacing == 0) ? "back" : "front");
|
}
|
|
// get camera device driver
|
memset(mCameraDevice, 0, sizeof(mCameraDevice));
|
if (readKey(kCAMERA_DEVICE, mCameraDevice)) {
|
HAL_LOGV("camera device %s", mCameraDevice);
|
}
|
|
// get device id
|
char deviceID[2];
|
if (readKey(kDEVICE_ID, deviceID)) {
|
mDeviceID = atoi(deviceID);
|
HAL_LOGV("camera device id %d", mDeviceID);
|
}
|
|
// get camera orientation
|
char str[4];
|
if (readKey(kCAMERA_ORIENTATION, str)) {
|
mOrientation = atoi(str);
|
int32_t rotation =
|
property_get_int32("persist.vendor.overlay.user_rotation", 0);
|
if (rotation > 0) {
|
if (mCameraFacing) {
|
mOrientation -= rotation;
|
} else {
|
mOrientation += rotation;
|
}
|
mOrientation = (mOrientation + 360) % 360;
|
}
|
HAL_LOGV("camera orientation %d", mOrientation);
|
}
|
|
// get camera support frame rate
|
char str1[4];
|
if (readKey(kSUPPORT_FRAME_RATE, str1)) {
|
mSupportFrameRate = atoi(str1);
|
}
|
|
// init other parameters
|
initParameters();
|
mConstructOk = true;
|
}
|
|
CCameraConfig::~CCameraConfig() {
|
CHECK_FREE_POINTER(PreviewSize)
|
CHECK_FREE_POINTER(PictureSize)
|
CHECK_FREE_POINTER(InterpolationSize)
|
CHECK_FREE_POINTER(ReducecallnumSize)
|
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 != NULL) {
|
::fclose(mhKeyFile);
|
mhKeyFile = NULL;
|
}
|
}
|
|
bool CCameraConfig::usedKey(char *value) {
|
return strcmp(value, "1") ? false : true;
|
}
|
|
void CCameraConfig::initParameters() {
|
if (!mConstructOk) {
|
return;
|
}
|
|
if (mhKeyFile == NULL) {
|
HAL_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;
|
HAL_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(INTERPOLATION_SIZE, InterpolationSize)
|
INIT_PARAMETER(REDUCECALLNUM_SIZE, ReducecallnumSize)
|
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 {
|
HAL_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);
|
memset(mReduceCallNum, 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 {
|
HAL_LOGV("\"%s\" not support", kUSED_ZOOM);
|
}
|
}
|
readKey(kREDUCE_CALL_NUM, mReduceCallNum);
|
readKey(KHORIZONTAL_VIEW_ANGLE, str);
|
mHorizonalViewAngle = atof(str);
|
readKey(KVERTICAL_VIEW_ANGLE, str);
|
mVerticalViewAngle = atof(str);
|
}
|
|
void CCameraConfig::dumpParameters() {
|
if (!mConstructOk) {
|
return;
|
}
|
|
if (mhKeyFile == NULL) {
|
HAL_LOGW("invalid camera config file hadle");
|
return;
|
}
|
|
HAL_LOGV("/*------------------------------------------------------*/");
|
HAL_LOGV("camrea id: %d", mCurCameraId);
|
HAL_LOGV("camera facing %s", (mCameraFacing == 0) ? "back" : "front");
|
HAL_LOGV("%s support fast picture mode", mFastPictureMode ? "" : "do not");
|
HAL_LOGV("camera orientation %d", mOrientation);
|
HAL_LOGV("camera support frame rate %d", mSupportFrameRate);
|
HAL_LOGV("camera device %s", mCameraDevice);
|
DUMP_PARAMETERS(PREVIEW_SIZE, PreviewSize)
|
DUMP_PARAMETERS(PICTURE_SIZE, PictureSize)
|
DUMP_PARAMETERS(INTERPOLATION_SIZE, InterpolationSize)
|
DUMP_PARAMETERS(REDUCECALLNUM_SIZE, ReducecallnumSize)
|
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(kREDUCE_CALL_NUM, mReduceCallNum)
|
_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)
|
HAL_LOGV("/*------------------------------------------------------*/");
|
}
|
|
void CCameraConfig::getValue(char *line, char *value) {
|
char * ptemp = line;
|
while (*ptemp) {
|
if (*ptemp++ == '=') {
|
break;
|
}
|
}
|
|
char *pval = ptemp;
|
char *saveptr = NULL;
|
const char *seps = " \n\r\t";
|
int offset = 0;
|
pval = strtok_r(pval, seps, &saveptr);
|
while (pval != NULL) {
|
strncpy(value + offset, pval, strlen(pval));
|
offset += strlen(pval);
|
pval = strtok_r(NULL, seps, &saveptr);
|
}
|
*(value + offset) = 0;
|
}
|
|
bool CCameraConfig::readKey(const char *key, char *value) {
|
return readCommonKey(key, value, mCurCameraId);
|
}
|
|
bool CCameraConfig::readCommonKey(const char *key,
|
char * value,
|
int cameraId) {
|
bool bRet = false;
|
bool bFlagBegin = false;
|
char strId[2];
|
char str[KEY_LENGTH];
|
|
if (key == 0 || value == 0) {
|
HAL_LOGE("error input para");
|
return false;
|
}
|
|
if (mhKeyFile == NULL) {
|
HAL_LOGE("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)
|
|| !strcmp(key, kCAMERA_MULTIPLEXING)) {
|
bFlagBegin = true;
|
}
|
|
if (!bFlagBegin) {
|
if (!strncmp(str, "camera_id", strlen("camera_id"))) {
|
getValue(str, strId);
|
if (atoi(strId) == cameraId) {
|
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;
|
}
|
