2193 lines
82 KiB
C++
2193 lines
82 KiB
C++
|
|
|
|
#include <stdlib.h>
|
|
#include <utils/Log.h>
|
|
#include <libexpat/expat.h>
|
|
#include <dlfcn.h>
|
|
#include <isi/isi_iss.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <time.h>
|
|
#include <fcntl.h>
|
|
#include <dlfcn.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/file.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <sys/time.h>
|
|
#include <signal.h>
|
|
#include <linux/ion.h>
|
|
#if !defined(ANDROID_5_X)
|
|
#include <linux/videodev.h>
|
|
#include <linux/android_pmem.h>
|
|
#endif
|
|
#include <linux/videodev2.h>
|
|
#include <linux/fb.h>
|
|
#include <linux/types.h>
|
|
#include <linux/version.h>
|
|
|
|
#include "CameraHal_board_xml_parse.h"
|
|
#include "CameraHal_Tracer.h"
|
|
|
|
void camera_board_profiles::ParserSensorInfo(const char *name, const char **atts, void *userData)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
rk_sensor_info *pSensorInfo = &(pCamInfo->mHardInfo.mSensorInfo);
|
|
int result;
|
|
if (strcmp(name, "SensorName")==0) {
|
|
strlcpy(pSensorInfo->mSensorName, atts[1], sizeof(pSensorInfo->mSensorName));
|
|
ALOGD("%s(%d): SensorName(%s)\n", __FUNCTION__, __LINE__, pSensorInfo->mSensorName);
|
|
} else if (strcmp(name, "SensorLens")==0) {
|
|
strlcpy(pSensorInfo->mLensName, atts[1], sizeof(pSensorInfo->mLensName));
|
|
ALOGD("%s(%d): lensName(%s)\n", __FUNCTION__, __LINE__, pSensorInfo->mLensName);
|
|
} else if (strcmp(name, "SensorDevID")==0) {
|
|
ALOGD("%s(%d): SensorDevID(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
if(strcmp("CAMSYS_DEVID_SENSOR_1A", atts[1])==0){
|
|
pSensorInfo->mCamDevid = CAMSYS_DEVID_SENSOR_1A;
|
|
}else if(strcmp("CAMSYS_DEVID_SENSOR_1B", atts[1])==0){
|
|
pSensorInfo->mCamDevid = CAMSYS_DEVID_SENSOR_1B;
|
|
}else if(strcmp("CAMSYS_DEVID_SENSOR_2", atts[1])==0){
|
|
pSensorInfo->mCamDevid = CAMSYS_DEVID_SENSOR_2;
|
|
}else{
|
|
pSensorInfo->mCamDevid = 0;
|
|
ALOGD("%s(%d): SensorDevID(%s) don't support\n", __FUNCTION__, __LINE__, atts[1]);
|
|
}
|
|
ALOGD("%s(%d): SensorDevID(%d)\n", __FUNCTION__, __LINE__, pSensorInfo->mCamDevid);
|
|
} else if (strcmp(name,"SensorHostDevID")==0){
|
|
ALOGD("%s(%d): SensorHostDevID(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
if(strcmp("CAMSYS_DEVID_MARVIN", atts[1])==0){
|
|
pSensorInfo->mHostDevid= CAMSYS_DEVID_MARVIN;
|
|
strlcpy(pSensorInfo->mCamsysDevPath, "/dev/camsys_marvin", sizeof(pSensorInfo->mCamsysDevPath));
|
|
}else if(strcmp("CAMSYS_DEVID_CIF_0", atts[1])==0){
|
|
pSensorInfo->mHostDevid = CAMSYS_DEVID_CIF_0;
|
|
strlcpy(pSensorInfo->mCamsysDevPath, "/dev/camsys_cif0", sizeof(pSensorInfo->mCamsysDevPath));
|
|
}else if(strcmp("CAMSYS_DEVID_CIF_1", atts[1])==0){
|
|
pSensorInfo->mHostDevid = CAMSYS_DEVID_CIF_1;
|
|
strlcpy(pSensorInfo->mCamsysDevPath, "/dev/camsys_cif1", sizeof(pSensorInfo->mCamsysDevPath));
|
|
}else {
|
|
pSensorInfo->mHostDevid = 0;
|
|
ALOGD("%s(%d): SensorDevID(%s) don't support\n", __FUNCTION__, __LINE__, atts[1]);
|
|
}
|
|
} else if (strcmp(name,"SensorI2cBusNum")==0){
|
|
ALOGD("%s(%d): Sensori2cBusNum(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pSensorInfo->mSensorI2cBusNum = atoi(atts[1]);
|
|
} else if (strcmp(name,"SensorI2cAddrByte")==0){
|
|
ALOGD("%s(%d): SensorI2cAddrByte(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pSensorInfo->mI2cAddrBytes = atoi(atts[1]);
|
|
} else if (strcmp(name,"SensorI2cRate")==0){
|
|
ALOGD("%s(%d): SensorI2cRate(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pSensorInfo->mSensorI2cRate = atoi(atts[1]);
|
|
} else if (strcmp(name,"SensorMclk")==0){
|
|
ALOGD("%s(%d): SensorMclk(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pSensorInfo->mMclkRate = atoi(atts[1]);
|
|
} else if (strcmp(name,"SensorAvdd")==0){
|
|
ALOGD("%s(%d): SensorAvdd(%s) min(%s) max(%s)\n", __FUNCTION__, __LINE__, atts[1], atts[3], atts[5]);
|
|
strlcpy((char*)pSensorInfo->mAvdd.name, (atts[1]), sizeof(pSensorInfo->mAvdd.name));
|
|
pSensorInfo->mAvdd.min_uv = atoi(atts[3]);
|
|
pSensorInfo->mAvdd.max_uv = atoi(atts[5]);
|
|
} else if (strcmp(name,"SensorDovdd")==0){
|
|
ALOGD("%s(%d): SensorDovdd(%s) min(%s) max(%s)\n", __FUNCTION__, __LINE__, atts[1], atts[3], atts[5]);
|
|
strlcpy((char*)pSensorInfo->mDovdd.name, (atts[1]), sizeof(pSensorInfo->mDovdd.name));
|
|
pSensorInfo->mDovdd.min_uv = atoi(atts[3]);
|
|
pSensorInfo->mDovdd.max_uv = atoi(atts[5]);
|
|
} else if (strcmp(name,"SensorDvdd")==0){
|
|
ALOGD("%s(%d): SensorDvdd(%s) min(%s) max(%s)\n", __FUNCTION__, __LINE__, atts[1], atts[3], atts[5]);
|
|
strlcpy((char*)pSensorInfo->mDvdd.name, (atts[1]), sizeof(pSensorInfo->mDvdd.name));
|
|
pSensorInfo->mDvdd.min_uv = atoi(atts[3]);
|
|
pSensorInfo->mDvdd.max_uv = atoi(atts[5]);
|
|
} else if (strcmp(name,"SensorGpioPwdn")==0){
|
|
ALOGD("%s(%d): SensorGpioPwdn(%s) active(%s) \n", __FUNCTION__, __LINE__, atts[1], atts[3]);
|
|
strlcpy((char*)pSensorInfo->mSensorGpioPwdn.name, (atts[1]), sizeof(pSensorInfo->mSensorGpioPwdn.name));
|
|
pSensorInfo->mSensorGpioPwdn.active = atoi(atts[3]);
|
|
} else if (strcmp(name,"SensorGpioRst")==0){
|
|
ALOGD("%s(%d): SensorGpioRst(%s) active(%s) \n", __FUNCTION__, __LINE__, atts[1], atts[3]);
|
|
strlcpy((char*)pSensorInfo->mSensorGpioReset.name, (atts[1]), sizeof(pSensorInfo->mSensorGpioReset.name));
|
|
pSensorInfo->mSensorGpioReset.active = atoi(atts[3]);
|
|
} else if (strcmp(name,"SensorGpioPwen")==0){
|
|
ALOGD("%s(%d): SensorGpioPwen(%s) active(%s) \n", __FUNCTION__, __LINE__, atts[1], atts[3]);
|
|
strlcpy((char*)pSensorInfo->SensorGpioPwen.name, (atts[1]), sizeof(pSensorInfo->SensorGpioPwen.name));
|
|
pSensorInfo->SensorGpioPwen.active = atoi(atts[3]);
|
|
}else if (strcmp(name,"SensorFacing")==0){
|
|
ALOGD("%s(%d): SensorFacing(%s) \n", __FUNCTION__, __LINE__, atts[1]);
|
|
if(strcmp("front", atts[1])==0){
|
|
pSensorInfo->mFacing = RK_CAM_FACING_FRONT;
|
|
}else if(strcmp("back", atts[1])==0){
|
|
pSensorInfo->mFacing = RK_CAM_FACING_BACK;
|
|
}else{
|
|
ALOGD("%s(%d): SensorFacing(%s) is wrong \n", __FUNCTION__, __LINE__, atts[1]);
|
|
}
|
|
} else if (strcmp(name,"SensorInterface")==0){
|
|
ALOGD("%s(%d): SensorInterface(%s) \n", __FUNCTION__, __LINE__, atts[1]);
|
|
if(strcmp("CCIR601", atts[1])==0){
|
|
pSensorInfo->mMode = CCIR601;
|
|
}else if(strcmp("MIPI", atts[1])==0){
|
|
pSensorInfo->mMode = MIPI;
|
|
}else if(strcmp("SMIA", atts[1])==0){
|
|
pSensorInfo->mMode = SMIA;
|
|
}else if(strcmp("CCIR656", atts[1])==0){
|
|
pSensorInfo->mMode = CCIR656;
|
|
}else{
|
|
ALOGD("%s(%d): SensorInterface(%s) don't support \n", __FUNCTION__, __LINE__, atts[1]);
|
|
}
|
|
} else if (strcmp(name,"SensorMirrorFlip")==0){
|
|
ALOGD("%s(%d): SensorMirrorFlip(%s) \n", __FUNCTION__, __LINE__, atts[1]);
|
|
pSensorInfo->mMirrorFilp = atoi(atts[1]);
|
|
} else if (strcmp(name,"SensorPowerupSequence")==0){
|
|
ALOGD("%s(%d): SensorPowerupSequence(%s) \n", __FUNCTION__, __LINE__, atts[1]);
|
|
pSensorInfo->mSensorPowerupSequence = atoi(atts[1]);
|
|
} else if(strcmp(name, "SensorOrientation")==0){
|
|
ALOGD("%s(%d): SensorOrientation(%s) \n", __FUNCTION__, __LINE__, atts[1]);
|
|
pSensorInfo->mOrientation = atoi(atts[1]);
|
|
}else if(strcmp(name, "SensorDriver")==0){
|
|
ALOGD("%s(%d): SensorDriver(%s) \n", __FUNCTION__, __LINE__, atts[1]);
|
|
strlcpy(pSensorInfo->mSensorDriver, atts[1], sizeof(pSensorInfo->mSensorDriver));
|
|
}else if(strcmp(name, "SensorPhy")==0){
|
|
camsys_fmt_t fmt;
|
|
|
|
if(strcmp(atts[7], "CamSys_Fmt_Yuv420_8b")==0){
|
|
fmt = CamSys_Fmt_Yuv420_8b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_Yuv420_10b")==0){
|
|
fmt = CamSys_Fmt_Yuv420_10b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_LegacyYuv420_8b")==0){
|
|
fmt = CamSys_Fmt_LegacyYuv420_8b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_Yuv422_8b")==0){
|
|
fmt = CamSys_Fmt_Yuv422_8b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_Yuv422_10b")==0){
|
|
fmt = CamSys_Fmt_Yuv422_10b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_Raw_6b")==0){
|
|
fmt = CamSys_Fmt_Raw_6b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_Raw_7b")==0){
|
|
fmt = CamSys_Fmt_Raw_7b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_Raw_8b")==0){
|
|
fmt = CamSys_Fmt_Raw_8b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_Raw_10b")==0){
|
|
fmt = CamSys_Fmt_Raw_10b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_Raw_12b")==0){
|
|
fmt = CamSys_Fmt_Raw_12b;
|
|
}else if(strcmp(atts[7], "CamSys_Fmt_Raw_14b")==0){
|
|
fmt = CamSys_Fmt_Raw_14b;
|
|
}else {
|
|
fmt = CamSys_Fmt_Raw_10b;
|
|
ALOGE("%s(%d): unknown fmt (%s) \n", __FUNCTION__, __LINE__ , atts[7]);
|
|
}
|
|
|
|
if(strcmp(atts[1], "CamSys_Phy_Mipi")==0){
|
|
pSensorInfo->mPhy.type = CamSys_Phy_Mipi;
|
|
int laneNum = atoi(atts[3]);
|
|
if(laneNum<=1 || laneNum>4){
|
|
ALOGE("%s(%d): SensorPhy laneNum wrong (%s) range[1,4]\n", __FUNCTION__, __LINE__, atts[3]);
|
|
if(laneNum<1)
|
|
laneNum=1;
|
|
if(laneNum>4)
|
|
laneNum=4;
|
|
}
|
|
|
|
int data_en_bit = 0;
|
|
int i=0;
|
|
while(laneNum){
|
|
data_en_bit |= (1<<i) ;
|
|
laneNum--;
|
|
i++;
|
|
}
|
|
|
|
int phyIndex = atoi(atts[5]);
|
|
if(phyIndex<0 || phyIndex>1){
|
|
ALOGE("%s(%d): SensorPhy phyIndex wrong (%s) range[0,1]\n", __FUNCTION__, __LINE__, atts[9]);
|
|
if(phyIndex<0)
|
|
phyIndex = 0;
|
|
if(phyIndex>1)
|
|
phyIndex = 1;
|
|
}
|
|
|
|
pSensorInfo->mPhy.info.mipi.data_en_bit = data_en_bit;
|
|
pSensorInfo->mPhy.info.mipi.phy_index = phyIndex;
|
|
pSensorInfo->laneNum = atoi(atts[3]);
|
|
pSensorInfo->fmt = fmt;
|
|
ALOGD("%s(%d): SensorPhy: MIPI lane: %d phyindex: %d fmt: 0x%x\n",
|
|
__FUNCTION__,__LINE__,pSensorInfo->laneNum, pSensorInfo->mPhy.info.mipi.phy_index , fmt);
|
|
}else if(strcmp(atts[1], "CamSys_Phy_Cif")==0){
|
|
pSensorInfo->mPhy.type = CamSys_Phy_Cif;
|
|
|
|
if (strcmp(atts[3], "0") == 0) {
|
|
pSensorInfo->mPhy.info.cif.cifio = CamSys_SensorBit0_CifBit0;
|
|
} else if (strcmp(atts[3], "2") == 0) {
|
|
pSensorInfo->mPhy.info.cif.cifio = CamSys_SensorBit0_CifBit2;
|
|
}else if (strcmp(atts[3], "4") == 0) {
|
|
pSensorInfo->mPhy.info.cif.cifio = CamSys_SensorBit0_CifBit4;
|
|
}
|
|
|
|
pSensorInfo->mPhy.info.cif.cif_num = atoi(atts[5]);
|
|
pSensorInfo->mPhy.info.cif.fmt = fmt;
|
|
|
|
ALOGD("%s(%d): SensorPhy: CIF sensor_d0_to_cif_d: %s cifnum: %d fmt: 0x%x\n",
|
|
__FUNCTION__,__LINE__,atts[3], pSensorInfo->mPhy.info.cif.cif_num , fmt);
|
|
|
|
}else{
|
|
ALOGE("%s(%d): unknown phy mode(%s) \n" ,__FUNCTION__,__LINE__, atts[1]);
|
|
}
|
|
strlcpy(pSensorInfo->mSensorDriver, atts[1], sizeof(pSensorInfo->mSensorDriver));
|
|
}
|
|
else if(strcmp(name, "SensorFovParemeter")==0){
|
|
sscanf(atts[1], "%f", &(pSensorInfo->fov_h));
|
|
sscanf(atts[3], "%f", &(pSensorInfo->fov_v));
|
|
ALOGD("%s(%d): SensorFovParemeter fov_h(%s)(%f) fov_v(%s)(%f) \n", __FUNCTION__, __LINE__, atts[1],pSensorInfo->fov_h, atts[3],pSensorInfo->fov_v);
|
|
}
|
|
else if(strcmp(name, "SensorAWB_Frame_Skip")==0){
|
|
ALOGD("%s(%d): SensorAWB_Frame_Skip fps(%s) \n", __FUNCTION__, __LINE__, atts[1]);
|
|
pSensorInfo->awb_frame_skip = atoi(atts[1]);
|
|
}
|
|
}
|
|
|
|
void camera_board_profiles::ParserVCMInfo(const char *name, const char **atts, void *userData)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
rk_vcm_info *pVcmInfo = &(pCamInfo->mHardInfo.mVcmInfo);
|
|
|
|
if (strcmp(name, "VCMDrvName")==0) {
|
|
ALOGD("%s(%d): VCMDrvName(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
strlcpy(pVcmInfo->mVcmDrvName, atts[1], sizeof(pVcmInfo->mVcmDrvName));
|
|
} else if (strcmp(name, "VCMName")==0) {
|
|
ALOGD("%s(%d): VCMName(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
strlcpy(pVcmInfo->mVcmName, atts[1], sizeof(pVcmInfo->mVcmName));
|
|
} else if (strcmp(name, "VCMI2cBusNum")==0) {
|
|
ALOGD("%s(%d): VCMI2cBusNum(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pVcmInfo->mVcmI2cBusNum = atoi(atts[1]);
|
|
} else if (strcmp(name,"VCMI2cAddrByte")==0){
|
|
ALOGD("%s(%d): VCMI2cAddrByte(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pVcmInfo->mI2cAddrBytes = atoi(atts[1]);
|
|
} else if (strcmp(name,"VCMI2cRate")==0){
|
|
ALOGD("%s(%d): VCMI2cRate(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pVcmInfo->mVcmI2cRate = atoi(atts[1]);
|
|
} else if (strcmp(name,"VCMGpioPwdn")==0){
|
|
ALOGD("%s(%d): VCMGpioPwdn(%s) active(%s) \n", __FUNCTION__, __LINE__, atts[1], atts[3]);
|
|
strlcpy((char*)pVcmInfo->mVcmGpioPwdn.name, (atts[1]), sizeof(pVcmInfo->mVcmGpioPwdn.name));
|
|
pVcmInfo->mVcmGpioPwdn.active = atoi(atts[3]);
|
|
} else if (strcmp(name,"VCMGpioPower")==0){
|
|
ALOGD("%s(%d): VCMGpioPower(%s) active(%s) \n", __FUNCTION__, __LINE__, atts[1], atts[3]);
|
|
strlcpy((char*)pVcmInfo->mVcmGpioPower.name, (atts[1]), sizeof(pVcmInfo->mVcmGpioPower.name));
|
|
pVcmInfo->mVcmGpioPower.active = atoi(atts[3]);
|
|
} else if (strcmp(name,"VCMVdd")==0){
|
|
ALOGD("%s(%d): VCMVdd(%s) min(%s) max(%s)\n", __FUNCTION__, __LINE__, atts[1], atts[3], atts[5]);
|
|
strlcpy((char*)pVcmInfo->mVcmVdd.name, (atts[1]), sizeof(pVcmInfo->mVcmVdd.name));
|
|
pVcmInfo->mVcmVdd.min_uv= atoi(atts[3]);
|
|
pVcmInfo->mVcmVdd.max_uv= atoi(atts[5]);
|
|
} else if (strcmp(name,"VCMCurrent") == 0) {
|
|
pVcmInfo->mStartCurrent = atoi(atts[1]);
|
|
pVcmInfo->mRatedCurrent = atoi(atts[3]);
|
|
pVcmInfo->mVcmMaxCurrent = atoi(atts[5]);
|
|
pVcmInfo->mStepMode = atoi(atts[7]);
|
|
pVcmInfo->mVcmDrvMaxCurrent = atoi(atts[9]);
|
|
ALOGD("%s(%d): start current(%d) rated current(%d) vcm max(%d) step mode(%d) drv max(%d) \n",
|
|
__FUNCTION__, __LINE__,
|
|
pVcmInfo->mStartCurrent,
|
|
pVcmInfo->mRatedCurrent,
|
|
pVcmInfo->mVcmMaxCurrent,
|
|
pVcmInfo->mStepMode,
|
|
pVcmInfo->mVcmDrvMaxCurrent);
|
|
}
|
|
|
|
}
|
|
|
|
void camera_board_profiles::ParserFlashInfo(const char *name, const char **atts, void *userData)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
rk_flash_info *pFlashInfo = &(pCamInfo->mHardInfo.mFlashInfo);
|
|
rk_flash_config *pFlashConfig = &(pCamInfo->mSoftInfo.mFlashConfig);
|
|
int support = 0;
|
|
|
|
if (strcmp(name, "FlashName")==0) {
|
|
ALOGD("%s(%d): FlashName(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
strlcpy(pFlashInfo->mFlashName, atts[1], sizeof(pFlashInfo->mFlashName));
|
|
} else if (strcmp(name, "FlashI2cBusNum")==0) {
|
|
ALOGD("%s(%d): FlashI2cBusNum(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pFlashInfo->mFlashI2cBusNum = atoi(atts[1]);
|
|
} else if (strcmp(name,"FlashI2cAddrByte")==0){
|
|
ALOGD("%s(%d): FlashI2cAddrByte(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pFlashInfo->mI2cAddrBytes = atoi(atts[1]);
|
|
} else if (strcmp(name,"FlashI2cRate")==0){
|
|
ALOGD("%s(%d): FlashI2cRate(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
pFlashInfo->mFlashI2cRate = atoi(atts[1]);
|
|
} else if (strcmp(name,"FlashTrigger")==0){
|
|
ALOGD("%s(%d): FlashTrigger(%s) active(%s) \n", __FUNCTION__, __LINE__, atts[1], atts[3]);
|
|
strlcpy((char*)pFlashInfo->mFlashTrigger.name, (atts[1]), sizeof(pFlashInfo->mFlashTrigger.name));
|
|
pFlashInfo->mFlashTrigger.active = atoi(atts[3]);
|
|
} else if (strcmp(name,"FlashEn")==0){
|
|
ALOGD("%s(%d): FlashEn(%s) active(%s) \n", __FUNCTION__, __LINE__, atts[1], atts[3]);
|
|
strlcpy((char*)pFlashInfo->mFlashEn.name, (atts[1]), sizeof(pFlashInfo->mFlashEn.name));
|
|
pFlashInfo->mFlashEn.active = atoi(atts[3]);
|
|
}else if(strcmp(name,"FlashModeType")==0){
|
|
pFlashInfo->mFlashMode = atoi(atts[1]);
|
|
}else if(strcmp(name,"FlashLuminance")==0){
|
|
pFlashInfo->mLuminance = atof(atts[1]);
|
|
ALOGD("%s(%d): FlashLuminance(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
}else if(strcmp(name,"FlashColorTemp")==0){
|
|
pFlashInfo->mColorTemperature = atof(atts[1]);
|
|
ALOGD("%s(%d): FlashColorTemp(%s)\n", __FUNCTION__, __LINE__, atts[1]);
|
|
}else if (strcmp(name, "Flash_Mode_Off")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFlashConfig->mFlashSupport |= (0x01<<FLASH_MODE_OFF_BITPOS);
|
|
} else if (strcmp(name, "Flash_Mode_On")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFlashConfig->mFlashSupport |= (0x01<<FLASH_MODE_ON_BITPOS);
|
|
} else if (strcmp(name,"Flash_Mode_Torch")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFlashConfig->mFlashSupport |= (0x01<<FLASH_MODE_TORCH_BITPOS);
|
|
} else if (strcmp(name,"Flash_Mode_Auto")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFlashConfig->mFlashSupport |= (0x01<<FLASH_MODE_AUTO_BITPOS);
|
|
} else if (strcmp(name,"Flash_Mode_Red_Eye")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFlashConfig->mFlashSupport |= (0x01<<FLASH_MODE_RED_EYE_BITPOS);
|
|
}
|
|
|
|
}
|
|
|
|
void camera_board_profiles::ParserAwbConfig(const char *name, const char **atts, void *userData)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
rk_white_balance_config *pAWBConfig = &(pCamInfo->mSoftInfo.mAwbConfig);
|
|
int support = 0;
|
|
|
|
if (strcmp(name, "AWB_Auto")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAWBConfig->mAwbSupport |= (0x01<<AWB_AUTO_BITPOS );
|
|
} else if (strcmp(name, "AWB_Incandescent")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAWBConfig->mAwbSupport |= (0x01<<AWB_INCANDESCENT_BITPOS);
|
|
} else if (strcmp(name,"AWB_Fluorescent")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAWBConfig->mAwbSupport |= (0x01<<AWB_FLUORESCENT_BITPOS);
|
|
} else if (strcmp(name,"AWB_Warm_Fluorescent")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAWBConfig->mAwbSupport |= (0x01<<AWB_WARM_FLUORESCENT_BITPOS);
|
|
} else if (strcmp(name,"AWB_Daylight")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAWBConfig->mAwbSupport |= (0x01<<AWB_DAYLIGHT_BITPOS);
|
|
} else if (strcmp(name,"AWB_Cloudy_Daylight")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAWBConfig->mAwbSupport |= (0x01<<AWB_CLOUDY_BITPOS);
|
|
} else if (strcmp(name,"AWB_Twilight")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAWBConfig->mAwbSupport |= (0x01<<AWB_TWILIGHT_BITPOS);
|
|
} else if (strcmp(name,"AWB_Shade")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAWBConfig->mAwbSupport |= (0x01<<AWB_SHADE_BITPOS);
|
|
}
|
|
|
|
}
|
|
|
|
void camera_board_profiles::ParserSenceConfig(const char *name, const char **atts, void *userData)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
rk_sence_config *pSenceConfig = &(pCamInfo->mSoftInfo.mSenceConfig);
|
|
int support = 0;
|
|
|
|
if (strcmp(name, "Sence_Mode_Auto")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_AUTO_BITPOS);
|
|
} else if (strcmp(name, "Sence_Mode_Action")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_ACTION_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Portrait")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_PORTRAIT_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Landscape")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_LANDSCAPE_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Night")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_NIGHT_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Night_Portrait")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_NIGHT_PORTRAIT_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Theatre")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_THEATRE_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Beach")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_BEACH_BITPOS);
|
|
} else if (strcmp(name, "Sence_Mode_Snow")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_SNOW_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Sunset")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_SUNSET_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Steayphoto")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_STEAYPHOTO_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Pireworks")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_PIREWORKS_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Sports")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_SPORTS_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Party")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport|= (0x01<<SENCE_MODE_PARTY_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Candlelight")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_CANDLELIGHT_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_Barcode")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_BARCODE_BITPOS);
|
|
} else if (strcmp(name,"Sence_Mode_HDR")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pSenceConfig->mSenceSupport |= (0x01<<SENCE_MODE_HDR_BITPOS);
|
|
}
|
|
|
|
}
|
|
|
|
void camera_board_profiles::ParserEffectConfig(const char *name, const char **atts, void *userData)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
rk_effect_config *pEffectConfig = &(pCamInfo->mSoftInfo.mEffectConfig);
|
|
int support=0;
|
|
|
|
if (strcmp(name, "Effect_None")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pEffectConfig->mEffectSupport |= (0x01<<EFFECT_NONE_BITPOS);
|
|
} else if (strcmp(name, "Effect_Mono")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pEffectConfig->mEffectSupport |= (0x01<<EFFECT_MONO_BITPOS);
|
|
} else if (strcmp(name,"Effect_Solarize")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pEffectConfig->mEffectSupport |= (0x01<<EFFECT_SOLARIZE_BITPOS);
|
|
} else if (strcmp(name,"Effect_Negative")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pEffectConfig->mEffectSupport |= (0x01<<EFFECT_NEGATIVE_BITPOS);
|
|
} else if (strcmp(name,"Effect_Sepia")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pEffectConfig->mEffectSupport |= (0x01<<EFFECT_SEPIA_BITPOS);
|
|
} else if (strcmp(name,"Effect_Posterize")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pEffectConfig->mEffectSupport |= (0x01<<EFFECT_POSTERIZE_BITPOS);
|
|
} else if (strcmp(name,"Effect_Whiteboard")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pEffectConfig->mEffectSupport |= (0x01<<EFFECT_WHITEBOARD_BITPOS);
|
|
} else if (strcmp(name,"Effect_Blackboard")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pEffectConfig->mEffectSupport |= (0x01<<EFFECT_BLACKBOARD_BITPOS);
|
|
} else if (strcmp(name,"Effect_Aqua")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pEffectConfig->mEffectSupport |= (0x01<<EFFECT_AQUE_BITPOS);
|
|
}
|
|
|
|
}
|
|
|
|
void camera_board_profiles::ParserFocusConfig(const char *name, const char **atts, void *userData)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
rk_focus_config *pFocusConfig = &(pCamInfo->mSoftInfo.mFocusConfig);
|
|
int support=0;
|
|
|
|
if (strcmp(name, "Focus_Mode_Auto")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFocusConfig->mFocusSupport |= (0x01<<FOCUS_AUTO_BITPOS);
|
|
} else if (strcmp(name, "Focus_Mode_Infinity")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFocusConfig->mFocusSupport |= (0x01<<FOCUS_INFINITY_BITPOS);
|
|
} else if (strcmp(name,"Focus_Mode_Marco")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFocusConfig->mFocusSupport |= (0x01<<FOCUS_MARCO_BITPOS);
|
|
} else if (strcmp(name,"Focus_Mode_Fixed")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFocusConfig->mFocusSupport |= (0x01<<FOCUS_FIXED_BITPOS);
|
|
} else if (strcmp(name,"Focus_Mode_Edof")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFocusConfig->mFocusSupport |= (0x01<<FOCUS_EDOF_BITPOS);
|
|
} else if (strcmp(name,"Focus_Mode_Continuous_Video")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFocusConfig->mFocusSupport |= (0x01<<FOCUS_CONTINUOUS_VIDEO_BITPOS);
|
|
} else if (strcmp(name,"Focus_Mode_Continuous_Picture")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pFocusConfig->mFocusSupport |= (0x01<<FOCUS_CONTINUOUS_PICTURE_BITPOS);
|
|
}
|
|
|
|
}
|
|
|
|
void camera_board_profiles::ParserAntiBandingConfig(const char *name, const char **atts, void *userData)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
rk_anti_banding_config *pAntiBandingConfig = &(pCamInfo->mSoftInfo.mAntiBandingConfig);
|
|
int support = 0;
|
|
|
|
if (strcmp(name, "Anti_Banding_Auto")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAntiBandingConfig->mAntiBandingSupport |= (0x01<<ANTI_BANDING_AUTO_BITPOS);
|
|
} else if (strcmp(name, "Anti_Banding_50HZ")==0) {
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAntiBandingConfig->mAntiBandingSupport |= (0x01<<ANTI_BANDING_50HZ_BITPOS);
|
|
} else if (strcmp(name,"Anti_Banding_60HZ")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAntiBandingConfig->mAntiBandingSupport |= (0x01<<ANTI_BANDING_60HZ_BITPOS);
|
|
} else if (strcmp(name,"Anti_Banding_Off")==0){
|
|
support = atoi(atts[1]);
|
|
if(support==1)
|
|
pAntiBandingConfig->mAntiBandingSupport |= (0x01<<ANTI_BANDING_OFF_BITPOS);
|
|
}
|
|
|
|
}
|
|
|
|
void camera_board_profiles::ParserDVConfig(const char *name, const char **atts, void *userData)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
rk_DV_info *pDVResolution = NULL;
|
|
|
|
if (strcmp(name, "DV_QCIF")==0) {
|
|
ALOGD("%s(%d): DV_QCIF(%s) resolution(%sx%s) fps(%s) support(%s)\n", __FUNCTION__, __LINE__, atts[1],atts[3], atts[5],atts[7],atts[9]);
|
|
pDVResolution = new rk_DV_info();
|
|
if(pDVResolution){
|
|
strlcpy(pDVResolution->mName, atts[1], sizeof(pDVResolution->mName));
|
|
pDVResolution->mWidth = atoi(atts[3]);
|
|
pDVResolution->mHeight = atoi(atts[5]);
|
|
pDVResolution->mFps = atoi(atts[7]);
|
|
pDVResolution->mIsSupport = atoi(atts[9]);
|
|
pDVResolution->mResolution = 0x00000000;
|
|
pCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);
|
|
}
|
|
} else if (strcmp(name, "DV_QVGA")==0) {
|
|
ALOGD("%s(%d): DV_QVGA(%s) resolution(%sx%s) fps(%s) support(%s)\n", __FUNCTION__, __LINE__, atts[1],atts[3], atts[5],atts[7],atts[9]);
|
|
pDVResolution = new rk_DV_info();
|
|
if(pDVResolution){
|
|
strlcpy(pDVResolution->mName, atts[1], sizeof(pDVResolution->mName));
|
|
pDVResolution->mWidth = atoi(atts[3]);
|
|
pDVResolution->mHeight = atoi(atts[5]);
|
|
pDVResolution->mFps = atoi(atts[7]);
|
|
pDVResolution->mIsSupport = atoi(atts[9]);
|
|
pDVResolution->mResolution = 0x00000000;
|
|
pCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);
|
|
}
|
|
} else if (strcmp(name,"DV_CIF")==0){
|
|
ALOGD("%s(%d): DV_CIF(%s) resolution(%sx%s) fps(%s) support(%s)\n", __FUNCTION__, __LINE__, atts[1],atts[3], atts[5],atts[7],atts[9]);
|
|
pDVResolution = new rk_DV_info();
|
|
if(pDVResolution){
|
|
strlcpy(pDVResolution->mName, atts[1], sizeof(pDVResolution->mName));
|
|
pDVResolution->mWidth = atoi(atts[3]);
|
|
pDVResolution->mHeight = atoi(atts[5]);
|
|
pDVResolution->mFps = atoi(atts[7]);
|
|
pDVResolution->mIsSupport = atoi(atts[9]);
|
|
pDVResolution->mResolution = 0x00000000;
|
|
pCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);
|
|
}
|
|
} else if (strcmp(name,"DV_VGA")==0){
|
|
ALOGD("%s(%d): DV_VGA(%s) resolution(%sx%s) fps(%s) support(%s)\n", __FUNCTION__, __LINE__, atts[1],atts[3], atts[5],atts[7],atts[9]);
|
|
pDVResolution = new rk_DV_info();
|
|
if(pDVResolution){
|
|
strlcpy(pDVResolution->mName, atts[1], sizeof(pDVResolution->mName));
|
|
pDVResolution->mWidth = atoi(atts[3]);
|
|
pDVResolution->mHeight = atoi(atts[5]);
|
|
pDVResolution->mFps = atoi(atts[7]);
|
|
pDVResolution->mIsSupport = atoi(atts[9]);
|
|
pDVResolution->mResolution = ISI_RES_VGAP15;
|
|
pCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);
|
|
}
|
|
} else if (strcmp(name, "DV_480P")==0) {
|
|
ALOGD("%s(%d): DV_480P(%s) resolution(%sx%s) fps(%s) support(%s)\n", __FUNCTION__, __LINE__, atts[1],atts[3], atts[5],atts[7],atts[9]);
|
|
pDVResolution = new rk_DV_info();
|
|
if(pDVResolution){
|
|
strlcpy(pDVResolution->mName, atts[1], sizeof(pDVResolution->mName));
|
|
pDVResolution->mWidth = atoi(atts[3]);
|
|
pDVResolution->mHeight = atoi(atts[5]);
|
|
pDVResolution->mFps = atoi(atts[7]);
|
|
pDVResolution->mIsSupport = atoi(atts[9]);
|
|
pDVResolution->mResolution = 0x000000000;
|
|
pCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);
|
|
}
|
|
} else if (strcmp(name, "DV_SVGA")==0) {
|
|
ALOGD("%s(%d): DV_SVGA(%s) resolution(%sx%s) fps(%s) support(%s)\n", __FUNCTION__, __LINE__, atts[1],atts[3], atts[5],atts[7],atts[9]);
|
|
pDVResolution = new rk_DV_info();
|
|
if(pDVResolution){
|
|
strlcpy(pDVResolution->mName, atts[1], sizeof(pDVResolution->mName));
|
|
pDVResolution->mWidth = atoi(atts[3]);
|
|
pDVResolution->mHeight = atoi(atts[5]);
|
|
pDVResolution->mFps = atoi(atts[7]);
|
|
pDVResolution->mIsSupport = atoi(atts[9]);
|
|
pDVResolution->mResolution = 0x000000000;
|
|
pCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);
|
|
}
|
|
} else if (strcmp(name,"DV_720P")==0){
|
|
ALOGD("%s(%d): DV_720P(%s) resolution(%sx%s) fps(%s) support(%s)\n", __FUNCTION__, __LINE__, atts[1],atts[3], atts[5],atts[7],atts[9]);
|
|
pDVResolution = new rk_DV_info();
|
|
if(pDVResolution){
|
|
strlcpy(pDVResolution->mName, atts[1], sizeof(pDVResolution->mName));
|
|
pDVResolution->mWidth = atoi(atts[3]);
|
|
pDVResolution->mHeight = atoi(atts[5]);
|
|
pDVResolution->mFps = atoi(atts[7]);
|
|
pDVResolution->mIsSupport = atoi(atts[9]);
|
|
pDVResolution->mResolution = (ISI_RES_TV720P5 | ISI_RES_TV720P15 |ISI_RES_TV720P30 |ISI_RES_TV720P60);;
|
|
pCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);
|
|
}
|
|
} else if (strcmp(name,"DV_1080P")==0){
|
|
ALOGD("%s(%d): DV_1080P(%s) resolution(%sx%s) fps(%s) support(%s)\n", __FUNCTION__, __LINE__, atts[1],atts[3], atts[5],atts[7],atts[9]);
|
|
pDVResolution = new rk_DV_info();
|
|
if(pDVResolution){
|
|
strlcpy(pDVResolution->mName, atts[1], sizeof(pDVResolution->mName));
|
|
pDVResolution->mWidth = atoi(atts[3]);
|
|
pDVResolution->mHeight = atoi(atts[5]);
|
|
pDVResolution->mFps = atoi(atts[7]);
|
|
pDVResolution->mIsSupport = atoi(atts[9]);
|
|
pDVResolution->mResolution = (ISI_RES_TV1080P5 |ISI_RES_TV1080P12 |ISI_RES_TV1080P15 |ISI_RES_TV1080P20 |ISI_RES_TV1080P24 |ISI_RES_TV1080P25 |ISI_RES_TV1080P30 |ISI_RES_TV1080P50 |ISI_RES_TV1080P60);
|
|
pCamInfo->mSoftInfo.mDV_vector.add(pDVResolution);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void camera_board_profiles::StartElementHandler(void *userData, const char *name, const char **atts)
|
|
{
|
|
camera_board_profiles *pCamInfoProfiles = (camera_board_profiles *) userData;
|
|
rk_cam_total_info *pCamInfo = pCamInfoProfiles->mCurDevice;
|
|
int support = 0;
|
|
|
|
if(strcmp(name,"BoardXmlVersion")==0){
|
|
int highBit = 0;
|
|
int middleBit = 0;
|
|
int lowBit = 0;
|
|
sscanf(atts[1], "v%x.%x.%x", &highBit, &middleBit, &lowBit);
|
|
pCamInfoProfiles->mBoardXmlVersion = ( (highBit&0xff)<<16 ) + ( (middleBit&0xff)<<8 ) + (lowBit&0xff) ;
|
|
ALOGD("\n\n\n Cam_board.xml Version Check: \n");
|
|
ALOGD(" /etc/cam_board.xml : %s\n",atts[1]);
|
|
ALOGD(" CameraHal_board_xml_parser: v%d.%d.%d\n",
|
|
(ConfigBoardXmlVersion&0xff0000)>>16,
|
|
(ConfigBoardXmlVersion&0xff00)>>8,
|
|
ConfigBoardXmlVersion&0xff);
|
|
}
|
|
/* ddl@rock-chips.com: v1.3.0 */
|
|
if(pCamInfoProfiles->mBoardXmlVersion != ConfigBoardXmlVersion) {
|
|
ALOGE("cam_board.xml version(v%d.%d.%d) != xml parser version(v%d.%d.%d)\n",
|
|
(pCamInfoProfiles->mBoardXmlVersion&0xff0000)>>16,
|
|
(pCamInfoProfiles->mBoardXmlVersion&0xff00)>>8,
|
|
pCamInfoProfiles->mBoardXmlVersion&0xff,
|
|
(ConfigBoardXmlVersion&0xff0000)>>16,
|
|
(ConfigBoardXmlVersion&0xff00)>>8,
|
|
ConfigBoardXmlVersion&0xff);
|
|
return;
|
|
}
|
|
|
|
if(strcmp(name,"CamDevie")==0){
|
|
rk_cam_total_info* pNewCamInfo = new rk_cam_total_info();
|
|
if(pNewCamInfo){
|
|
pCamInfoProfiles->mCurDevice= pNewCamInfo;
|
|
pCamInfoProfiles->mDevieVector.add(pNewCamInfo);
|
|
pNewCamInfo->mDeviceIndex = (pCamInfoProfiles->mDevieVector.size()) - 1;
|
|
memset(pNewCamInfo->mHardInfo.mSensorInfo.mLensName,0,CAMSYS_NAME_LEN);
|
|
}else{
|
|
ALOGE("%s(%d): Warnimg camdevice malloc fail! \n", __FUNCTION__,__LINE__);
|
|
}
|
|
}else if (strstr(name, "Sensor")) {
|
|
ParserSensorInfo(name, atts, userData);
|
|
} else if (strstr(name, "VCM")) {
|
|
ParserVCMInfo(name, atts, userData);
|
|
} else if (strstr(name,"Flash")){
|
|
ParserFlashInfo(name, atts, userData);
|
|
} else if (strstr(name,"AWB")){
|
|
ParserAwbConfig(name, atts, userData);
|
|
} else if (strstr(name,"Sence")){
|
|
ParserSenceConfig(name, atts, userData);
|
|
} else if (strstr(name,"Effect")){
|
|
ParserEffectConfig(name, atts, userData);
|
|
} else if (strstr(name,"Focus")){
|
|
ParserFocusConfig(name, atts, userData);
|
|
} else if (strstr(name,"Anti_Banding")){
|
|
ParserAntiBandingConfig(name, atts, userData);
|
|
} else if (strstr(name,"HDR")){
|
|
support = atoi(atts[1]);
|
|
pCamInfo->mSoftInfo.mHDRConfig = support;
|
|
ALOGD("%s(%d): HDR(%d)! \n", __FUNCTION__,__LINE__,support);
|
|
} else if (strstr(name,"ZSL")){
|
|
support = atoi(atts[1]);
|
|
pCamInfo->mSoftInfo.mZSLConfig= support;
|
|
ALOGD("%s(%d): ZSL(%d)! \n", __FUNCTION__,__LINE__,support);
|
|
} else if (strstr(name,"DigitalZoom")){
|
|
support = atoi(atts[1]);
|
|
pCamInfo->mSoftInfo.mZoomConfig= support;
|
|
ALOGD("%s(%d): zoom(%d)! \n", __FUNCTION__,__LINE__,support);
|
|
} else if (strstr(name,"Cproc")){
|
|
pCamInfo->mSoftInfo.mCprocConfig.mSupported = (atoi(atts[1]) == 1) ? true:false;
|
|
pCamInfo->mSoftInfo.mCprocConfig.mContrast = atof(atts[3]);
|
|
pCamInfo->mSoftInfo.mCprocConfig.mSaturation = atof(atts[5]);
|
|
pCamInfo->mSoftInfo.mCprocConfig.mHue= atof(atts[7]);
|
|
pCamInfo->mSoftInfo.mCprocConfig.mBrightness = atoi(atts[9]);
|
|
ALOGD("%s(%d): cproc support %d(contrast:%f,saturation:%f,hue:%f,brightness:%d)! \n",
|
|
__FUNCTION__,__LINE__,atoi(atts[1]),atof(atts[3]),atof(atts[5]),atof(atts[7]),atoi(atts[9]));
|
|
} else if (strstr(name,"Gammaout")){
|
|
pCamInfo->mSoftInfo.mGammaOutConfig.mSupported = (atoi(atts[1]) == 1) ? true:false;
|
|
pCamInfo->mSoftInfo.mGammaOutConfig.mGamma= atof(atts[3]);
|
|
pCamInfo->mSoftInfo.mGammaOutConfig.mOffSet= atoi(atts[5]);
|
|
ALOGD("%s(%d): Gammaout support %d(mGamma:%f,mOffSet:%d)! \n", __FUNCTION__,__LINE__,atoi(atts[1]),atof(atts[3]),atoi(atts[5]));
|
|
} else if (strstr(name,"FaceDetect")){
|
|
support = atoi(atts[1]);
|
|
pCamInfo->mSoftInfo.mFaceDetctConfig.mFaceDetectSupport = support;
|
|
pCamInfo->mSoftInfo.mFaceDetctConfig.mFaceMaxNum = atoi(atts[3]);
|
|
ALOGD("%s(%d): face detect config(%d),max face num is (%d)! \n", __FUNCTION__,__LINE__,support,atoi(atts[3]));
|
|
} else if (strstr(name,"PreviewSize")){
|
|
pCamInfo->mSoftInfo.mPreviewWidth = atoi(atts[1]);
|
|
pCamInfo->mSoftInfo.mPreviewHeight = atoi(atts[3]);
|
|
ALOGD("%s(%d): PreviewSize(%dx%d)! \n", __FUNCTION__,__LINE__,pCamInfo->mSoftInfo.mPreviewWidth,pCamInfo->mSoftInfo.mPreviewHeight);
|
|
} else if (strstr(name,"DV")){
|
|
ParserDVConfig(name, atts, userData);
|
|
} else if (strstr(name,"Continue_SnapShot")){
|
|
support = atoi(atts[1]);
|
|
pCamInfo->mSoftInfo.mContinue_snapshot_config = support;
|
|
ALOGD("%s(%d): Continue_SnapShot(%d)! \n", __FUNCTION__,__LINE__,support);
|
|
}else if(strstr(name,"InterpolationRes")){
|
|
pCamInfo->mSoftInfo.mInterpolationRes = atoi(atts[1]);
|
|
ALOGD("%s(%d): InterpolationRes(%d)! \n", __FUNCTION__,__LINE__,pCamInfo->mSoftInfo.mInterpolationRes);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
camera_board_profiles* camera_board_profiles::createInstance()
|
|
{
|
|
FILE *fp = NULL;
|
|
|
|
camera_board_profiles *profiles = new camera_board_profiles();
|
|
|
|
fp = fopen(RK_BOARD_XML_PATH, "r");
|
|
if(!fp){
|
|
LOGD("This machine have not dvp/mipi camera!!\n");
|
|
return profiles;
|
|
}
|
|
|
|
LOGD("open xml file(%s) success\n", RK_BOARD_XML_PATH);
|
|
|
|
XML_Parser parser = XML_ParserCreate(NULL);
|
|
if(parser==NULL){
|
|
ALOGE("XML_ParserCreate failed\n");
|
|
return NULL;
|
|
}
|
|
|
|
XML_SetUserData(parser, profiles);
|
|
XML_SetElementHandler(parser, StartElementHandler, NULL);
|
|
|
|
const int BUFF_SIZE = 512;
|
|
for (;;) {
|
|
void *buff = ::XML_GetBuffer(parser, BUFF_SIZE);
|
|
if (buff == NULL) {
|
|
ALOGE("failed to in call to XML_GetBuffer()");
|
|
goto exit;
|
|
}
|
|
|
|
int bytes_read = ::fread(buff, 1, BUFF_SIZE, fp);
|
|
if (bytes_read < 0) {
|
|
ALOGE("failed in call to read");
|
|
goto exit;
|
|
}
|
|
|
|
int res = XML_ParseBuffer(parser, bytes_read, bytes_read == 0);
|
|
if(res!=1){
|
|
ALOGE("XML_ParseBuffer error or susppend (%d)\n", res);
|
|
}
|
|
|
|
if (bytes_read == 0) break; // done parsing the xml file
|
|
}
|
|
|
|
exit:
|
|
XML_ParserFree(parser);
|
|
fclose(fp);
|
|
|
|
size_t nCamDev2 = profiles->mDevieVector.size();
|
|
ALOGD("number of camdevice (%d)\n", nCamDev2);
|
|
|
|
if (nCamDev2>0) {
|
|
size_t nDVnum2 = profiles->mCurDevice->mSoftInfo.mDV_vector.size();
|
|
ALOGD("now DV size(%d)\n", nDVnum2);
|
|
}
|
|
return profiles;
|
|
|
|
}
|
|
|
|
camera_board_profiles* camera_board_profiles::getInstance()
|
|
{
|
|
camera_board_profiles *profiles = createInstance();
|
|
|
|
return profiles;
|
|
}
|
|
|
|
bool camera_board_profiles::LoadALLCalibrationData(camera_board_profiles* profiles)
|
|
{
|
|
size_t nCamDev2 = profiles->mDevieVector.size();
|
|
unsigned int i=0;
|
|
char filename[50];
|
|
|
|
|
|
if(nCamDev2>=1){
|
|
for(i=0; i<nCamDev2; i++)
|
|
{
|
|
rk_sensor_info *pSensorInfo = &(profiles->mDevieVector[i]->mHardInfo.mSensorInfo);
|
|
|
|
CalibDb *pcalidb = &(profiles->mDevieVector[i]->mLoadSensorInfo.calidb);
|
|
memset(filename, 0x00, 50);
|
|
if(strlen(pSensorInfo->mLensName) == 0)
|
|
sprintf(filename, "%s.xml", pSensorInfo->mSensorName);
|
|
else
|
|
sprintf(filename, "%s_lens_%s.xml", pSensorInfo->mSensorName,pSensorInfo->mLensName);
|
|
bool res = pcalidb->CreateCalibDb(filename);
|
|
if(res){
|
|
ALOGD("load %s success\n", filename);
|
|
}else{
|
|
ALOGE("load %s failed\n", filename);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void camera_board_profiles::OpenAndRegistALLSensor(camera_board_profiles* profiles)
|
|
{
|
|
size_t nCamDev2 = profiles->mDevieVector.size();
|
|
unsigned int i=0;
|
|
char filename[50];
|
|
int err;
|
|
|
|
LOG_FUNCTION_NAME
|
|
if(nCamDev2>=1){
|
|
for(i=0; i<nCamDev2; i++)
|
|
{
|
|
OpenAndRegistOneSensor(profiles->mDevieVector[i]);
|
|
}
|
|
}
|
|
LOG_FUNCTION_NAME_EXIT
|
|
}
|
|
|
|
|
|
int camera_board_profiles::OpenAndRegistOneSensor(rk_cam_total_info *pCamInfo)
|
|
{
|
|
rk_sensor_info *pSensorInfo = &(pCamInfo->mHardInfo.mSensorInfo);
|
|
camsys_load_sensor_info* pLoadSensorInfo = &(pCamInfo->mLoadSensorInfo);
|
|
|
|
if(!pCamInfo)
|
|
return RK_RET_NULL_POINTER;
|
|
|
|
pCamInfo->mIsConnect = 0;
|
|
|
|
sprintf(pLoadSensorInfo->mSensorLibName, "%s%s.so", RK_SENSOR_LIB_PATH, pSensorInfo->mSensorName);
|
|
|
|
void *hSensorLib = dlopen( pLoadSensorInfo->mSensorLibName, RTLD_NOW/*RTLD_LAZY*/ );
|
|
if ( NULL == hSensorLib )
|
|
{
|
|
ALOGE( "%s can't open the specified driver(%s)\n", __FUNCTION__, pLoadSensorInfo->mSensorLibName);
|
|
ALOGE("dlopen err:%s.\n",dlerror());
|
|
pLoadSensorInfo->mhSensorLib = NULL;
|
|
pLoadSensorInfo->pCamDrvConfig = NULL;
|
|
return RK_RET_NULL_POINTER;
|
|
}
|
|
|
|
IsiCamDrvConfig_t *pIsiCamDrvConfig = (IsiCamDrvConfig_t *)dlsym( hSensorLib, "IsiCamDrvConfig" );
|
|
if ( NULL == pIsiCamDrvConfig )
|
|
{
|
|
ALOGE("%s (can't load sensor driver)\n", __FUNCTION__ );
|
|
ALOGE("dlsym err:%s.\n",dlerror());
|
|
if(hSensorLib)
|
|
dlclose( hSensorLib );
|
|
pLoadSensorInfo->mhSensorLib = NULL;
|
|
pLoadSensorInfo->pCamDrvConfig = NULL;
|
|
return RK_RET_NULL_POINTER;
|
|
}
|
|
|
|
// initialize function pointer
|
|
if(pIsiCamDrvConfig->pfIsiGetSensorIss){
|
|
if ( RET_SUCCESS != pIsiCamDrvConfig->pfIsiGetSensorIss( &(pIsiCamDrvConfig->IsiSensor) ) )
|
|
{
|
|
ALOGE("%s (IsiGetSensorIss failed)\n", __FUNCTION__ );
|
|
return RK_RET_FUNC_FAILED;
|
|
}
|
|
}else{
|
|
ALOGE("%s ERROR(driver(%s) don't support IsiGetSensorIss)\n", __FUNCTION__, pSensorInfo->mSensorName);
|
|
return RK_RET_NULL_POINTER;
|
|
}
|
|
|
|
pLoadSensorInfo->mhSensorLib = hSensorLib;
|
|
pLoadSensorInfo->pCamDrvConfig = pIsiCamDrvConfig;
|
|
|
|
if(pIsiCamDrvConfig->pfIsiGetSensorI2cInfo){
|
|
sensor_i2c_info_t* pI2cInfo;
|
|
if(RET_SUCCESS != pIsiCamDrvConfig->pfIsiGetSensorI2cInfo(&pI2cInfo)){
|
|
ALOGE("GET I2C INFO ERRO !!!!!!!!!!!!!!!!");
|
|
return RK_RET_FUNC_FAILED;
|
|
}
|
|
|
|
pCamInfo->mLoadSensorInfo.mpI2cInfo = pI2cInfo;
|
|
//register i2c device
|
|
int err = RegisterSensorDevice(pCamInfo);
|
|
if(err==RK_RET_SUCCESS)
|
|
{
|
|
if(pIsiCamDrvConfig->IsiSensor.pIsiSensorCaps->SensorOutputMode == ISI_SENSOR_OUTPUT_MODE_RAW){
|
|
CalibDb *pcalidb = &(pCamInfo->mLoadSensorInfo.calidb);
|
|
if(strlen(pSensorInfo->mLensName) == 0)
|
|
sprintf(pLoadSensorInfo->mSensorXmlFile, "%s%s", RK_SENSOR_XML_PATH, pSensorInfo->mSensorName);
|
|
else
|
|
sprintf(pLoadSensorInfo->mSensorXmlFile, "%s%s_lens_%s", RK_SENSOR_XML_PATH, pSensorInfo->mSensorName,pSensorInfo->mLensName);
|
|
if(pCamInfo->mHardInfo.mIsOTP == true)
|
|
strcat(pLoadSensorInfo->mSensorXmlFile,"_OTP.xml");
|
|
else
|
|
strcat(pLoadSensorInfo->mSensorXmlFile,".xml");
|
|
|
|
LOGD("sensor xml file name : %s lens name %s",pLoadSensorInfo->mSensorXmlFile,pSensorInfo->mLensName);
|
|
bool res = pcalidb->CreateCalibDb(pLoadSensorInfo->mSensorXmlFile);
|
|
if(res){
|
|
pCamInfo->mIsConnect = 1;
|
|
return RK_RET_SUCCESS;
|
|
}else{
|
|
ALOGE("load %s failed\n", pLoadSensorInfo->mSensorXmlFile);
|
|
return RK_RET_FUNC_FAILED;
|
|
}
|
|
}else{
|
|
pCamInfo->mIsConnect = 1;
|
|
return RK_RET_SUCCESS;
|
|
}
|
|
}else{
|
|
ALOGE("%s device register failed!",pSensorInfo->mSensorName);
|
|
if(hSensorLib)
|
|
dlclose( hSensorLib );
|
|
return RK_RET_NOSETUP;
|
|
}
|
|
}else{
|
|
ALOGE("sensor(%s)'s driver don't have func pfIsiGetSensorI2cInfo\n", pSensorInfo->mSensorName);
|
|
return RK_RET_NULL_POINTER;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sensor_write_i2c(
|
|
void* context,
|
|
int camsys_fd,
|
|
const uint32_t reg_address,
|
|
const uint32_t value,
|
|
int* i2c_base_info
|
|
)
|
|
{
|
|
int err = RK_RET_SUCCESS;
|
|
camsys_i2c_info_t i2cinfo;
|
|
rk_cam_total_info* pCamInfo = (rk_cam_total_info*)context;
|
|
rk_sensor_info *pSensorInfo = &(pCamInfo->mHardInfo.mSensorInfo);
|
|
camsys_load_sensor_info *pLoadInfo = &(pCamInfo->mLoadSensorInfo);
|
|
|
|
if(i2c_base_info != NULL && i2c_base_info[0] != 0){
|
|
i2cinfo.bus_num = pSensorInfo->mSensorI2cBusNum;
|
|
i2cinfo.slave_addr = i2c_base_info[0];
|
|
i2cinfo.reg_addr = reg_address;
|
|
i2cinfo.reg_size = i2c_base_info[1];
|
|
i2cinfo.val = value;
|
|
i2cinfo.val_size = i2c_base_info[2];
|
|
i2cinfo.i2cbuf_directly = 0;
|
|
i2cinfo.speed = pSensorInfo->mSensorI2cRate;
|
|
}else{
|
|
i2cinfo.bus_num = pSensorInfo->mSensorI2cBusNum;
|
|
i2cinfo.slave_addr = pLoadInfo->mpI2cInfo->i2c_addr;
|
|
i2cinfo.reg_addr = reg_address;
|
|
i2cinfo.reg_size = pLoadInfo->mpI2cInfo->reg_size;
|
|
i2cinfo.val = value;
|
|
i2cinfo.val_size = pLoadInfo->mpI2cInfo->value_size;
|
|
i2cinfo.i2cbuf_directly = 0;
|
|
i2cinfo.speed = pSensorInfo->mSensorI2cRate;
|
|
|
|
}
|
|
|
|
err = ioctl(camsys_fd, CAMSYS_I2CWR, &i2cinfo);
|
|
if (err<0) {
|
|
ALOGE("%s failed\n",__FUNCTION__);
|
|
err = RK_RET_DEVICEERR;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static int sensor_read_i2c(
|
|
void* context,
|
|
int camsys_fd,
|
|
const uint32_t reg_address,
|
|
int* i2c_base_info
|
|
)
|
|
{
|
|
int err = RK_RET_SUCCESS;
|
|
camsys_i2c_info_t i2cinfo;
|
|
rk_cam_total_info* pCamInfo = (rk_cam_total_info*)context;
|
|
rk_sensor_info *pSensorInfo = &(pCamInfo->mHardInfo.mSensorInfo);
|
|
camsys_load_sensor_info *pLoadInfo = &(pCamInfo->mLoadSensorInfo);
|
|
|
|
if(i2c_base_info != NULL && i2c_base_info[0] != 0){
|
|
i2cinfo.bus_num = pSensorInfo->mSensorI2cBusNum;
|
|
i2cinfo.slave_addr = i2c_base_info[0];
|
|
i2cinfo.reg_addr = reg_address;
|
|
i2cinfo.reg_size = i2c_base_info[1];
|
|
i2cinfo.val = 0;
|
|
i2cinfo.val_size = i2c_base_info[2];
|
|
i2cinfo.i2cbuf_directly = 0;
|
|
i2cinfo.speed = pSensorInfo->mSensorI2cRate;
|
|
}else{
|
|
i2cinfo.bus_num = pSensorInfo->mSensorI2cBusNum;
|
|
i2cinfo.slave_addr = pLoadInfo->mpI2cInfo->i2c_addr;
|
|
i2cinfo.reg_addr = reg_address;
|
|
i2cinfo.reg_size = pLoadInfo->mpI2cInfo->reg_size;
|
|
i2cinfo.val = 0;
|
|
i2cinfo.val_size = pLoadInfo->mpI2cInfo->value_size;
|
|
i2cinfo.i2cbuf_directly = 0;
|
|
i2cinfo.speed = pSensorInfo->mSensorI2cRate;
|
|
}
|
|
|
|
err = ioctl(camsys_fd, CAMSYS_I2CRD, &i2cinfo);
|
|
if (err<0) {
|
|
ALOGE("%s failed\n",__FUNCTION__);
|
|
err = RK_RET_DEVICEERR;
|
|
}else
|
|
err = i2cinfo.val;
|
|
return err;
|
|
}
|
|
|
|
int camera_board_profiles::RegisterSensorDevice(rk_cam_total_info* pCamInfo)
|
|
{
|
|
int err = RK_RET_SUCCESS,i;
|
|
camsys_sysctrl_t sysctl;
|
|
camsys_devio_name_t extdev;
|
|
camsys_i2c_info_t i2cinfo;
|
|
camsys_querymem_t qmem1, qmem2;
|
|
// unsigned int *regbase=MAP_FAILED, *i2cbase=MAP_FAILED;
|
|
unsigned int i2cbytes;
|
|
struct rk_sensor_reg *sensor_reg;
|
|
unsigned char *i2cchar;
|
|
int camsys_fd=-1;
|
|
int regist_ret=-1;
|
|
int ret = RK_RET_SUCCESS;
|
|
|
|
//for test
|
|
//return RK_RET_SUCCESS;
|
|
|
|
rk_sensor_info *pSensorInfo = &(pCamInfo->mHardInfo.mSensorInfo);
|
|
rk_vcm_info *pVcmInfo = &(pCamInfo->mHardInfo.mVcmInfo);
|
|
camsys_load_sensor_info *pLoadInfo = &(pCamInfo->mLoadSensorInfo);
|
|
rk_flash_info *pFlashInfo = &(pCamInfo->mHardInfo.mFlashInfo);
|
|
sensor_i2c_info_t *pI2cInfo = pLoadInfo->mpI2cInfo;
|
|
|
|
camsys_fd = open(pSensorInfo->mCamsysDevPath, O_RDWR);
|
|
if (camsys_fd < 0) {
|
|
ALOGE("Open (%s) failed, error=(%s)\n", pSensorInfo->mCamsysDevPath,strerror(errno));
|
|
err = RK_RET_NOFILE;
|
|
ret = RK_RET_NOFILE;
|
|
goto end;
|
|
}
|
|
|
|
memset(&extdev,0x00, sizeof(camsys_devio_name_t));
|
|
pCamInfo->mLoadSensorInfo.mCamsysFd = camsys_fd;
|
|
|
|
strlcpy((char*)extdev.dev_name, (char*)pSensorInfo->mSensorName, sizeof(extdev.dev_name));
|
|
extdev.dev_id = pSensorInfo->mCamDevid;
|
|
strlcpy((char*)extdev.avdd.name, (char*)pSensorInfo->mAvdd.name,sizeof(extdev.avdd.name));
|
|
//strlcpy((char*)extdev.avdd.name, pSensorInfo->mAvdd.name,2);
|
|
extdev.avdd.min_uv = pSensorInfo->mAvdd.min_uv;
|
|
extdev.avdd.max_uv = pSensorInfo->mAvdd.max_uv;
|
|
strlcpy((char*)extdev.dovdd.name,(char*)pSensorInfo->mDovdd.name,sizeof(extdev.dovdd.name));
|
|
extdev.dovdd.min_uv = pSensorInfo->mDovdd.min_uv;
|
|
extdev.dovdd.max_uv = pSensorInfo->mDovdd.max_uv;
|
|
strlcpy((char*)extdev.dvdd.name, (char*)pSensorInfo->mDvdd.name,sizeof(extdev.dvdd.name));
|
|
extdev.dvdd.min_uv = pSensorInfo->mDvdd.min_uv;
|
|
extdev.dvdd.max_uv = pSensorInfo->mDvdd.max_uv;
|
|
strlcpy((char*)extdev.afvdd.name, (char*)pVcmInfo->mVcmVdd.name,sizeof(extdev.afvdd.name));
|
|
extdev.afvdd.min_uv = pVcmInfo->mVcmVdd.min_uv;
|
|
extdev.afvdd.max_uv = pVcmInfo->mVcmVdd.max_uv;
|
|
|
|
strlcpy((char*)extdev.pwrdn.name, (char*)pSensorInfo->mSensorGpioPwdn.name,sizeof(extdev.pwrdn.name));
|
|
extdev.pwrdn.active = pSensorInfo->mSensorGpioPwdn.active;
|
|
strlcpy((char*)extdev.rst.name, (char*)pSensorInfo->mSensorGpioReset.name,sizeof(extdev.rst.name));
|
|
extdev.rst.active = pSensorInfo->mSensorGpioReset.active;
|
|
|
|
strlcpy((char*)extdev.pwren.name, (char*)pSensorInfo->SensorGpioPwen.name,sizeof(extdev.pwren.name));
|
|
extdev.pwren.active = pSensorInfo->SensorGpioPwen.active;
|
|
|
|
strlcpy((char*)extdev.afpwrdn.name, (char*)pVcmInfo->mVcmGpioPwdn.name,sizeof(extdev.afpwrdn.name));
|
|
extdev.afpwrdn.active = pVcmInfo->mVcmGpioPwdn.active;
|
|
strlcpy((char*)extdev.afpwr.name, (char*)pVcmInfo->mVcmGpioPower.name,sizeof(extdev.afpwr.name));
|
|
extdev.afpwr.active = pVcmInfo->mVcmGpioPower.active;
|
|
|
|
if (strcmp("Internal",pFlashInfo->mFlashName) == 0) {
|
|
extdev.dev_cfg |= CAMSYS_DEVCFG_FLASHLIGHT;
|
|
extdev.fl.fl.active = pFlashInfo->mFlashTrigger.active;
|
|
if(pFlashInfo->mFlashMode == 2)
|
|
{
|
|
if (pFlashInfo->mFlashTrigger.active != pFlashInfo->mFlashEn.active) {
|
|
LOGE("%s:\n"
|
|
"WARNING: flashen active value is not equal to flashtrigger active value!\n\n\n", __PRETTY_FUNCTION__);
|
|
}
|
|
extdev.dev_cfg |= CAMSYS_DEVCFG_PREFLASHLIGHT;
|
|
}
|
|
}else{
|
|
strcpy((char*)extdev.fl.fl_drv_name,pFlashInfo->mFlashName);
|
|
strlcpy((char*)extdev.fl.fl.name, (char*)pFlashInfo->mFlashTrigger.name,sizeof(extdev.fl.fl.name));
|
|
extdev.fl.fl.active = pFlashInfo->mFlashTrigger.active;
|
|
strlcpy((char*)extdev.fl.fl_en.name, (char*)pFlashInfo->mFlashEn.name,sizeof(extdev.fl.fl_en.name));
|
|
extdev.fl.fl_en.active = pFlashInfo->mFlashEn.active;
|
|
|
|
}
|
|
|
|
if(pSensorInfo->mPhy.type == CamSys_Phy_Cif){
|
|
extdev.phy.type = CamSys_Phy_Cif;
|
|
extdev.phy.info.cif.fmt = pSensorInfo->mPhy.info.cif.fmt;
|
|
extdev.phy.info.cif.cif_num = pSensorInfo->mPhy.info.cif.cif_num;
|
|
}else if(pSensorInfo->mPhy.type == CamSys_Phy_Mipi){
|
|
extdev.phy.type = CamSys_Phy_Mipi;
|
|
extdev.phy.info.mipi.data_en_bit = pSensorInfo->mPhy.info.mipi.data_en_bit;
|
|
extdev.phy.info.mipi.phy_index = pSensorInfo->mPhy.info.mipi.phy_index;
|
|
|
|
}else{
|
|
ALOGE("%s %d: unknow phy type(%d)\n",__func__,__LINE__, pSensorInfo->mPhy.type);
|
|
}
|
|
|
|
extdev.clk.in_rate = pSensorInfo->mMclkRate;
|
|
|
|
//oyyf before register sensor driver, check the kernel camsys version
|
|
ALOGD("\n\n\n CamSys_Head.h Version Check:\n");
|
|
err = ioctl(camsys_fd, CAMSYS_VERCHK, &(pCamInfo->mCamsysVersion));
|
|
if(!err){
|
|
ALOGD(" Kernel camsys_head.h: v%d.%d.%d\n",
|
|
(pCamInfo->mCamsysVersion.head_ver&0xff0000)>>16,
|
|
(pCamInfo->mCamsysVersion.head_ver&0xff00)>>8,
|
|
(pCamInfo->mCamsysVersion.head_ver&0xff));
|
|
ALOGD(" Kernel camsys_drv : v%d.%d.%d\n",
|
|
(pCamInfo->mCamsysVersion.drv_ver&0xff0000)>>16,
|
|
(pCamInfo->mCamsysVersion.drv_ver&0xff00)>>8,
|
|
(pCamInfo->mCamsysVersion.drv_ver&0xff));
|
|
|
|
ALOGD(" CameraHal camsys_head.h : v%d.%d.%d\n",
|
|
(CAMSYS_HEAD_VERSION&0xff0000)>>16,
|
|
(CAMSYS_HEAD_VERSION&0xff00)>>8,
|
|
(CAMSYS_HEAD_VERSION&0xff));
|
|
ALOGD("\n\n\n");
|
|
|
|
//just warnning
|
|
if (CAMSYS_HEAD_VERSION != pCamInfo->mCamsysVersion.head_ver)
|
|
ALOGE("%s:\n VERSION-WARNING: camsys_head.h version isn't match in Kernel and CameraHal\n\n\n", __FUNCTION__);
|
|
|
|
|
|
}else{
|
|
ALOGE("%s(%d): get camsys head version failed! ---------\n\n\n",__FUNCTION__,__LINE__);
|
|
goto regist_err;
|
|
}
|
|
|
|
regist_ret = ioctl(camsys_fd, CAMSYS_REGISTER_DEVIO, &extdev);
|
|
if (regist_ret<0) {
|
|
ALOGE("CAMSYS_REGISTER_DEVIO failed\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto regist_err;
|
|
}
|
|
|
|
sysctl.dev_mask = pSensorInfo->mCamDevid;
|
|
sysctl.ops = CamSys_Avdd;
|
|
sysctl.on = 1;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_Avdd on failed!\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
|
|
sysctl.ops = CamSys_Dvdd;
|
|
sysctl.on = 1;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_Dvdd on failed!\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
|
|
sysctl.ops = CamSys_Dovdd;
|
|
sysctl.on = 1;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_Dovdd on failed!\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
usleep(5000);
|
|
sysctl.dev_mask = (pSensorInfo->mHostDevid|pSensorInfo->mCamDevid); //need modify
|
|
sysctl.ops = CamSys_ClkIn;
|
|
sysctl.on = 1;
|
|
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_ClkIn on failed\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
|
|
//1)power en
|
|
usleep(1000);
|
|
sysctl.dev_mask = pSensorInfo->mCamDevid;
|
|
sysctl.ops = CamSys_PwrEn;
|
|
sysctl.on = 1;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_PwrDn on failed\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
|
|
//2)reset
|
|
usleep(1000);
|
|
sysctl.dev_mask = pSensorInfo->mCamDevid;
|
|
sysctl.ops = CamSys_Rst;
|
|
sysctl.on = 0;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_PwrDn on failed\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
//3)power down control
|
|
usleep(1000);
|
|
sysctl.dev_mask = pSensorInfo->mCamDevid;
|
|
sysctl.ops = CamSys_PwrDn;
|
|
sysctl.on = 0;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_PwrDn on failed\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
usleep(2000);
|
|
|
|
i2cinfo.bus_num = pSensorInfo->mSensorI2cBusNum;
|
|
i2cinfo.slave_addr = pLoadInfo->mpI2cInfo->i2c_addr;
|
|
i2cinfo.reg_addr = pLoadInfo->mpI2cInfo->soft_reg_addr;
|
|
i2cinfo.reg_size = pLoadInfo->mpI2cInfo->reg_size;
|
|
i2cinfo.val = pLoadInfo->mpI2cInfo->soft_reg_value;
|
|
i2cinfo.val_size = pLoadInfo->mpI2cInfo->value_size;
|
|
i2cinfo.i2cbuf_directly = 0;
|
|
i2cinfo.speed = pSensorInfo->mSensorI2cRate;
|
|
err = ioctl(camsys_fd, CAMSYS_I2CWR, &i2cinfo);
|
|
if(err<0) {
|
|
if (pLoadInfo->mpI2cInfo->i2c_addr2 != 0) {
|
|
i2cinfo.slave_addr = pLoadInfo->mpI2cInfo->i2c_addr2;
|
|
err = ioctl(camsys_fd, CAMSYS_I2CWR, &i2cinfo);
|
|
if (err>=0) {
|
|
pLoadInfo->mpI2cInfo->i2c_addr = pLoadInfo->mpI2cInfo->i2c_addr2;
|
|
}
|
|
}
|
|
|
|
if (err<0) {
|
|
ALOGE("WARNING: %s soft reset by i2c failed!, please check follow information:\n",pSensorInfo->mSensorName);
|
|
ALOGE(" Slave_addr: 0x%x 0x%x\n"
|
|
" Soft reset reg: 0x%x val: 0x%x\n"
|
|
" Power/PowerDown/Reset/Mclk/I2cBus\n",
|
|
pLoadInfo->mpI2cInfo->i2c_addr,pLoadInfo->mpI2cInfo->i2c_addr2,
|
|
i2cinfo.reg_addr, i2cinfo.val);
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
}
|
|
|
|
//query iommu is enabled ?
|
|
{
|
|
int iommu_enabled = 0;
|
|
err = ioctl(camsys_fd, CAMSYS_QUREYIOMMU, &iommu_enabled);
|
|
if(err<0) {
|
|
ALOGE("CAMSYS_QUREYIOMMU failed !!!!");
|
|
}else{
|
|
pCamInfo->mIsIommuEnabled = (iommu_enabled == 1) ? true:false;
|
|
}
|
|
}
|
|
|
|
if(!ListEmpty(&(pI2cInfo->chipid_info))){
|
|
List* l = ListHead( &(pI2cInfo->chipid_info) );
|
|
while ( l )
|
|
{
|
|
sensor_chipid_info_t* pChipIDInfo = (sensor_chipid_info_t *)l;
|
|
i2cinfo.reg_addr = pChipIDInfo->chipid_reg_addr;
|
|
|
|
err = ioctl(camsys_fd, CAMSYS_I2CRD, &i2cinfo);
|
|
if (err<0) {
|
|
ALOGE("%s CAMSYS_I2CRD failed\n",pSensorInfo->mSensorName);
|
|
} else {
|
|
ALOGD("Check %s ID: reg: 0x%x val: 0x%x default: 0x%x \n",
|
|
pSensorInfo->mSensorName,
|
|
i2cinfo.reg_addr, i2cinfo.val, pChipIDInfo->chipid_reg_value);
|
|
if(i2cinfo.val!=pChipIDInfo->chipid_reg_value){
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
}
|
|
|
|
l = l->p_next;
|
|
}
|
|
}else{
|
|
|
|
ALOGE("ERROR: sensor dirver don't have chip id info\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
|
|
//check otp
|
|
{
|
|
camsys_load_sensor_info* pLoadSensorInfo = &(pCamInfo->mLoadSensorInfo);
|
|
|
|
if(pLoadInfo->pCamDrvConfig->IsiSensor.pIsiCheckOTPInfo){
|
|
ALOGD("%s:check and read otp info!!!!",__FUNCTION__);
|
|
int tmp = pLoadInfo->pCamDrvConfig->IsiSensor.pIsiCheckOTPInfo(sensor_write_i2c,sensor_read_i2c,pCamInfo,camsys_fd);
|
|
if(tmp == RET_SUCCESS){
|
|
pCamInfo->mHardInfo.mIsOTP = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// power off
|
|
power_off:
|
|
sysctl.dev_mask = pSensorInfo->mCamDevid;
|
|
sysctl.ops = CamSys_PwrDn;
|
|
sysctl.on = 1;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_PwrDn off failed\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
|
|
}
|
|
|
|
sysctl.dev_mask = pSensorInfo->mCamDevid;
|
|
sysctl.ops = CamSys_Rst;
|
|
sysctl.on = 1;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_Rst off failed\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
|
|
}
|
|
|
|
sysctl.dev_mask = pSensorInfo->mCamDevid;
|
|
sysctl.ops = CamSys_PwrEn;
|
|
sysctl.on = 0;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_PwrEn off failed\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
|
|
}
|
|
|
|
usleep(1000);
|
|
sysctl.dev_mask = (pSensorInfo->mHostDevid|pSensorInfo->mCamDevid);
|
|
sysctl.ops = CamSys_ClkIn;
|
|
sysctl.on = 0;
|
|
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_ClkIn off failed\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
|
|
}
|
|
|
|
usleep(2000);
|
|
|
|
sysctl.dev_mask = pSensorInfo->mCamDevid;
|
|
sysctl.ops = CamSys_Dovdd;
|
|
sysctl.on = 0;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_Dovdd off failed!\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
|
|
}
|
|
|
|
sysctl.ops = CamSys_Dvdd;
|
|
sysctl.on = 0;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_Dvdd on failed!\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
goto power_off;
|
|
}
|
|
|
|
sysctl.dev_mask = pSensorInfo->mCamDevid;
|
|
sysctl.ops = CamSys_Avdd;
|
|
sysctl.on = 0;
|
|
err = ioctl(camsys_fd, CAMSYS_SYSCTRL, &sysctl);
|
|
if (err<0) {
|
|
ALOGE("CamSys_Avdd off failed!\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
|
|
}
|
|
|
|
|
|
unmap_pos:
|
|
|
|
regist_err:
|
|
if(regist_ret==0 && ret<0){
|
|
// unregister device need modify
|
|
err = ioctl(camsys_fd, CAMSYS_DEREGISTER_DEVIO, &sysctl);
|
|
if(err<0){
|
|
ALOGE("CAMSYS_DEREGISTER_DEVIO failed!\n");
|
|
ret = RK_RET_DEVICEERR;
|
|
}
|
|
}
|
|
|
|
if(camsys_fd){
|
|
close(camsys_fd);
|
|
camsys_fd = 0;
|
|
}
|
|
|
|
end:
|
|
return ret;
|
|
}
|
|
|
|
int camera_board_profiles::CheckSensorSupportDV(rk_cam_total_info* pCamInfo)
|
|
{
|
|
size_t nDvVector = pCamInfo->mSoftInfo.mDV_vector.size();
|
|
uint32_t lanes;
|
|
|
|
if (pCamInfo->mHardInfo.mSensorInfo.mPhy.type == CamSys_Phy_Mipi) {
|
|
lanes = pCamInfo->mHardInfo.mSensorInfo.laneNum;
|
|
if (lanes == 4)
|
|
lanes = 2;
|
|
else if (lanes == 2)
|
|
lanes = 1;
|
|
else
|
|
lanes = 0;
|
|
} else {
|
|
lanes = 0;
|
|
}
|
|
if((int)nDvVector>=1){
|
|
for(int i=0; i<(int)nDvVector; i++){
|
|
rk_DV_info *pDVInfo = pCamInfo->mSoftInfo.mDV_vector[i];
|
|
char *p = pCamInfo->mHardInfo.mSensorInfo.mSensorName;
|
|
if(strcmp(pCamInfo->mHardInfo.mSensorInfo.mSensorName, UVC_CAM_NAME)==0){
|
|
|
|
if(pDVInfo->mIsSupport)
|
|
pDVInfo->mAddMask = 0;
|
|
else
|
|
pDVInfo->mAddMask = 1;
|
|
ALOGD("(%s) UVC camera resolution(%dx%d) is support \n", pCamInfo->mHardInfo.mSensorInfo.mSensorName, pDVInfo->mWidth, pDVInfo->mHeight);
|
|
}
|
|
else if(strcmp(pCamInfo->mHardInfo.mSensorInfo.mSensorName, SOC_CAM_NAME)==0){
|
|
if(pDVInfo->mIsSupport)
|
|
pDVInfo->mAddMask = 0;
|
|
else{
|
|
pDVInfo->mAddMask = 1;
|
|
ALOGD("(%s) SOC camera resolution(%dx%d) is support \n", pCamInfo->mHardInfo.mSensorInfo.mSensorName, pDVInfo->mWidth, pDVInfo->mHeight);
|
|
}
|
|
}
|
|
else{
|
|
pDVInfo->mAddMask = 1;
|
|
if(pDVInfo->mIsSupport) {
|
|
List *l,*head;
|
|
sensor_caps_t *pCaps;
|
|
|
|
head = &pCamInfo->mLoadSensorInfo.mpI2cInfo->lane_res[lanes];
|
|
if (!ListEmpty(head)) {
|
|
l = ListHead( head );
|
|
while ( l )
|
|
{
|
|
pCaps = (sensor_caps_t*)l;
|
|
if (ISI_RES_W_GET(pCaps->caps.Resolution)*ISI_RES_H_GET(pCaps->caps.Resolution)*10 >=
|
|
pDVInfo->mHeight*pDVInfo->mWidth*9) {
|
|
if ((unsigned int)(ISI_FPS_GET(pCaps->caps.Resolution)) >= pDVInfo->mFps) {
|
|
pDVInfo->mFps = ISI_FPS_GET(pCaps->caps.Resolution);
|
|
pDVInfo->mAddMask = 0;
|
|
}
|
|
}
|
|
l = l->p_next;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}else{
|
|
ALOGD("WARNING: sensor(%s) don't support any DV resolution\n", pCamInfo->mHardInfo.mSensorInfo.mSensorName);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int camera_board_profiles::WriteDevNameTOXML(camera_board_profiles* profiles, char *SrcFile, char* DstFile)
|
|
{
|
|
FILE *fpsrc, *fpdst;
|
|
char one_line_buf[256];
|
|
char *leave_line0, *leave_line1, *leave_line2;
|
|
int isWrite=0;
|
|
int i;
|
|
|
|
size_t nCamNum = profiles->mDevideConnectVector.size();
|
|
|
|
fpsrc = fopen(SrcFile,"r");
|
|
if(fpsrc == NULL)
|
|
{
|
|
ALOGE("%s OPEN SrcMediaProfiles '%s' FALID, mode(read only), error(%s)\n", __FUNCTION__, SrcFile, strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
fpdst = fopen(DstFile,"w");
|
|
if(fpdst == NULL)
|
|
{
|
|
ALOGE("%s OPEN DstMediaProfiles %s TEMP FALID, mode(w), error(%s)\n",__FUNCTION__, DstFile, strerror(errno));
|
|
return -2;
|
|
}
|
|
|
|
fseek(fpsrc,0,SEEK_SET);
|
|
fseek(fpdst,0,SEEK_SET);
|
|
while(fgets(one_line_buf,256,fpsrc) != NULL)
|
|
{
|
|
|
|
fputs(one_line_buf, fpdst);
|
|
|
|
if(isWrite==0){
|
|
leave_line0 = NULL;
|
|
leave_line0 = strstr(one_line_buf, "<?");
|
|
if(leave_line0==NULL){
|
|
continue;
|
|
}
|
|
|
|
leave_line0 = NULL;
|
|
leave_line0 = strstr(one_line_buf, "?>");
|
|
if(leave_line0==NULL){
|
|
continue;
|
|
}
|
|
|
|
for(i=0; (i<(int)nCamNum && i<CAM_MAX_SUPPORT); i++){
|
|
fprintf(fpdst, "<!-- videoname%d=\"%s\" index=%d facing=%d --> \n",
|
|
i, profiles->mDevideConnectVector[i]->mHardInfo.mSensorInfo.mSensorName,
|
|
profiles->mDevideConnectVector[i]->mDeviceIndex, profiles->mDevideConnectVector[i]->mHardInfo.mSensorInfo.mFacing);
|
|
}
|
|
isWrite=1;
|
|
}
|
|
|
|
if(fgetc(fpsrc)==EOF)
|
|
{
|
|
break;
|
|
}
|
|
fseek(fpsrc,-1,SEEK_CUR);
|
|
}
|
|
|
|
memset(one_line_buf,0,sizeof(one_line_buf));
|
|
fclose(fpsrc);
|
|
fclose(fpdst);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int camera_board_profiles::ReadDevNameFromXML(FILE* fp, xml_DEV_name_s* video_name)
|
|
{
|
|
char one_line_buf[256];
|
|
char *leave_line0, *leave_line1, *leave_line2;
|
|
int leave_num;
|
|
const char* equal_sign = "=";
|
|
const char* mark_sign_start = "<!--";
|
|
const char* mark_sign_end = "-->";
|
|
const char* videoname_sign = "videoname";
|
|
xml_DEV_name_s* pst_video_name = video_name;
|
|
int count = 0;
|
|
|
|
fseek(fp,0,SEEK_SET);
|
|
|
|
while(fgets(one_line_buf,256,fp) != NULL)
|
|
{
|
|
if(strlen(one_line_buf) < 3) //line is NULL
|
|
{
|
|
continue;
|
|
}
|
|
leave_line0 = NULL;
|
|
leave_line0 = strstr(one_line_buf, mark_sign_start);
|
|
if(leave_line0==NULL)
|
|
{
|
|
continue;
|
|
}
|
|
leave_line1 = NULL;
|
|
leave_line1 = strstr(one_line_buf, mark_sign_end);
|
|
if(leave_line1==NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
leave_line0 = NULL;
|
|
leave_line0 = strstr(one_line_buf, videoname_sign);
|
|
if(leave_line0==NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
leave_line1 = NULL;
|
|
leave_line1 = strstr(leave_line0, equal_sign);
|
|
if(leave_line1==NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ALOGD("%s\n", leave_line0);
|
|
sscanf(leave_line0, "videoname%d=\"%[^\"]\" index=%d facing=%d",
|
|
&(pst_video_name->camid), pst_video_name->camera_name,
|
|
&(pst_video_name->index), &(pst_video_name->facing));
|
|
count++;
|
|
pst_video_name++;
|
|
|
|
if(count==CAM_MAX_SUPPORT) {
|
|
break;
|
|
}
|
|
|
|
if(fgetc(fp)==EOF)
|
|
{
|
|
break;
|
|
}
|
|
fseek(fp,-1,SEEK_CUR);
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
int camera_board_profiles::XMLFseekCamIDPos(FILE* fp, xml_fp_pos_s* fp_pos)
|
|
{
|
|
char one_line_buf[256];
|
|
int find_fmt_sign=0;
|
|
char *leave_line, *leave_line1, *leave_line2;
|
|
char str_camId[4];
|
|
const char *equal_sign = "=";
|
|
int count=0;
|
|
|
|
if(fp==NULL)
|
|
return -1;
|
|
|
|
if(fp_pos==NULL)
|
|
return -2;
|
|
|
|
memset(str_camId, 0x00, sizeof(str_camId));
|
|
sprintf(str_camId, "%d", fp_pos->camid);
|
|
fseek(fp,0,SEEK_SET);
|
|
while(fgets(one_line_buf,256,fp) != NULL)
|
|
{
|
|
if(strlen(one_line_buf) < 3) //line is NULL
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(find_fmt_sign==0)
|
|
{
|
|
leave_line = NULL;
|
|
leave_line = strstr(one_line_buf, "<CamcorderProfiles");
|
|
if(leave_line == NULL) //no "<CamcorderProfiles"
|
|
{
|
|
continue;
|
|
}
|
|
|
|
leave_line1 = NULL;
|
|
leave_line1 = strstr(leave_line,equal_sign);
|
|
if(leave_line1 == NULL) //no "="
|
|
{
|
|
continue;
|
|
}
|
|
|
|
leave_line2 = NULL;
|
|
leave_line2 = strstr(leave_line1,str_camId);
|
|
if(leave_line2 == NULL) //no "0/1"
|
|
{
|
|
continue;
|
|
}else{
|
|
fp_pos->camid_start = ftell(fp);
|
|
find_fmt_sign=1;
|
|
continue;
|
|
}
|
|
}else{
|
|
leave_line = NULL;
|
|
leave_line = strstr(one_line_buf, "</CamcorderProfiles>");
|
|
if(leave_line == NULL) //no
|
|
{
|
|
continue;
|
|
}else{
|
|
fp_pos->camid_end = ftell(fp);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(fgetc(fp)==EOF)
|
|
{
|
|
break;
|
|
}
|
|
fseek(fp,-1,SEEK_CUR);
|
|
memset(one_line_buf,0,sizeof(one_line_buf));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int camera_board_profiles::FindResolution(camera_board_profiles* profiles, xml_video_element_s* find_element)
|
|
{
|
|
int ret = -1;
|
|
unsigned int j;
|
|
size_t nCamNum = profiles->mDevideConnectVector.size();
|
|
size_t nDVNum = 0;
|
|
|
|
ALOGD("find element camid(%d) quality(%s) width(%d)\n",find_element->n_cameraId, find_element->str_quality, find_element->n_width);
|
|
if(find_element->n_cameraId < (int)nCamNum){
|
|
nDVNum = profiles->mDevideConnectVector[find_element->n_cameraId]->mSoftInfo.mDV_vector.size();
|
|
for(j=0; j<nDVNum; j++){
|
|
rk_DV_info* DVInfo = profiles->mDevideConnectVector[find_element->n_cameraId]->mSoftInfo.mDV_vector[j];
|
|
if(DVInfo->mWidth==find_element->n_width)
|
|
{
|
|
find_element->n_height = DVInfo->mHeight;
|
|
find_element->n_frameRate = DVInfo->mFps;
|
|
find_element->isAddMark = DVInfo->mAddMask;
|
|
break;
|
|
}
|
|
}
|
|
}else{
|
|
return -1;
|
|
}
|
|
|
|
if( j==nDVNum)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int camera_board_profiles::ModifyMediaProfileXML( camera_board_profiles* profiles, char* src_xml_file, char* dst_xml_file)
|
|
{
|
|
int ret=0, err=0;
|
|
int alter_sign = 0;
|
|
int find_fmt_sign=0;
|
|
int leave_num=0;
|
|
long now_fp_pos;
|
|
const char *equal_sign = "=";
|
|
FILE *src_fp=NULL, *dst_fp=NULL;
|
|
char one_line_buf[256];
|
|
char frontpart_line[50];
|
|
long front_fptmp = 0,back_fptmp = 0;
|
|
char *leave_line, *leave_line1, *leave_line2;
|
|
int i = 0;
|
|
int camid_found = 0;
|
|
|
|
xml_fp_pos_s fp_pos[CAM_MAX_SUPPORT];
|
|
xml_video_element_s find_element;
|
|
|
|
src_fp = fopen(src_xml_file, "r");
|
|
if(src_fp==NULL){
|
|
err = -1;
|
|
ALOGE("open file '%s' failed!!! (r)\n", src_xml_file);
|
|
goto alter_exit;
|
|
}
|
|
|
|
dst_fp = fopen(dst_xml_file, "w");
|
|
if(dst_fp==NULL){
|
|
err = -2;
|
|
ALOGE("open file '%s' failed!!! (r)\n", dst_xml_file);
|
|
goto alter_exit;
|
|
}
|
|
|
|
for(i=0; i<CAM_MAX_SUPPORT; i++) {
|
|
fp_pos[i].camid = 1;
|
|
fp_pos[i].camid_start = 0;
|
|
fp_pos[i].camid_end = 0;
|
|
ret = XMLFseekCamIDPos(src_fp, &fp_pos[i]);
|
|
if(ret < 0 || fp_pos[i].camid_end <= fp_pos[i].camid_start){
|
|
ALOGE("find camid(%d) failed\n", fp_pos[i].camid);
|
|
err = -3;
|
|
goto alter_exit;
|
|
}
|
|
if(fp_pos[i].camid_end > 0 && fp_pos[i].camid_end > 0)
|
|
camid_found = 1;
|
|
else
|
|
camid_found = 0;
|
|
}
|
|
|
|
find_element.isAddMark = 1;
|
|
find_element.n_cameraId = -1;
|
|
find_element.n_frameRate = 0;
|
|
find_element.n_width = 0;
|
|
find_element.n_height = 0;
|
|
if(camid_found) {
|
|
fseek(src_fp,0,SEEK_SET);
|
|
fseek(dst_fp,0,SEEK_SET);
|
|
|
|
while(fgets(one_line_buf,256,src_fp) != NULL)
|
|
{
|
|
if(strlen(one_line_buf) < 3) //line is NULL
|
|
{
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
|
|
if(find_fmt_sign==0)
|
|
{
|
|
leave_line = NULL;
|
|
leave_line = strstr(one_line_buf,equal_sign);
|
|
if(leave_line == NULL) //no "="
|
|
{
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
leave_line1 = NULL;
|
|
leave_line1 = strstr(one_line_buf, "<EncoderProfile");
|
|
if(leave_line1 == NULL)
|
|
{
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
|
|
leave_line2 = NULL;
|
|
leave_line2 = strstr(leave_line1, "timelapse");
|
|
if(leave_line2 == NULL)
|
|
{
|
|
memset(find_element.str_quality, 0x00, sizeof(find_element.str_quality));
|
|
sscanf(leave_line, "%*[^\"]\"%[^\"]", find_element.str_quality);
|
|
}else{
|
|
memset(find_element.str_quality, 0x00, sizeof(find_element.str_quality));
|
|
sscanf(leave_line, "%*[^\"]\"timelapse%[^\"]", find_element.str_quality);
|
|
}
|
|
|
|
//ALOGD("quality %s\n", find_element.str_quality);
|
|
find_fmt_sign = 1;
|
|
front_fptmp = ftell(dst_fp);
|
|
fprintf(dst_fp, " \n");
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
else if(find_fmt_sign==1)
|
|
{
|
|
leave_line = NULL;
|
|
leave_line = strstr(one_line_buf,equal_sign);
|
|
if(leave_line == NULL) //no "="
|
|
{
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
|
|
leave_line1 = NULL;
|
|
leave_line1 = strstr(one_line_buf,"width");
|
|
if(leave_line1 == NULL) //no "width"
|
|
{
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
sscanf(leave_line, "%*[^1-9]%d\"", &(find_element.n_width));
|
|
//ALOGD("%d\n", find_element.n_width);
|
|
find_fmt_sign=2;
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
else if(find_fmt_sign==2)
|
|
{
|
|
leave_line = NULL;
|
|
leave_line = strstr(one_line_buf,equal_sign);
|
|
if(leave_line == NULL) //no "="
|
|
{
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
leave_line1 = NULL;
|
|
leave_line1 = strstr(one_line_buf, "frameRate");
|
|
if(leave_line1 == NULL) //no "framRate"
|
|
{
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
|
|
now_fp_pos = ftell(src_fp);
|
|
find_element.n_cameraId = -1;
|
|
for (i=0; i<CAM_MAX_SUPPORT; i++) {
|
|
if(now_fp_pos>fp_pos[i].camid_start && now_fp_pos<fp_pos[i].camid_end) {
|
|
find_element.n_cameraId = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(find_element.n_cameraId != -1){
|
|
ret = FindResolution(profiles, &find_element);
|
|
if(ret==0){
|
|
leave_num = leave_line - one_line_buf;
|
|
memset(frontpart_line,0,sizeof(frontpart_line));
|
|
strncpy(frontpart_line,one_line_buf,leave_num);
|
|
fputs(frontpart_line,dst_fp);
|
|
|
|
//ALOGD("new frameRate %d isaddmark(%d)\n", find_element.n_frameRate, find_element.isAddMark);
|
|
fprintf(dst_fp,"=\"%d\" /> \n", (find_element.n_frameRate));
|
|
alter_sign++;
|
|
find_fmt_sign = 3;
|
|
ALOGD("XML modify: camID(%d) resolution:%s(%dx%d) fps(%d) isaddmark(%d)\n",find_element.n_cameraId,find_element.str_quality,
|
|
find_element.n_width, find_element.n_height, find_element.n_frameRate, find_element.isAddMark);
|
|
}else{
|
|
ALOGD("WARNING: can't find camID(%d) resolution:%s(%dx), addmark!!!\n", find_element.n_cameraId,find_element.str_quality, find_element.n_width);
|
|
find_element.isAddMark=1;
|
|
find_fmt_sign = 3;
|
|
fputs(one_line_buf, dst_fp);
|
|
//continue;
|
|
}
|
|
}else{
|
|
find_fmt_sign = 3;
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
}else if(find_fmt_sign==3){
|
|
leave_line = NULL;
|
|
leave_line = strstr(one_line_buf,"</EncoderProfile>");
|
|
if(leave_line == NULL) //no "framRate"
|
|
{
|
|
fputs(one_line_buf, dst_fp);
|
|
continue;
|
|
}
|
|
fputs(one_line_buf, dst_fp);
|
|
if(find_element.isAddMark){
|
|
back_fptmp = ftell(dst_fp);
|
|
fseek(dst_fp,front_fptmp,SEEK_SET);
|
|
fprintf(dst_fp, "<!-- \n");
|
|
fseek(dst_fp,back_fptmp,SEEK_SET);
|
|
fprintf(dst_fp, "--> \n");
|
|
find_element.isAddMark=0;
|
|
}
|
|
find_fmt_sign=0;
|
|
}
|
|
|
|
if(fgetc(src_fp)==EOF)
|
|
{
|
|
break;
|
|
}
|
|
fseek(src_fp,-1,SEEK_CUR);
|
|
memset(one_line_buf,0,sizeof(one_line_buf));
|
|
}
|
|
}
|
|
|
|
alter_exit:
|
|
if(src_fp)
|
|
fclose(src_fp);
|
|
|
|
if(dst_fp)
|
|
fclose(dst_fp);
|
|
|
|
if(err==0){
|
|
//remove(src_xml_file);
|
|
//chmod(src_xml_file, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
|
|
remove(src_xml_file);
|
|
chmod(dst_xml_file, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
|
|
int camera_board_profiles::ProduceNewXml(camera_board_profiles* profiles)
|
|
{
|
|
char temp_dst_file[50];
|
|
char dst_file[50];
|
|
char default_file[50];
|
|
int err=0;
|
|
int res=0;
|
|
|
|
//CheckSensorSupportDV
|
|
AddConnectSensorToVector(profiles);
|
|
size_t nCamNum =profiles->mDevideConnectVector.size();
|
|
|
|
//verrify media_xml_device is supported by board xml
|
|
for(int i=0; (i<profiles->xml_device_count && i<CAM_MAX_SUPPORT); i++)
|
|
{
|
|
res |= ConnectDevHaveDev(profiles, (profiles->mXmlDevInfo + i));
|
|
}
|
|
|
|
if(res == RK_RET_SUCCESS && profiles->xml_device_count==(int)nCamNum){
|
|
return RK_RET_SUCCESS;
|
|
}
|
|
|
|
int fileexit = access(RK_DST_MEDIA_PROFILES_XML_PATH, 0);
|
|
ALOGD("judge the media profile xml fileexit = %d\n", fileexit);
|
|
if((int)nCamNum>=1){
|
|
//if((int)nCamNum>=1 && fileexit == -1){
|
|
LOG1("enter produce new xml\n");
|
|
//new xml file name
|
|
strlcpy(default_file, RK_DEFAULT_MEDIA_PROFILES_XML_PATH, sizeof(default_file));
|
|
strlcpy(dst_file, RK_DST_MEDIA_PROFILES_XML_PATH, sizeof(dst_file));
|
|
strlcpy(temp_dst_file, RK_TMP_MEDIA_PROFILES_XML_PATH, sizeof(temp_dst_file));
|
|
|
|
for(int i=0; i<(int)nCamNum; i++){
|
|
CheckSensorSupportDV(profiles->mDevideConnectVector[i]);
|
|
}
|
|
|
|
//write name to xml
|
|
err = WriteDevNameTOXML(profiles, default_file, temp_dst_file);
|
|
if(err){
|
|
|
|
ALOGE("write dev name to xml failed\n");
|
|
goto end;
|
|
}
|
|
|
|
//modify xml
|
|
err = ModifyMediaProfileXML( profiles, temp_dst_file, dst_file);
|
|
if(err){
|
|
|
|
ALOGE("modify xml failed\n");
|
|
goto end;
|
|
}
|
|
|
|
LOG1("exit produce new xml\n");
|
|
}
|
|
|
|
end:
|
|
return err;
|
|
|
|
}
|
|
|
|
int camera_board_profiles::LoadSensor(camera_board_profiles* profiles)
|
|
{
|
|
char dst_file[50];
|
|
int err = RK_RET_SUCCESS;
|
|
int count = 0;
|
|
int result= 0;
|
|
|
|
LOG_FUNCTION_NAME
|
|
|
|
strlcpy(dst_file, RK_DST_MEDIA_PROFILES_XML_PATH, sizeof(dst_file));
|
|
ALOGD("read cam name from xml(%s)\n",dst_file );
|
|
|
|
FILE* fp = fopen(dst_file, "r");
|
|
if(!fp){
|
|
ALOGE(" is not exist, register all\n");
|
|
goto err_end;
|
|
}
|
|
|
|
//read sensor name
|
|
count = ReadDevNameFromXML(fp, profiles->mXmlDevInfo);
|
|
profiles->xml_device_count = count;
|
|
//if(count<1){
|
|
if(count<CAM_MAX_SUPPORT){
|
|
ALOGD("media_profiles.xml not have any camera device\n");
|
|
goto err_end;
|
|
}
|
|
|
|
ALOGD("find camera count(%d) cam1(%s) cam2(%s)\n", count, profiles->mXmlDevInfo[0].camera_name, profiles->mXmlDevInfo[1].camera_name);
|
|
//verrify media_xml_device is supported by board xml
|
|
for(int i=0; (i<count && i<CAM_MAX_SUPPORT); i++)
|
|
{
|
|
if(strcmp(profiles->mXmlDevInfo[i].camera_name, UVC_CAM_NAME)!= 0){
|
|
err |= BoardFileHaveDev(profiles, (profiles->mXmlDevInfo+i));
|
|
}
|
|
}
|
|
|
|
if(err != RK_RET_SUCCESS){
|
|
goto err_end;
|
|
}
|
|
|
|
//register exist sensor
|
|
for(int i=0; (i<count && i<CAM_MAX_SUPPORT); i++){
|
|
if(strcmp(profiles->mXmlDevInfo[i].camera_name, UVC_CAM_NAME)== 0){
|
|
continue;
|
|
}
|
|
|
|
result = OpenAndRegistOneSensor(profiles->mDevieVector[profiles->mXmlDevInfo[i].index]);
|
|
if(result != 0){
|
|
goto err_end;
|
|
}
|
|
|
|
}
|
|
|
|
if(profiles->mDevieVector.size()>0){
|
|
|
|
return RK_RET_SUCCESS;
|
|
}else
|
|
return RK_RET_NOSETUP;
|
|
|
|
err_end:
|
|
OpenAndRegistALLSensor(profiles);
|
|
LOG_FUNCTION_NAME_EXIT
|
|
return err;
|
|
|
|
}
|
|
|
|
int camera_board_profiles::BoardFileHaveDev(camera_board_profiles* profiles, xml_DEV_name_s* media_xml_device )
|
|
{
|
|
size_t nCamNum = profiles->mDevieVector.size();
|
|
|
|
if(media_xml_device->index < (int)nCamNum)
|
|
{
|
|
rk_sensor_info *pSensorInfo = &(profiles->mDevieVector[media_xml_device->index]->mHardInfo.mSensorInfo);
|
|
if(!strcmp(media_xml_device->camera_name, pSensorInfo->mSensorName)
|
|
&& (media_xml_device->facing == pSensorInfo->mFacing))
|
|
{
|
|
return RK_RET_SUCCESS;
|
|
}
|
|
}
|
|
return RK_RET_NOSETUP;
|
|
}
|
|
|
|
void camera_board_profiles::AddConnectSensorToVector(camera_board_profiles* profiles)
|
|
{
|
|
size_t nCamNum = profiles->mDevieVector.size();
|
|
|
|
for(int i=0; i<(int)nCamNum; i++)
|
|
{
|
|
if(profiles->mDevieVector[i]->mIsConnect == 1)
|
|
{
|
|
profiles->mDevideConnectVector.add(profiles->mDevieVector[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
int camera_board_profiles::ConnectDevHaveDev(camera_board_profiles* profiles, xml_DEV_name_s* media_xml_device )
|
|
{
|
|
size_t nCamNum = profiles->mDevideConnectVector.size();
|
|
|
|
for(int i=0; i<(int)nCamNum; i++)
|
|
{
|
|
rk_sensor_info *pSensorInfo = &(profiles->mDevideConnectVector[i]->mHardInfo.mSensorInfo);
|
|
if(!strcmp(media_xml_device->camera_name, pSensorInfo->mSensorName)
|
|
&& (media_xml_device->facing == pSensorInfo->mFacing))
|
|
{
|
|
return RK_RET_SUCCESS;
|
|
}
|
|
}
|
|
return RK_RET_NOSETUP;
|
|
}
|
|
|
|
|
|
|