friendlyelec
/
rk35xx-android12
1
0
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b2396bfea0'
${ noResults }
rk35xx-android12/packages/apps/Camera360/CameraSocAdapter.cpp

922 lines
38 KiB
Raw Blame History

/******************************************************************************
*
* Copyright (C) 2018 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
* BY DOWNLOADING, INSTALLING, COPYING, SAVING OR OTHERWISE USING THIS SOFTWARE,
* YOU ACKNOWLEDGE THAT YOU AGREE THE SOFTWARE RECEIVED FORM ROCKCHIP IS PROVIDED
* TO YOU ON AN "AS IS" BASIS and ROCKCHP DISCLAIMS ANY AND ALL WARRANTIES AND
* REPRESENTATIONS WITH RESPECT TO SUCH FILE, WHETHER EXPRESS, IMPLIED, STATUTORY
* OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY IMPLIED WARRANTIES OF TITLE,
* NON-INFRINGEMENT, MERCHANTABILITY, SATISFACTROY QUALITY, ACCURACY OR FITNESS FOR
* A PARTICULAR PURPOSE.
* Rockchip hereby grants to you a limited, non-exclusive, non-sublicensable and
* non-transferable license (a) to install, save and use the Software; (b) to copy
* and distribute the Software in binary code format only.
* Except as expressively authorized by Rockchip in writing, you may NOT: (a) distribute
* the Software in source code; (b) distribute on a standalone basis but you may distribute
* the Software in conjunction with platforms incorporating Rockchip integrated circuits;
* (c) modify the Software in whole or part;(d) decompile, reverse-engineer, dissemble,
* or attempt to derive any source code from the Software;(e) remove or obscure any copyright,
* patent, or trademark statement or notices contained in the Software.
*
*****************************************************************************/
#include "CameraHal.h"
namespace android{
CameraSOCAdapter::CameraSOCAdapter(int cameraId, int dev_id)
:CameraAdapter(cameraId, dev_id)
{
mCamDriverV4l2MemType = V4L2_MEMORY_DMABUF;
CameraHal_SupportFmt[0] = V4L2_PIX_FMT_NV12;
CameraHal_SupportFmt[1] = V4L2_PIX_FMT_NV16;
#if CONFIG_CAMERA_UVC_MJPEG_SUPPORT
CameraHal_SupportFmt[2] = V4L2_PIX_FMT_MJPEG;
CameraHal_SupportFmt[3] = V4L2_PIX_FMT_YUYV;
CameraHal_SupportFmt[4] = V4L2_PIX_FMT_RGB565;
#else
CameraHal_SupportFmt[2] = V4L2_PIX_FMT_YUYV;
CameraHal_SupportFmt[3] = V4L2_PIX_FMT_RGB565;
CameraHal_SupportFmt[4] = 0x00;
#endif
CameraHal_SupportFmt[5] = 0x00;
mWhiteBalance_number = 0;
mEffect_number = 0;
mScene_number = 0;
mAntibanding_number = 0;
mZoomMin = 0;
mZoomMax = 0;
mZoomStep = 0;
mFlashMode_number = 0;
mCamDriverFrmWidthMax = 0;
mCamDriverFrmHeightMax = 0;
}
CameraSOCAdapter::~CameraSOCAdapter()
{
}
int CameraSOCAdapter::cameraStop()
{
int i;
char *cameraDevicePathCur = NULL;
/* ddl@rock-chips.com: Release v4l2 buffer must by close device, buffer isn't release in VIDIOC_STREAMOFF ioctl */
if (mCamDriverV4l2MemType == V4L2_MEMORY_MMAP) {
for (i=0; i<V4L2_BUFFER_MAX; i++) {
if (mCamDriverV4l2Buffer[i] != NULL) {
if (munmap((void*)mCamDriverV4l2Buffer[i], mCamDriverV4l2BufferLen) < 0)
LOGE("%s(%d): mCamDriverV4l2Buffer[%d] munmap failed : %s",__FUNCTION__,__LINE__,i,strerror(errno));
mCamDriverV4l2Buffer[i] = NULL;
} else {
break;
}
}
}
close(mCamFd);
return 0;
}
void CameraSOCAdapter::initDefaultParameters(int camFd)
{
CameraParameters params;
String8 parameterString;
int i,j,k,previewFrameSizeMax;
char cur_param[32],str_element[32]; /* ddl@rock-chips.com: v0.4.f */
char str[300];
int ret,picture_size_bit,framerate[200];
struct v4l2_format fmt;
struct v4l2_queryctrl query_control;
struct v4l2_control control;
struct v4l2_querymenu *menu_ptr,query_menu;
struct v4l2_frmivalenum fival;
struct v4l2_frmsizeenum fsize;
bool dot,isRestartPreview = false;
char *ptr,str_fov_h[4],str_fov_v[4],fov_h,fov_v;
LOG_FUNCTION_NAME
i = 0;
memset(str,0x00,sizeof(str));
memset(framerate,0x00,sizeof(framerate));
/*preview size setting*/
fsize.index = 0;
fsize.pixel_format = mCamDriverPreviewFmt;
mCamDriverFrmWidthMax = 0;
mCamDriverFrmHeightMax = 0;
while ((ret = ioctl(mCamFd, VIDIOC_ENUM_FRAMESIZES, &fsize)) == 0) {
if (fsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
memset(str_element,0x00,sizeof(str_element));
if (parameterString.size() != 0)
str_element[0]=',';
sprintf((char*)(&str_element[strlen(str_element)]),"%d",fsize.discrete.width);
strcat(str_element, "x");
sprintf((char*)(&str_element[strlen(str_element)]),"%d",fsize.discrete.height);
parameterString.append((const char*)str_element);
if (fsize.discrete.width > (unsigned int)mCamDriverFrmWidthMax) {
mCamDriverFrmWidthMax = fsize.discrete.width;
mCamDriverFrmHeightMax = fsize.discrete.height;
}
memset(&fival, 0, sizeof(fival));
fival.index = 0;
fival.pixel_format = fsize.pixel_format;
fival.width = fsize.discrete.width;
fival.height = fsize.discrete.height;
while ((ret = ioctl(mCamFd, VIDIOC_ENUM_FRAMEINTERVALS, &fival)) == 0) {
if (fival.type == V4L2_FRMIVAL_TYPE_DISCRETE) {
framerate[i++] = fival.discrete.denominator/fival.discrete.numerator;
//LOGD("%dx%d : %d %d/%d",fival.width,fival.height, framerate[i-1],fival.discrete.denominator,fival.discrete.numerator);
} else if (fival.type == V4L2_FRMIVAL_TYPE_CONTINUOUS) {
break;
} else if (fival.type == V4L2_FRMIVAL_TYPE_STEPWISE) {
break;
}
fival.index++;
}
}
fsize.index++;
}
params.set(KEY_PREVIEW_W_FORCE,"0");
params.set(KEY_PREVIEW_H_FORCE,"0");
params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, parameterString.string());
if(parameterString.contains("640x480"))
params.setPreviewSize(640,480);
else
params.setPreviewSize(mCamDriverFrmWidthMax,mCamDriverFrmHeightMax);
/*picture size setting*/
params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, parameterString.string());
params.setPictureSize(mCamDriverFrmWidthMax, mCamDriverFrmHeightMax);
/* set framerate */
struct v4l2_streamparm setfps;
int fps_min,fps_max;
i=0;
fps_min = 100;
fps_max = 0;
while (framerate[i]) {
memset(str_element,0x00,sizeof(str_element));
sprintf((char*)(&str_element[strlen(str_element)]),"%d",framerate[i]);
if (strstr(str,str_element)==NULL) {
if (strlen(str)==0) {
strcat(str,str_element);
} else {
strcat(str,",");
strcat(str,str_element);
}
}
if (fps_min>framerate[i])
fps_min = framerate[i];
if (fps_max<framerate[i])
fps_max = framerate[i];
i++;
}
memset(&setfps, 0, sizeof(struct v4l2_streamparm));
if (mCapture_type & V4L2_CAP_VIDEO_CAPTURE_MPLANE)
setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
else
setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
setfps.parm.capture.timeperframe.numerator=1;
setfps.parm.capture.timeperframe.denominator=fps_max;
ret = ioctl(mCamFd, VIDIOC_S_PARM, &setfps);
/*frame rate setting*/
params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, str);
params.setPreviewFrameRate(fps_max);
memset(str_element,0x00,sizeof(str_element));
sprintf((char*)(&str_element[0]),"%d,%d",fps_min*1000,fps_max*1000);
params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, str_element);
memset(str_element,0x00,sizeof(str_element));
sprintf((char*)(&str_element[0]),"(%d,%d)",fps_min*1000,fps_max*1000);
params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, str_element);
/*zoom setting*/
char str_zoom_max[3],str_zoom_element[5];
int max;
memset(str,0x00,sizeof(str));
strcpy(str, "");//default zoom
mZoomMax = 300;
mZoomMin= 100;
mZoomStep = 5;
max = (mZoomMax - mZoomMin)/mZoomStep;
sprintf(str_zoom_max,"%d",max);
params.set(CameraParameters::KEY_ZOOM_SUPPORTED, "true");
params.set(CameraParameters::KEY_MAX_ZOOM, str_zoom_max);
params.set(CameraParameters::KEY_ZOOM, "0");
for (i=mZoomMin; i<=mZoomMax; i+=mZoomStep) {
sprintf(str_zoom_element,"%d,", i);
strcat(str,str_zoom_element);
}
params.set(CameraParameters::KEY_ZOOM_RATIOS, str);
/*preview format setting*/
params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, "yuv420sp,yuv420p");
params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,CameraParameters::PIXEL_FORMAT_YUV420SP);
params.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP);
params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,CameraParameters::PIXEL_FORMAT_YUV420SP);
/*picture format setting*/
params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, CameraParameters::PIXEL_FORMAT_JPEG);
params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
/*jpeg quality setting*/
params.set(CameraParameters::KEY_JPEG_QUALITY, "70");
/*white balance setting*/
struct v4l2_queryctrl whiteBalance;
struct v4l2_querymenu *whiteBalance_menu = mWhiteBalance_menu;
/* ddl@rock-chips.com: v0.4.9 */
memset(str,0x00,sizeof(str));
dot = false;
whiteBalance.id = V4L2_CID_AUTO_WHITE_BALANCE;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &whiteBalance)) {
strcat(str, "auto");
dot = true;
}
whiteBalance.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &whiteBalance)) {
if ((whiteBalance.minimum <= 2800) && (2800 <= whiteBalance.maximum)) {
if (dot)
strcat(str, ",");
strcat(str, "incandescent");
dot = true;
}
if ((whiteBalance.minimum <= 4000) && (4000 <= whiteBalance.maximum)) {
if (dot)
strcat(str, ",");
strcat(str, "fluorescent");
dot = true;
}
if ((whiteBalance.minimum <= 5500) && (5500 <= whiteBalance.maximum)) {
if (dot)
strcat(str, ",");
strcat(str, "daylight");
dot = true;
}
if ((whiteBalance.minimum <= 6500) && (6500 <= whiteBalance.maximum)) {
if (dot)
strcat(str, ",");
strcat(str, "cloudy-daylight");
dot = true;
}
params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, str);
params.set(CameraParameters::KEY_WHITE_BALANCE, "auto");
}
/*scene setting*/
struct v4l2_queryctrl scene;
struct v4l2_querymenu *scene_menu = mScene_menu;
memset(str,0x00,sizeof(str));
strcpy(str, "");//default scene
scene.id = V4L2_CID_SCENE;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &scene)) {
for (i=scene.minimum; i<=scene.maximum; i+=scene.step) {
scene_menu->id = V4L2_CID_SCENE;
scene_menu->index = i;
if (!ioctl(mCamFd, VIDIOC_QUERYMENU, scene_menu)) {
if (i != scene.minimum)
strcat(str, ",");
strcat(str, (char *)scene_menu->name);
if (scene.default_value == i) {
strcpy(cur_param, (char *)scene_menu->name);
}
mScene_number++;
}
scene_menu++;
}
params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, str);
params.set(CameraParameters::KEY_SCENE_MODE, cur_param);
}
/*anti-banding setting*/
struct v4l2_queryctrl anti_banding;
struct v4l2_querymenu *anti_banding_menus = mAntibanding_menu;
memset(str,0x00,sizeof(str));
strcpy(str, "");//default scene
anti_banding.id = V4L2_CID_POWER_LINE_FREQUENCY;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &anti_banding)) {
for (i=anti_banding.minimum; i<=anti_banding.maximum; i+=anti_banding.step) {
anti_banding_menus->id = V4L2_CID_POWER_LINE_FREQUENCY;
anti_banding_menus->index = i;
if (!ioctl(mCamFd, VIDIOC_QUERYMENU, anti_banding_menus)) {
if (i != anti_banding.minimum)
strcat(str, ",");
if (!strcmp((char*)anti_banding_menus->name,"50 Hz")) {
strcat(str, "50hz");
if (anti_banding.default_value == i) {
strcpy(cur_param, "50hz");
}
} else if (!strcmp((char*)anti_banding_menus->name,"60 Hz")) {
strcat(str, "60hz");
if (anti_banding.default_value == i) {
strcpy(cur_param, "60hz");
}
} else if (!strcmp((char*)anti_banding_menus->name,"Disabled")) {
strcat(str, "off");
if (anti_banding.default_value == i) {
strcpy(cur_param, "off");
}
} else if (!strcmp((char*)anti_banding_menus->name,"Auto")) {
strcat(str, "auto");
if (anti_banding.default_value == i) {
strcpy(cur_param, "auto");
}
}
mAntibanding_number++;
}
anti_banding_menus++;
}
if ((!strstr(str,"auto")) && (strstr(str,"off"))) {
strcat(str, ",auto");
}
params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, str);
params.set(CameraParameters::KEY_ANTIBANDING, "off");
}
/*flash mode setting*/
struct v4l2_queryctrl flashMode;
struct v4l2_querymenu *flashMode_menu = mFlashMode_menu;
memset(str,0x00,sizeof(str));
strcpy(str, "");//default flash
flashMode.id = V4L2_CID_FLASH;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &flashMode)) {
for (i = flashMode.minimum; i <= flashMode.maximum; i += flashMode.step) {
flashMode_menu->id = V4L2_CID_FLASH;
flashMode_menu->index = i;
if (!ioctl(mCamFd, VIDIOC_QUERYMENU, flashMode_menu)) {
if (i != flashMode.minimum)
strcat(str, ",");
strcat(str, (char *)flashMode_menu->name);
if (flashMode.default_value == i) {
strcpy(cur_param, (char *)flashMode_menu->name);
}
mFlashMode_number++;
flashMode_menu++;
}
}
params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, str);
params.set(CameraParameters::KEY_FLASH_MODE, cur_param);
}
/*focus mode setting*/
struct v4l2_queryctrl focus;
parameterString = CameraParameters::FOCUS_MODE_FIXED;
params.set(CameraParameters::KEY_FOCUS_MODE, CameraParameters::FOCUS_MODE_FIXED);
#if 1
params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, CameraParameters::FOCUS_MODE_FIXED);
params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,"0");
#else
focus.id = V4L2_CID_FOCUS_AUTO;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &focus)) {
parameterString.append(",");
parameterString.append(CameraParameters::FOCUS_MODE_AUTO);
params.set(CameraParameters::KEY_FOCUS_MODE, CameraParameters::FOCUS_MODE_AUTO);
}
focus.id = V4L2_CID_FOCUS_CONTINUOUS;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &focus)) {
parameterString.append(",");
parameterString.append(CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE);
}
focus.id = V4L2_CID_FOCUS_ABSOLUTE;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &focus)) {
parameterString.append(",");
parameterString.append(CameraParameters::FOCUS_MODE_INFINITY);
parameterString.append(",");
parameterString.append(CameraParameters::FOCUS_MODE_MACRO);
}
params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, parameterString.string());
focus.id = V4L2_CID_FOCUSZONE;
// focus area settings
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &focus)) {
params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,"1");
}else{
params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,"0");
}
#endif
/*Exposure setting*/
char str_exposure[16], exposure_failed;
exposure_failed = true;
#if CONFIG_CAMERA_UVC_MANEXP
query_control.id = V4L2_CID_BRIGHTNESS;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &query_control)) {
for (i = query_control.minimum; i <= query_control.maximum; i += query_control.step) {
control.id = V4L2_CID_BRIGHTNESS;
control.value = i;
if (!ioctl(mCamFd,VIDIOC_S_CTRL,&control)) {
exposure_failed = false;
params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0");
params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "3");
params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-3");
params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "1");
} else {
LOGE("%s(%d): V4L2_CID_EXPOSURE_AUTO(%s) set failed!",
__FUNCTION__,__LINE__,query_menu.name);
}
break;
}
if (i==query_control.maximum) {
LOGE("%s(%d): V4L2_CID_EXPOSURE_AUTO Manual Mode isn't support",__FUNCTION__,__LINE__);
}
}
#endif
if (exposure_failed == true) {
params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0");
params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "0");
params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "0");
params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.000001f");
}
/*rotation setting*/
params.set(CameraParameters::KEY_ROTATION, "0");
/*horizontal angle of view setting ,no much meaning ,only for passing cts */
ptr = strstr((char*)(&mCamDriverCapability.card[0]),"-"); /* ddl@rock-chips.com: v0.4.0x15 */
if (ptr != NULL) {
ptr = strstr(ptr,"_");
if (ptr != NULL) {
ptr++;
fov_h = atoi(ptr);
sprintf(str_fov_h,"%d",fov_h);
ptr = strstr(ptr,"_");
ptr++;
fov_v = atoi(ptr);
sprintf(str_fov_v,"%d",fov_v);
} else {
LOGD("%s(%d): Current driver isn't support fov query, user can update driver to v0.3.0xf",__FUNCTION__,__LINE__);
strlcpy(str_fov_h,"100",3);
strlcpy(str_fov_v,"100",3);
}
} else {
LOGE("%s(%d): mCamDriverCapability.card is error!",__FUNCTION__,__LINE__);
strlcpy(str_fov_h,"100",3);
strlcpy(str_fov_v,"100",3);
}
params.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, str_fov_h);
params.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, str_fov_v);
params.set(KEY_CONTINUOUS_PIC_NUM,"1");
/*lzg@rockchip.com :add some settings to pass cts*/
/*focus distance setting ,no much meaning ,only for passing cts */
parameterString = "0.3,50,Infinity";
params.set(CameraParameters::KEY_FOCUS_DISTANCES, parameterString.string());
/*focus length setting ,no much meaning ,only for passing cts */
parameterString = "35";
params.set(CameraParameters::KEY_FOCAL_LENGTH, parameterString.string());
/*quality of the EXIF thumbnail in Jpeg picture setting */
parameterString = "50";
params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, parameterString.string());
/*supported size of the EXIF thumbnail in Jpeg picture setting */
parameterString = "0x0,160x128";
params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, parameterString.string());
parameterString = "160";
params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, parameterString.string());
parameterString = "128";
params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, parameterString.string());
/* zyc@rock-chips.com: for cts ,KEY_MAX_NUM_DETECTED_FACES_HW should not be 0 */
params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, "0");
params.set(CameraParameters::KEY_RECORDING_HINT,"false");
params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,"false");
params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,"true");
params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,"0");
params.set(KEY_CONTINUOUS_PIC_NUM,"1");
LOGD ("Support Preview format: %s .. %s",params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS),
params.get(CameraParameters::KEY_PREVIEW_FORMAT));
LOGD ("Support Preview sizes: %s %s",params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES),
params.get(CameraParameters::KEY_PREVIEW_SIZE));
LOGD ("Support Preview FPS range: %s",params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE));
LOGD ("Support Preview framerate: %s",params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES));
LOGD ("Support Picture sizes: %s ",params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
if (params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE))
LOGD ("Support white balance: %s",params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE));
if (params.get(CameraParameters::KEY_SUPPORTED_EFFECTS))
LOGD ("Support color effect: %s",params.get(CameraParameters::KEY_SUPPORTED_EFFECTS));
if (params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES))
LOGD ("Support scene: %s",params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES));
if (params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES))
LOGD ("Support flash: %s",params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));
LOGD ("Support focus: %s focus zone: %s",params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES),
params.get(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS));
LOGD ("Support zoom: %s(ratios: %s)",params.get(CameraParameters::KEY_ZOOM_SUPPORTED),
params.get(CameraParameters::KEY_ZOOM_RATIOS));
if (strcmp("0", params.get(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION))
|| strcmp("0", params.get(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION))) {
LOGD ("Support exposure: (%s -> %s)",params.get(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION),
params.get(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION));
}
if (params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING))
LOGD("Support anti-banding: %s anti-banding: %s",params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING),
params.get(CameraParameters::KEY_ANTIBANDING));
LOGD ("Support hardware faces detecte: %s",params.get(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW));
LOGD ("Support software faces detecte: %s",params.get(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW));
LOGD ("Support video stabilization: %s",params.get(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED));
LOGD ("Support recording hint: %s",params.get(CameraParameters::KEY_RECORDING_HINT));
cameraConfig(params,true,isRestartPreview);
LOG_FUNCTION_NAME_EXIT
}
int CameraSOCAdapter::setParameters(const CameraParameters &params_set,bool &isRestartValue)
{
CameraParameters params;
int fps_min,fps_max;
params = params_set;
if (strstr(mParameters.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES), params.get(CameraParameters::KEY_PREVIEW_SIZE)) == NULL) {
LOGE("%s(%d): previewsize(%s) not supported",__FUNCTION__,__LINE__,params.get(CameraParameters::KEY_PREVIEW_SIZE));
return BAD_VALUE;
}else if (strcmp(mParameters.get(CameraParameters::KEY_PREVIEW_SIZE), params.get(CameraParameters::KEY_PREVIEW_SIZE))) {
LOGD("%s(%d): Set preview size %s",__FUNCTION__,__LINE__,params.get(CameraParameters::KEY_PREVIEW_SIZE));
if(mPreviewRunning){
LOGD("%s(%d):WARNING, set preview size during preview",__FUNCTION__,__LINE__);
}
//should update preview cb settings ,for cts
int w,h;
const char * fmt= params_set.getPreviewFormat();
params_set.getPreviewSize(&w, &h);
//mRefEventNotifier->setPreviewDataCbRes(w, h, fmt);
}
if (strstr(mParameters.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES), params.get(CameraParameters::KEY_PICTURE_SIZE)) == NULL) {
LOGE("%s(%d): PictureSize(%s) not supported",__FUNCTION__,__LINE__,params.get(CameraParameters::KEY_PICTURE_SIZE));
return BAD_VALUE;
} else if (strcmp(mParameters.get(CameraParameters::KEY_PICTURE_SIZE), params.get(CameraParameters::KEY_PICTURE_SIZE))) {
LOGD("%s(%d): Set picture size %s",__FUNCTION__,__LINE__,params.get(CameraParameters::KEY_PICTURE_SIZE));
}
if (strcmp(params.getPictureFormat(), "jpeg") != 0) {
LOGE("%s(%d): Only jpeg still pictures are supported",__FUNCTION__,__LINE__);
return BAD_VALUE;
}
//set zoom
if (params.getInt(CameraParameters::KEY_ZOOM) > params.getInt(CameraParameters::KEY_MAX_ZOOM)) {
LOGE("Zomm(%d) is larger than MaxZoom(%d)",params.getInt(CameraParameters::KEY_ZOOM),params.getInt(CameraParameters::KEY_MAX_ZOOM));
return BAD_VALUE;
}
params.getPreviewFpsRange(&fps_min,&fps_max);
if ((fps_min < 0) || (fps_max < 0) || (fps_max < fps_min)) {
LOGE("%s(%d): FpsRange(%s) is invalidate",__FUNCTION__,__LINE__,params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE));
return BAD_VALUE;
}
//set af
if (strstr(mParameters.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES),params.get(CameraParameters::KEY_FOCUS_MODE))){
LOGD("suppport focus modes:%s, expect:%s",mParameters.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES),
params.get(CameraParameters::KEY_FOCUS_MODE));
}else {
LOGE("%s isn't supported for this camera, support focus: %s",
params.get(CameraParameters::KEY_FOCUS_MODE),
mParameters.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES));
if (strstr(mParameters.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES),CameraParameters::FOCUS_MODE_AUTO))
mParameters.set(CameraParameters::KEY_FOCUS_MODE, CameraParameters::FOCUS_MODE_AUTO);
else
mParameters.set(CameraParameters::KEY_FOCUS_MODE, CameraParameters::FOCUS_MODE_FIXED);
return BAD_VALUE;
}
//adapter needn't know preview formats ? just to tell AppMsgNotifier ?
if (strstr(mParameters.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS),params.getPreviewFormat())) {
if (strcmp(mParameters.getPreviewFormat(), params.getPreviewFormat())){
if(mPreviewRunning){
LOGD("%s(%d): WARING,set preview format during preview",__FUNCTION__,__LINE__);
}
}
} else {
LOGE("%s(%d): %s is not supported,Only %s and %s preview is supported",__FUNCTION__,__LINE__,params.getPreviewFormat(),CameraParameters::PIXEL_FORMAT_YUV420SP,CameraParameters::PIXEL_FORMAT_YUV422SP);
return BAD_VALUE;
}
int framerate = params.getPreviewFrameRate();
if (!cameraConfig(params,false,isRestartValue)) {
LOG1("PreviewSize(%s)", mParameters.get(CameraParameters::KEY_PREVIEW_SIZE));
LOG1("PreviewFormat(%s) mCamDriverPreviewFmt(%c%c%c%c)",params.getPreviewFormat(),
mCamDriverPreviewFmt & 0xFF, (mCamDriverPreviewFmt >> 8) & 0xFF,
(mCamDriverPreviewFmt >> 16) & 0xFF, (mCamDriverPreviewFmt >> 24) & 0xFF);
LOG1("FPS Range(%s)",mParameters.get(CameraParameters::KEY_PREVIEW_FPS_RANGE));
LOG1("PictureSize(%s)",mParameters.get(CameraParameters::KEY_PICTURE_SIZE));
LOG1("PictureFormat(%s) ", params.getPictureFormat());
LOG1("Framerate: %d ", framerate);
LOG1("WhiteBalance: %s", params.get(CameraParameters::KEY_WHITE_BALANCE));
LOG1("Flash: %s", params.get(CameraParameters::KEY_FLASH_MODE));
LOG1("Focus: %s", params.get(CameraParameters::KEY_FOCUS_MODE));
LOG1("Scene: %s", params.get(CameraParameters::KEY_SCENE_MODE));
LOG1("Effect: %s", params.get(CameraParameters::KEY_EFFECT));
LOG1("ZoomIndex: %s", params.get(CameraParameters::KEY_ZOOM));
}else{
return BAD_VALUE;
}
return 0;
}
int CameraSOCAdapter::cameraConfig(const CameraParameters &tmpparams,bool isInit,bool &isRestartValue)
{
int err = 0, i = 0;
struct v4l2_control control;
struct v4l2_ext_control extCtrInfo;
struct v4l2_ext_controls extCtrInfos;
struct v4l2_queryctrl query_control;
CameraParameters params = tmpparams;
bool isRestartPreview = false;
if (params.getPreviewFrameRate() != mParameters.getPreviewFrameRate()) {
if (mPreviewRunning == 0) { /* ddl@rock-chips.com: v0.4.0x21 */
struct v4l2_streamparm setfps;
memset(&setfps, 0, sizeof(struct v4l2_streamparm));
if (mCapture_type & V4L2_CAP_VIDEO_CAPTURE_MPLANE)
setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
else
setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
setfps.parm.capture.timeperframe.numerator=1;
setfps.parm.capture.timeperframe.denominator=params.getPreviewFrameRate();
err = ioctl(mCamFd, VIDIOC_S_PARM, &setfps);
if (err != 0) {
LOGE ("%s(%d): Set framerate(%d fps) failed",__FUNCTION__,__LINE__,params.getPreviewFrameRate());
//return err;
} else {
LOGD ("%s(%d): Set framerate(%d fps) success",__FUNCTION__,__LINE__,params.getPreviewFrameRate());
}
} else {
LOGE("%s(%d): UVC isn't support set framerate after start preview",__FUNCTION__,__LINE__);
}
}
/*white balance setting*/
const char *white_balance = params.get(CameraParameters::KEY_WHITE_BALANCE);
const char *mwhite_balance = mParameters.get(CameraParameters::KEY_WHITE_BALANCE);
if (params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE)) {
if ( !mwhite_balance || strcmp(white_balance, mwhite_balance) ) {
/* ddl@rock-chips.com: v0.4.9 */
control.id = V4L2_CID_AUTO_WHITE_BALANCE;
if (strcmp(white_balance,"auto")==0) {
control.value = true;
} else {
control.value = false;
err = ioctl(mCamFd, VIDIOC_S_CTRL, &control);
if (err<0) {
LOGE("%s(%d): turn off auto white balance failed",__FUNCTION__,__LINE__);
}
}
if (strcmp(white_balance,"incandescent")==0) {
control.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
control.value = 2800;
} else if (strcmp(white_balance,"fluorescent")==0) {
control.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
control.value = 4000;
} else if (strcmp(white_balance,"daylight")==0) {
control.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
control.value = 5500;
} else if (strcmp(white_balance,"cloudy-daylight")==0) {
control.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
control.value = 6500;
}
err = ioctl(mCamFd, VIDIOC_S_CTRL, &control);
if (err<0) {
LOGE("%s(%d): Set white balance(%s) failed",__FUNCTION__,__LINE__,white_balance);
} else {
LOGD("%s(%d): Set white balance(%s) success",__FUNCTION__,__LINE__,white_balance);
}
}
}
/*zoom setting*/
const int zoom = params.getInt(CameraParameters::KEY_ZOOM);
const int mzoom = mParameters.getInt(CameraParameters::KEY_ZOOM);
if ((mzoom < 0) || (zoom != mzoom)) {
mZoomVal = zoom * mZoomStep + mZoomMin;
}
/*color effect setting*/
const char *effect = params.get(CameraParameters::KEY_EFFECT);
const char *meffect = mParameters.get(CameraParameters::KEY_EFFECT);
if (params.get(CameraParameters::KEY_SUPPORTED_EFFECTS)) {
if ( !meffect || strcmp(effect, meffect) ) {
for (i = 0; i < mEffect_number; i++) {
if (!strcmp((char *)mEffect_menu[i].name, effect)) {
break;
}
}
extCtrInfo.id = mEffect_menu[i].id;
extCtrInfo.value = mEffect_menu[i].index;
extCtrInfos.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
extCtrInfos.count = 1;
extCtrInfos.controls = &extCtrInfo;
err = ioctl(mCamFd, VIDIOC_S_EXT_CTRLS, &extCtrInfos);
if ( err < 0 ){
LOGE ("%s(%d): Set effect(%s) fail",__FUNCTION__,__LINE__,effect);
} else {
LOGD("%s(%d): Set effect %s",__FUNCTION__,__LINE__, (char *)mEffect_menu[i].name);
}
}
}
/*anti-banding setting*/
const char *anti_banding = params.get(CameraParameters::KEY_ANTIBANDING);
const char *manti_banding = mParameters.get(CameraParameters::KEY_ANTIBANDING);
if (anti_banding != NULL) {
if ( !manti_banding || (anti_banding && strcmp(anti_banding, manti_banding)) ) {
if (!strcmp(anti_banding,CameraParameters::ANTIBANDING_OFF)) {
for (i=0; i<mAntibanding_number; i++) {
if (!strcmp((char*)mAntibanding_menu[i].name,"Disabled"))
break;
}
} else if (!strcmp(anti_banding,CameraParameters::ANTIBANDING_50HZ)) {
for (i=0; i<mAntibanding_number; i++) {
if (!strcmp((char*)mAntibanding_menu[i].name,"50 Hz"))
break;
}
} else if (!strcmp(anti_banding,CameraParameters::ANTIBANDING_60HZ)) {
for (i=0; i<mAntibanding_number; i++) {
if (!strcmp((char*)mAntibanding_menu[i].name,"60 Hz"))
break;
}
} else if (!strcmp(anti_banding,CameraParameters::ANTIBANDING_AUTO)) {
for (i=0; i<mAntibanding_number; i++) {
if (!strcmp((char*)mAntibanding_menu[i].name,"Auto"))
break;
}
if (i==mAntibanding_number) {
for (i=0; i<mAntibanding_number; i++) {
if (!strcmp((char*)mAntibanding_menu[i].name,"Disabled"))
break;
}
}
}
if (i<mAntibanding_number) {
control.id = mAntibanding_menu[i].id;
control.value = mAntibanding_menu[i].index;
err = ioctl(mCamFd, VIDIOC_S_CTRL, &control);
if ( err < 0 ){
LOGE("%s(%d): Set anti-banding(%s) failed",__FUNCTION__,__LINE__,anti_banding);
} else {
LOGD ("%s(%d): Set anti-banding %s ",__FUNCTION__,__LINE__, (char *)mAntibanding_menu[i].name);
}
} else {
LOGE("%s(%d): AntiBanding(%s) isn't support!",__FUNCTION__,__LINE__, anti_banding);
}
}
}
/*scene setting*/
const char *scene = params.get(CameraParameters::KEY_SCENE_MODE);
const char *mscene = mParameters.get(CameraParameters::KEY_SCENE_MODE);
if (params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES)) {
if ( !mscene || strcmp(scene, mscene) ) {
for (i = 0; i < mScene_number; i++) {
if (!strcmp((char *)mScene_menu[i].name, scene)) {
break;
}
}
extCtrInfo.id = mScene_menu[i].id;
extCtrInfo.value = mScene_menu[i].index;
extCtrInfos.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
extCtrInfos.count = 1;
extCtrInfos.controls = &extCtrInfo;
err = ioctl(mCamFd, VIDIOC_S_EXT_CTRLS, &extCtrInfos);
if ( err < 0 ){
LOGE("%s(%d): Set scene(%s) failed",__FUNCTION__,__LINE__,scene);
} else {
LOGD ("%s(%d): Set scene %s ",__FUNCTION__,__LINE__, (char *)mScene_menu[i].name);
}
}
}
/*focus setting*/
/*flash mode setting*/
const char *flashMode = params.get(CameraParameters::KEY_FLASH_MODE);
const char *mflashMode = mParameters.get(CameraParameters::KEY_FLASH_MODE);
if (params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES)) {
if ( !mflashMode || strcmp(flashMode, mflashMode) ) {
for (i = 0; i < mFlashMode_number; i++) {
if (!strcmp((char *)mFlashMode_menu[i].name, flashMode)) {
break;
}
}
if(i== mFlashMode_number || mFlashMode_number == 0){
params.set(CameraParameters::KEY_FLASH_MODE,(mflashMode?mflashMode:CameraParameters::FLASH_MODE_OFF));
err = -1;
LOGE("%s(%d): flashMode %s is not support",__FUNCTION__,__LINE__,flashMode);
} else {
extCtrInfo.id = mFlashMode_menu[i].id;
extCtrInfo.value = mFlashMode_menu[i].index;
extCtrInfos.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
extCtrInfos.count = 1;
extCtrInfos.controls = &extCtrInfo;
err = ioctl(mCamFd, VIDIOC_S_EXT_CTRLS, &extCtrInfos);
if ( err < 0 ){
LOGE ("%s(%d): Set flash(%s) failed",__FUNCTION__,__LINE__,flashMode );
} else {
LOGD ("%s(%d): Set flash %s",__FUNCTION__,__LINE__, (char *)mFlashMode_menu[i].name);
}
}
}
}
/*exposure setting*/
const char *exposure = params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION);
const char *mexposure = mParameters.get(CameraParameters::KEY_EXPOSURE_COMPENSATION);
if (strcmp("0", params.get(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION))
|| strcmp("0", params.get(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION))) {
if (!mexposure || (exposure && strcmp(exposure,mexposure))) {
#if CONFIG_CAMERA_UVC_MANEXP
query_control.id = V4L2_CID_BRIGHTNESS;
if (!ioctl(mCamFd, VIDIOC_QUERYCTRL, &query_control)){
const int medium = (query_control.maximum + query_control.minimum)/2;
control.id = V4L2_CID_BRIGHTNESS ;
control.value = medium + atoi(exposure) * (query_control.maximum - medium)/3;
if (ioctl(mCamFd,VIDIOC_S_CTRL, &control) <0) {
LOGE("%s(%d): Set exposure(%s) failed",__FUNCTION__,__LINE__,exposure);
} else {
LOGD("%s(%d): Set exposure %s %d",__FUNCTION__,__LINE__,exposure,control.value);
}
}
#endif
}
}
mParameters = params;
//changeVideoPreviewSize();
isRestartValue = isNeedToRestartPreview();
end:
return err;
}
//define the frame info ,such as w, h ,fmt
int CameraSOCAdapter::reprocessFrame(FramInfo_s* frame)
{
return 0;
}
}
View Git Blame Copy Permalink