CAPTURE_DEVICE_ERR_RET V4l2CapDeviceBase :: DevSetConfig(struct capture_config_t *pCapcfg){
CAMERA_HAL_LOG_FUNC;
if (mCameraDevice <= 0 || pCapcfg == NULL){
return CAPTURE_DEVICE_ERR_BAD_PARAM;
}
CAPTURE_DEVICE_ERR_RET ret = CAPTURE_DEVICE_ERR_NONE;
if(mCapCfg.fmt != pCapcfg->fmt || mCapCfg.width != pCapcfg->width || mCapCfg.height != pCapcfg->height
|| mCapCfg.tv.denominator/mCapCfg.tv.numerator != pCapcfg->tv.denominator/pCapcfg->tv.numerator) {
mCapCfg.fmt = pCapcfg->fmt;
mCapCfg.width = pCapcfg->width;
mCapCfg.height = pCapcfg->height;
mCapCfg.tv.denominator = pCapcfg->tv.denominator;
mCapCfg.tv.numerator = pCapcfg->tv.numerator;
CAMERA_HAL_LOG_RUNTIME("V4l2SetConfig=width=%d,height=%d", mCapCfg.width, mCapCfg.height);
ret = V4l2SetConfig(pCapcfg);
if(ret < 0) {
return ret;
}
mCapCfg.rotate = SENSOR_PREVIEW_ROATE_INVALID;
}
if(mCapCfg.rotate != pCapcfg->rotate) {
mCapCfg.rotate = pCapcfg->rotate;
CAMERA_HAL_LOG_RUNTIME("V4l2SetRot=rotate=%d", mCapCfg.rotate);
if(V4l2SetRot(pCapcfg) < 0)
return CAPTURE_DEVICE_ERR_SYS_CALL;
}
return ret;
}
CAPTURE_DEVICE_ERR_RET V4l2CapDeviceBase :: V4l2Open(int cameraId){
CAMERA_HAL_LOG_FUNC;
int fd = 0, i, j, is_found = 0;
const char *flags[] = {"uncompressed", "compressed"};
char dev_node[CAMAERA_FILENAME_LENGTH];
DIR *v4l_dir = NULL;
struct dirent *dir_entry;
struct v4l2_capability v4l2_cap;
struct v4l2_fmtdesc vid_fmtdesc;
struct v4l2_frmsizeenum vid_frmsize;
CAPTURE_DEVICE_ERR_RET ret = CAPTURE_DEVICE_ERR_NONE;
if(mCameraDevice > 0)
return CAPTURE_DEVICE_ERR_ALRADY_OPENED;
else if (mCaptureDeviceName[0] != '#'){
CAMERA_HAL_LOG_RUNTIME("already get the device name %s", mCaptureDeviceName);
mCameraDevice = open(mCaptureDeviceName, O_RDWR, O_NONBLOCK);
if (mCameraDevice < 0)
return CAPTURE_DEVICE_ERR_OPEN;
}
else{
CAMERA_HAL_LOG_RUNTIME("deviceName is %s", mInitalDeviceName);
v4l_dir = opendir("/sys/class/video4linux");
if (v4l_dir){
while((dir_entry = readdir(v4l_dir))) {
memset((void *)dev_node, 0, CAMAERA_FILENAME_LENGTH);
if(strncmp(dir_entry->d_name, "video", 5))
continue;
sprintf(dev_node, "/dev/%s", dir_entry->d_name);
if ((fd = open(dev_node, O_RDWR, O_NONBLOCK)) < 0)
continue;
CAMERA_HAL_LOG_RUNTIME("dev_node is %s", dev_node);
if(ioctl(fd, VIDIOC_QUERYCAP, &v4l2_cap) < 0 ) {
close(fd);
fd = 0;
continue;
} else if ((strstr((char *)v4l2_cap.driver, mInitalDeviceName) != 0) &&
(v4l2_cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
is_found = 1;
strcpy(mCaptureDeviceName, dev_node);
CAMERA_HAL_LOG_RUNTIME("device name is %s", mCaptureDeviceName);
break;
} else {
close(fd);
fd = 0;
}
}
}
if (fd > 0){
mCameraDevice = fd;
}
else{
CAMERA_HAL_ERR("The device name is not correct or the device is error");
return CAPTURE_DEVICE_ERR_OPEN;
}
}
return ret;
}
CAPTURE_DEVICE_ERR_RET V4l2CsiDevice :: V4l2Open() {
CAMERA_HAL_LOG_FUNC;
int fd = 0, i, j, is_found = 0;
const char *flags[] = {"uncompressed", "compressed"};
char dev_node[CAMAERA_FILENAME_LENGTH];
DIR *v4l_dir = NULL;
struct dirent *dir_entry;
struct v4l2_dbg_chip_ident vid_chip;
struct v4l2_fmtdesc vid_fmtdesc;
struct v4l2_frmsizeenum vid_frmsize;
CAPTURE_DEVICE_ERR_RET ret = CAPTURE_DEVICE_ERR_NONE;
if(mCameraDevice > 0)
return CAPTURE_DEVICE_ERR_ALRADY_OPENED;
else if (mCaptureDeviceName[0] != '#') {
CAMERA_HAL_LOG_RUNTIME("already get the device name %s", mCaptureDeviceName);
mCameraDevice = open(mCaptureDeviceName, O_RDWR, O_NONBLOCK);
if (mCameraDevice < 0)
return CAPTURE_DEVICE_ERR_OPEN;
}
else {
CAMERA_HAL_LOG_RUNTIME("deviceName is %s", mInitalDeviceName);
v4l_dir = opendir("/sys/class/video4linux");
if (v4l_dir) {
while((dir_entry = readdir(v4l_dir))) {
memset((void *)dev_node, 0, CAMAERA_FILENAME_LENGTH);
if(strncmp(dir_entry->d_name, "video", 5))
continue;
sprintf(dev_node, "/dev/%s", dir_entry->d_name);
if ((fd = open(dev_node, O_RDWR, O_NONBLOCK)) < 0)
continue;
CAMERA_HAL_LOG_RUNTIME("dev_node is %s", dev_node);
if(ioctl(fd, VIDIOC_DBG_G_CHIP_IDENT, &vid_chip) < 0 ) {
close(fd);
continue;
} else if (strstr(vid_chip.match.name, mInitalDeviceName) != 0) {
is_found = 1;
strcpy(mCaptureDeviceName, dev_node);
strcpy(mInitalDeviceName, vid_chip.match.name);
CAMERA_HAL_LOG_INFO("device name is %s", mCaptureDeviceName);
CAMERA_HAL_LOG_INFO("sensor name is %s", mInitalDeviceName);
break;
} else {
close(fd);
fd = 0;
}
}
}
if (fd > 0)
mCameraDevice = fd;
else {
CAMERA_HAL_ERR("The device name is not correct or the device is error");
return CAPTURE_DEVICE_ERR_OPEN;
}
}
return ret;
}
CAPTURE_DEVICE_ERR_RET V4l2CapDeviceBase :: V4l2EnumParam(DevParamType devParamType, void *retParam) {
CAPTURE_DEVICE_ERR_RET ret = CAPTURE_DEVICE_ERR_NONE;
CAMERA_HAL_LOG_FUNC;
CAMERA_HAL_LOG_RUNTIME("devParamType is %d", devParamType);
if(mCameraDevice <= 0)
return CAPTURE_DEVICE_ERR_OPEN;
switch(devParamType) {
case OUTPU_FMT:
ret = V4l2EnumFmt(retParam);
break;
case FRAME_SIZE_FPS:
{
ret = V4l2EnumSizeFps(retParam);
break;
}
default:
{
ret = CAPTURE_DEVICE_ERR_SET_PARAM;
break;
}
}
return ret;
}
CAPTURE_DEVICE_ERR_RET V4l2CsiDevice :: V4l2EnumSizeFps(void *retParam) {
CAMERA_HAL_LOG_FUNC;
CAPTURE_DEVICE_ERR_RET ret = CAPTURE_DEVICE_ERR_NONE;
struct v4l2_frmsizeenum vid_frmsize;
struct capture_config_t *pCapCfg =(struct capture_config_t *) retParam;
memset(&vid_frmsize, 0, sizeof(struct v4l2_frmsizeenum));
vid_frmsize.index = mSizeFPSParamIdx;
CAMERA_HAL_LOG_RUNTIME("the query for size fps fmt is %x",pCapCfg->fmt);
vid_frmsize.pixel_format = pCapCfg->fmt;
if (ioctl(mCameraDevice, VIDIOC_ENUM_FRAMESIZES, &vid_frmsize) != 0) {
mSizeFPSParamIdx = 0;
ret = CAPTURE_DEVICE_ERR_SET_PARAM;
} else {
//hardcode here for ov3640
if (strstr(mInitalDeviceName, "3640") != NULL) {
CAMERA_HAL_LOG_INFO("the sensor is mInitalDeviceName");
if (vid_frmsize.discrete.width == 1024 && vid_frmsize.discrete.height == 768) {
mSizeFPSParamIdx ++;
vid_frmsize.index = mSizeFPSParamIdx;
if (ioctl(mCameraDevice, VIDIOC_ENUM_FRAMESIZES, &vid_frmsize) != 0) {
mSizeFPSParamIdx = 0;
ret = CAPTURE_DEVICE_ERR_SET_PARAM;
}
}
}
CAMERA_HAL_LOG_RUNTIME("in %s the w %d, h %d", __FUNCTION__,vid_frmsize.discrete.width, vid_frmsize.discrete.height);
pCapCfg->width = vid_frmsize.discrete.width;
pCapCfg->height = vid_frmsize.discrete.height;
if(vid_frmsize.discrete.width > 1280 || vid_frmsize.discrete.height >720) {
pCapCfg->tv.numerator = 1;
pCapCfg->tv.denominator = 15;
} else {
pCapCfg->tv.numerator = 1;
pCapCfg->tv.denominator = 30;
}
mSizeFPSParamIdx ++;
ret = CAPTURE_DEVICE_ERR_ENUM_CONTINUE;
}
return ret;
}
CAPTURE_DEVICE_ERR_RET V4l2CapDeviceBase :: V4l2EnumSizeFps(void *retParam) {
CAMERA_HAL_LOG_FUNC;
CAPTURE_DEVICE_ERR_RET ret = CAPTURE_DEVICE_ERR_NONE;
struct v4l2_frmsizeenum vid_frmsize;
struct v4l2_frmivalenum vid_frmval;
struct capture_config_t *pCapCfg =(struct capture_config_t *) retParam;
memset(&vid_frmsize, 0, sizeof(struct v4l2_frmsizeenum));
vid_frmsize.index = mSizeFPSParamIdx;
CAMERA_HAL_LOG_RUNTIME("the query for size fps fmt is %x",pCapCfg->fmt);
vid_frmsize.pixel_format = pCapCfg->fmt;
if (ioctl(mCameraDevice, VIDIOC_ENUM_FRAMESIZES, &vid_frmsize) != 0) {
mSizeFPSParamIdx = 0;
ret = CAPTURE_DEVICE_ERR_SET_PARAM;
} else {
memset(&vid_frmval, 0, sizeof(struct v4l2_frmivalenum));
CAMERA_HAL_LOG_RUNTIME("in %s the w %d, h %d", __FUNCTION__,vid_frmsize.discrete.width, vid_frmsize.discrete.height);
vid_frmval.index = 0; //get the first, that is the min frame interval, but the biggest fps
vid_frmval.pixel_format = pCapCfg->fmt;
vid_frmval.width = vid_frmsize.discrete.width;
vid_frmval.height= vid_frmsize.discrete.height;
if (ioctl(mCameraDevice, VIDIOC_ENUM_FRAMEINTERVALS, &vid_frmval) != 0) {
CAMERA_HAL_ERR("VIDIOC_ENUM_FRAMEINTERVALS error");
mSizeFPSParamIdx = 0;
ret = CAPTURE_DEVICE_ERR_SET_PARAM;
} else {
pCapCfg->width = vid_frmsize.discrete.width;
pCapCfg->height = vid_frmsize.discrete.height;
pCapCfg->tv.numerator = vid_frmval.discrete.numerator;
pCapCfg->tv.denominator = vid_frmval.discrete.denominator;
mSizeFPSParamIdx ++;
ret = CAPTURE_DEVICE_ERR_ENUM_CONTINUE;
}
}
return ret;
}
CAPTURE_DEVICE_ERR_RET V4l2CsiDevice :: V4l2EnumFmt(void *retParam) {
CAMERA_HAL_LOG_FUNC;
CAPTURE_DEVICE_ERR_RET ret = CAPTURE_DEVICE_ERR_NONE;
unsigned int *pParamVal = (unsigned int *)retParam;
if (mFmtParamIdx < ENUM_SUPPORTED_FMT) {
CAMERA_HAL_LOG_RUNTIME("vid_fmtdesc.pixelformat is %x", mSupportedFmt[mFmtParamIdx]);
*pParamVal = mSupportedFmt[mFmtParamIdx];
mFmtParamIdx ++;
ret = CAPTURE_DEVICE_ERR_ENUM_CONTINUE;
} else {
mFmtParamIdx = 0;
ret = CAPTURE_DEVICE_ERR_GET_PARAM;
}
return ret;
}
CAPTURE_DEVICE_ERR_RET V4l2CapDeviceBase :: V4l2EnumFmt(void *retParam) {
CAMERA_HAL_LOG_FUNC;
CAPTURE_DEVICE_ERR_RET ret = CAPTURE_DEVICE_ERR_NONE;
struct v4l2_fmtdesc vid_fmtdesc;
unsigned int *pParamVal = (unsigned int *)retParam;
vid_fmtdesc.index = mFmtParamIdx;
vid_fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (ioctl(mCameraDevice, VIDIOC_ENUM_FMT, &vid_fmtdesc ) != 0) {
mFmtParamIdx = 0;
ret = CAPTURE_DEVICE_ERR_GET_PARAM;
} else {
CAMERA_HAL_LOG_RUNTIME("vid_fmtdesc.pixelformat is %x", vid_fmtdesc.pixelformat);
*pParamVal = vid_fmtdesc.pixelformat;
mFmtParamIdx ++;
ret = CAPTURE_DEVICE_ERR_ENUM_CONTINUE;
}
return ret;
}
CAPTURE_DEVICE_ERR_RET V4l2CsiDevice :: V4l2SetConfig(struct capture_config_t *pCapcfg)
{
CAMERA_HAL_LOG_FUNC;
if (mCameraDevice <= 0 || pCapcfg == NULL) {
return CAPTURE_DEVICE_ERR_BAD_PARAM;
}
CAPTURE_DEVICE_ERR_RET ret = CAPTURE_DEVICE_ERR_NONE;
struct v4l2_format fmt;
struct v4l2_control ctrl;
struct v4l2_streamparm parm;
V4l2ConfigInput(pCapcfg);
parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
//hard code here to do a walk around.
if(pCapcfg->tv.denominator != 30 && pCapcfg->tv.denominator != 15) {
pCapcfg->tv.numerator = 1;
pCapcfg->tv.denominator = 30;
}
CAMERA_HAL_LOG_RUNTIME("the fps is %d", pCapcfg->tv.denominator);
parm.parm.capture.timeperframe.numerator = pCapcfg->tv.numerator;
parm.parm.capture.timeperframe.denominator = pCapcfg->tv.denominator;
ret = V4l2GetCaptureMode(pCapcfg, &(parm.parm.capture.capturemode));
if (ret != CAPTURE_DEVICE_ERR_NONE)
return ret;
if (ioctl(mCameraDevice, VIDIOC_S_PARM, &parm) < 0) {
parm.parm.capture.timeperframe.numerator = 1;
parm.parm.capture.timeperframe.denominator = 15;
if (ioctl(mCameraDevice, VIDIOC_S_PARM, &parm) < 0) {
CAMERA_HAL_ERR("%s:%d VIDIOC_S_PARM failed\n", __FUNCTION__,__LINE__);
CAMERA_HAL_ERR("frame timeval is numerator %d, denominator %d",parm.parm.capture.timeperframe.numerator,
parm.parm.capture.timeperframe.denominator);
return CAPTURE_DEVICE_ERR_SYS_CALL;
}
}
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.pixelformat = pCapcfg->fmt;
fmt.fmt.pix.width = pCapcfg->width&0xFFFFFFF8;
fmt.fmt.pix.height = pCapcfg->height&0xFFFFFFF8;
if (pCapcfg->fmt == V4L2_PIX_FMT_YUYV)
fmt.fmt.pix.bytesperline = fmt.fmt.pix.width * 2;
else
fmt.fmt.pix.bytesperline = fmt.fmt.pix.width;
fmt.fmt.pix.priv = 0;
fmt.fmt.pix.sizeimage = 0;
if (ioctl(mCameraDevice, VIDIOC_S_FMT, &fmt) < 0) {
CAMERA_HAL_ERR("set format failed\n");
CAMERA_HAL_ERR("pCapcfg->width is %d, pCapcfg->height is %d", pCapcfg->width, pCapcfg->height);
CAMERA_HAL_ERR(" Set the Format :%c%c%c%c\n",
pCapcfg->fmt & 0xFF, (pCapcfg->fmt >> 8) & 0xFF,
(pCapcfg->fmt >> 16) & 0xFF, (pCapcfg->fmt >> 24) & 0xFF);
return CAPTURE_DEVICE_ERR_SYS_CALL;
}
