add support params as we support in gingerbread

5 files changed, 418 insertions, 89 deletions

diff --git a/CameraHal.cpp b/CameraHal.cpp
index 1f8e7d3..bf28ef1 100644..100755
--- a/CameraHal.cpp
+++ b/CameraHal.cpp
@@ -3436,7 +3436,6 @@ void CameraHal::insertSupportedParams()
     p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED));
     p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED));
     p.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, mCameraProperties->get(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED));
-    p.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_VIDEO_SIZES));
 
     LOG_FUNCTION_NAME_EXIT;
 
diff --git a/CameraParameters.cpp b/CameraParameters.cpp
index 855b9b1..79c603e 100644..100755
--- a/CameraParameters.cpp
+++ b/CameraParameters.cpp
@@ -110,7 +110,6 @@ const char CameraProperties::MAX_NUM_METERING_AREAS[] = "prop-max-num-metering-a
 const char CameraProperties::METERING_AREAS[] = "prop-metering-areas";
 const char CameraProperties::VIDEO_SNAPSHOT_SUPPORTED[] = "prop-video-snapshot-supported";
 const char CameraProperties::VIDEO_SIZE[] = "video-size";
-const char CameraProperties::SUPPORTED_VIDEO_SIZES[] = "video-size-values";
 const char CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO[] = "preferred-preview-size-for-video";
 
 const char CameraProperties::PIXEL_FORMAT_RGB24[] = "rgb24";
diff --git a/V4LCameraAdapter/V4LCameraAdapter.cpp b/V4LCameraAdapter/V4LCameraAdapter.cpp
index 3fe4844..3051a5a 100755
--- a/V4LCameraAdapter/V4LCameraAdapter.cpp
+++ b/V4LCameraAdapter/V4LCameraAdapter.cpp
@@ -44,6 +44,9 @@
 #include <sys/time.h>
 
 #include <cutils/properties.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
 
 //for private_handle_t TODO move out of private header
 #include <gralloc_priv.h>
@@ -74,6 +77,14 @@ namespace android {
 
 Mutex gAdapterLock;
 
+extern "C" int set_banding(int camera_fd,const char *snm);
+extern "C" int set_night_mode(int camera_fd,const char *snm);
+extern "C" int set_effect(int camera_fd,const char *sef);
+extern "C" int SetExposure(int camera_fd,const char *sbn);
+extern "C" int set_white_balance(int camera_fd,const char *swb);
+
+
+
 /*--------------------junk STARTS here-----------------------------*/
 #define SYSFILE_CAMERA_SET_PARA "/sys/class/vm/attr2"
 #define SYSFILE_CAMERA_SET_MIRROR "/sys/class/vm/mirror"
@@ -205,13 +216,52 @@ status_t V4LCameraAdapter::setParameters(const CameraParameters &params)
 {
     LOG_FUNCTION_NAME;
 
-    status_t ret = NO_ERROR;
+    status_t rtn = NO_ERROR;
 
     // Udpate the current parameter set
-    mParams = params;
+	mParams = params;
+
+	//check zoom value
+	int zoom = mParams.getInt(CameraParameters::KEY_ZOOM);
+	int maxzoom = mParams.getInt(CameraParameters::KEY_MAX_ZOOM);
+	if((zoom > maxzoom) || (zoom < 0))
+	{
+		rtn = INVALID_OPERATION;
+		mParams.set((const char*)CameraParameters::KEY_ZOOM, maxzoom);
+	}
+
+	int min_fps,max_fps;
+	const char *white_balance=NULL;
+	const char *exposure=NULL;
+	const char *effect=NULL;
+	//const char *night_mode=NULL;
+	const char *qulity=NULL;
+	const char *banding=NULL;
+	const char *flashmode=NULL;
+
+	white_balance=mParams.get(CameraParameters::KEY_WHITE_BALANCE);
+	exposure=mParams.get(CameraParameters::KEY_EXPOSURE_COMPENSATION);
+	effect=mParams.get(CameraParameters::KEY_EFFECT);
+	banding=mParams.get(CameraParameters::KEY_ANTIBANDING);
+	qulity=mParams.get(CameraParameters::KEY_JPEG_QUALITY);
+	flashmode = mParams.get(CameraParameters::KEY_FLASH_MODE);
+	if(exposure)
+		SetExposure(mCameraHandle,exposure);
+	if(white_balance)
+		set_white_balance(mCameraHandle,white_balance);
+	if(effect)
+		set_effect(mCameraHandle,effect);
+	if(banding)
+		set_banding(mCameraHandle,banding);
+
+	mParams.getPreviewFpsRange(&min_fps, &max_fps);
+	if((min_fps<0)||(max_fps<0)||(max_fps<min_fps))
+	{
+		rtn = INVALID_OPERATION;
+	}
 
     LOG_FUNCTION_NAME_EXIT;
-    return ret;
+    return rtn;
 }
 
 
@@ -1089,28 +1139,14 @@ extern "C" int getValidFrameSize(int camera_id, int pixel_format, char *framesiz
 
 //TODO move
 extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
-    const char DEFAULT_ANTIBANDING[] = "auto";
     const char DEFAULT_BRIGHTNESS[] = "50";
     const char DEFAULT_CONTRAST[] = "100";
-    const char DEFAULT_EFFECT[] = "none";
-    const char DEFAULT_EV_COMPENSATION[] = "0";
-    const char DEFAULT_EV_STEP[] = "0.1";
-    const char DEFAULT_EXPOSURE_MODE[] = "auto";
-    const char DEFAULT_FLASH_MODE[] = "off";
-    const char DEFAULT_FOCUS_MODE_PREFERRED[] = "auto";
-    const char DEFAULT_FOCUS_MODE[] = "infinity";
-    const char DEFAULT_FRAMERATE_RANGE_IMAGE[] = "10000,15000";
-    const char DEFAULT_FRAMERATE_RANGE_VIDEO[]="10000,15000";
     const char DEFAULT_IPP[] = "ldc-nsf";
     const char DEFAULT_GBCE[] = "disable";
     const char DEFAULT_ISO_MODE[] = "auto";
-    const char DEFAULT_JPEG_QUALITY[] = "90";
-    const char DEFAULT_THUMBNAIL_QUALITY[] = "90";
-    const char DEFAULT_THUMBNAIL_SIZE[] = "160x120";
     const char DEFAULT_PICTURE_FORMAT[] = "jpeg";
     const char DEFAULT_PICTURE_SIZE[] = "640x480";
     const char DEFAULT_PREVIEW_FORMAT[] = "yuv420sp";
-    const char DEFAULT_FRAMERATE[] = "15";
     const char DEFAULT_PREVIEW_SIZE[] = "640x480";
     const char DEFAULT_NUM_PREV_BUFS[] = "6";
     const char DEFAULT_NUM_PIC_BUFS[] = "1";
@@ -1120,11 +1156,9 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     const char DEFAULT_SHARPNESS[] = "100";
     const char DEFAULT_VSTAB[] = "false";
     const char DEFAULT_VSTAB_SUPPORTED[] = "true";
-    const char DEFAULT_WB[] = "auto";
-    const char DEFAULT_ZOOM[] = "0";
     const char DEFAULT_MAX_FD_HW_FACES[] = "0";
     const char DEFAULT_MAX_FD_SW_FACES[] = "0";
-    const char DEFAULT_FOCAL_LENGTH_PRIMARY[] = "3.43";
+    const char DEFAULT_FOCAL_LENGTH_PRIMARY[] = "4.31";
     const char DEFAULT_FOCAL_LENGTH_SECONDARY[] = "1.95";
     const char DEFAULT_HOR_ANGLE[] = "54.8";
     const char DEFAULT_VER_ANGLE[] = "42.5";
@@ -1161,56 +1195,18 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     else
         params->set(CameraProperties::ORIENTATION_INDEX,"90");
 
-    params->set(CameraProperties::ANTIBANDING, DEFAULT_ANTIBANDING);
-    params->set(CameraProperties::BRIGHTNESS, DEFAULT_BRIGHTNESS);
-    params->set(CameraProperties::CONTRAST, DEFAULT_CONTRAST);
-    params->set(CameraProperties::EFFECT, DEFAULT_EFFECT);
-    params->set(CameraProperties::EV_COMPENSATION, DEFAULT_EV_COMPENSATION);
-    params->set(CameraProperties::SUPPORTED_EV_STEP, DEFAULT_EV_STEP);
-    params->set(CameraProperties::EXPOSURE_MODE, DEFAULT_EXPOSURE_MODE);
-    params->set(CameraProperties::FLASH_MODE, DEFAULT_FLASH_MODE);
-    char *pos = strstr(params->get(CameraProperties::SUPPORTED_FOCUS_MODES), DEFAULT_FOCUS_MODE_PREFERRED);
-    if ( NULL != pos )
-        {
-        params->set(CameraProperties::FOCUS_MODE, DEFAULT_FOCUS_MODE_PREFERRED);
-        }
-    else
-        {
-        params->set(CameraProperties::FOCUS_MODE, DEFAULT_FOCUS_MODE);
-        }
-    params->set(CameraProperties::IPP, DEFAULT_IPP);
-    params->set(CameraProperties::GBCE, DEFAULT_GBCE);
-    params->set(CameraProperties::ISO_MODE, DEFAULT_ISO_MODE);
-    params->set(CameraProperties::JPEG_QUALITY, DEFAULT_JPEG_QUALITY);
-    params->set(CameraProperties::JPEG_THUMBNAIL_QUALITY, DEFAULT_THUMBNAIL_QUALITY);
-    params->set(CameraProperties::JPEG_THUMBNAIL_SIZE, DEFAULT_THUMBNAIL_SIZE);
-    params->set(CameraProperties::PICTURE_FORMAT, DEFAULT_PICTURE_FORMAT);
-    params->set(CameraProperties::PREVIEW_FORMAT, DEFAULT_PREVIEW_FORMAT);
-    params->set(CameraProperties::PREVIEW_FRAME_RATE, DEFAULT_FRAMERATE);
-    params->set(CameraProperties::FRAMERATE_RANGE_IMAGE, DEFAULT_FRAMERATE_RANGE_IMAGE);
-    params->set(CameraProperties::FRAMERATE_RANGE_VIDEO, DEFAULT_FRAMERATE_RANGE_VIDEO);
-    params->set(CameraProperties::REQUIRED_PREVIEW_BUFS, DEFAULT_NUM_PREV_BUFS);
-    params->set(CameraProperties::REQUIRED_IMAGE_BUFS, DEFAULT_NUM_PIC_BUFS);
-    params->set(CameraProperties::SATURATION, DEFAULT_SATURATION);
-    params->set(CameraProperties::SCENE_MODE, DEFAULT_SCENE_MODE);
-    params->set(CameraProperties::SHARPNESS, DEFAULT_SHARPNESS);
-    params->set(CameraProperties::VSTAB, DEFAULT_VSTAB);
-    params->set(CameraProperties::VSTAB_SUPPORTED, DEFAULT_VSTAB_SUPPORTED);
-    params->set(CameraProperties::WHITEBALANCE, DEFAULT_WB);
-    params->set(CameraProperties::ZOOM, DEFAULT_ZOOM);
-    params->set(CameraProperties::MAX_FD_HW_FACES, DEFAULT_MAX_FD_HW_FACES);
-    params->set(CameraProperties::MAX_FD_SW_FACES, DEFAULT_MAX_FD_SW_FACES);
-    params->set(CameraProperties::AUTO_EXPOSURE_LOCK, DEFAULT_AE_LOCK);
-    params->set(CameraProperties::AUTO_WHITEBALANCE_LOCK, DEFAULT_AWB_LOCK);
-    params->set(CameraProperties::FOCAL_LENGTH, DEFAULT_FOCAL_LENGTH_PRIMARY);
-    params->set(CameraProperties::HOR_ANGLE, DEFAULT_HOR_ANGLE);
-    params->set(CameraProperties::VER_ANGLE, DEFAULT_VER_ANGLE);
-    params->set(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED, DEFAULT_VIDEO_SNAPSHOT_SUPPORTED);
-    params->set(CameraProperties::VIDEO_SIZE, DEFAULT_VIDEO_SIZE);
-    params->set(CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO, DEFAULT_PREFERRED_PREVIEW_SIZE_FOR_VIDEO);
+	params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,DEFAULT_PREVIEW_FORMAT);
+	params->set(CameraProperties::PREVIEW_FORMAT,DEFAULT_PREVIEW_FORMAT);
 
-    params->set(CameraProperties::FRAMERATE_RANGE, "10500,26623");
+    params->set(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES, "10,15");
+	params->set(CameraProperties::PREVIEW_FRAME_RATE, "15");
+
+	params->set(CameraProperties::FRAMERATE_RANGE_SUPPORTED, "(10500,26623)");
+	params->set(CameraProperties::FRAMERATE_RANGE, "10500,26623");
+    params->set(CameraProperties::FRAMERATE_RANGE_IMAGE, "10000,15000");
+    params->set(CameraProperties::FRAMERATE_RANGE_VIDEO, "10000,15000");
 
+	//get preview size & set
     char sizes[64];
     if (!getValidFrameSize(camera_id, DEFAULT_PREVIEW_PIXEL_FORMAT, sizes)) {
         int len = strlen(sizes);
@@ -1221,12 +1217,28 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
         params->set(CameraProperties::SUPPORTED_PREVIEW_SIZES, sizes);
         //set last size as default
         char * b = strrchr(sizes, ',');
-        if (b) b++;
-        else b = sizes;
+        if (b) 
+			b++;
+        else 
+			b = sizes;
         params->set(CameraProperties::PREVIEW_SIZE, b);
-    } else
-        params->set(CameraProperties::SUPPORTED_PREVIEW_SIZES, "640x480");
+    }
+	else
+	{
+	    params->set(CameraProperties::SUPPORTED_PREVIEW_SIZES, "352x288,640x480");
+		params->set(CameraProperties::PREVIEW_SIZE,"640x480");
+	}
+
+	params->set(CameraProperties::SUPPORTED_PICTURE_FORMATS, DEFAULT_PICTURE_FORMAT);
+	params->set(CameraProperties::PICTURE_FORMAT,DEFAULT_PICTURE_FORMAT);
+	params->set(CameraProperties::JPEG_QUALITY, 90);
+
+	//must have >2 sizes and contain "0x0"
+	params->set(CameraProperties::SUPPORTED_THUMBNAIL_SIZES, "180x160,0x0");
+	params->set(CameraProperties::JPEG_THUMBNAIL_SIZE, "180x160");
+	params->set(CameraProperties::JPEG_THUMBNAIL_QUALITY, 90);
 
+	//get & set picture size
     if (!getValidFrameSize(camera_id, DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT, sizes)) {
         int len = strlen(sizes);
         if(len>1){
@@ -1240,29 +1252,222 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
         else b = sizes;
         params->set(CameraProperties::PICTURE_SIZE, b);
     } else
-        params->set(CameraProperties::SUPPORTED_PICTURE_SIZES, "640x480");
+	{
+	    params->set(CameraProperties::SUPPORTED_PICTURE_SIZES, "640x480");
+		params->set(CameraProperties::PICTURE_SIZE, "640x480");
+	}
 
-    params->set(CameraProperties::SUPPORTED_THUMBNAIL_SIZES, "180x160,0x0");
 
-    params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS, CameraParameters::PIXEL_FORMAT_YUV420SP);
-    params->set(CameraProperties::SUPPORTED_IPP_MODES, DEFAULT_IPP);
-    params->set(CameraProperties::SUPPORTED_PICTURE_FORMATS, CameraParameters::PIXEL_FORMAT_JPEG);
-    params->set(CameraProperties::FRAMERATE_RANGE_SUPPORTED, "(10500,26623)");
-    params->set(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES, "10,15");
-    //params->set(CameraProperties::SUPPORTED_FOCUS_MODES, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE);
-    params->set(CameraProperties::SUPPORTED_FOCUS_MODES, DEFAULT_FOCUS_MODE);
+	params->set(CameraProperties::SUPPORTED_FOCUS_MODES, "fixed");
+	params->set(CameraProperties::FOCUS_MODE, "fixed");
+
+	params->set(CameraProperties::SUPPORTED_ANTIBANDING, "50hz,60hz");
+	params->set(CameraProperties::ANTIBANDING, "50hz");
+
+    params->set(CameraProperties::FOCAL_LENGTH, "4.31");
+
+	params->set(CameraProperties::HOR_ANGLE,"54.8");
+	params->set(CameraProperties::VER_ANGLE,"42.5");
 
+	params->set(CameraProperties::SUPPORTED_WHITE_BALANCE, "auto,daylight,incandescent,fluorescent");
+	params->set(CameraProperties::WHITEBALANCE, "auto");
+	params->set(CameraProperties::AUTO_WHITEBALANCE_LOCK, DEFAULT_AWB_LOCK);
+
+	params->set(CameraProperties::SUPPORTED_EFFECTS, "none,negative,sepia");
+	params->set(CameraProperties::EFFECT, "none");
+
+#ifdef AMLOGIC_FLASHLIGHT_SUPPORT
+	params->set(CameraProperties::SUPPORTED_FLASH_MODES, "on,off,torch");
+	params->set(CameraProperties::FLASH_MODE, "on");
+#endif
+
+	//params->set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,"auto,night,snow");
+	//params->set(CameraParameters::KEY_SCENE_MODE,"auto");
+
+    params->set(CameraProperties::EXPOSURE_MODE, "auto");
     params->set(CameraProperties::SUPPORTED_EXPOSURE_MODES, "auto");
-    params->set(CameraProperties::SUPPORTED_WHITE_BALANCE, "auto");
-    params->set(CameraProperties::SUPPORTED_ANTIBANDING, "auto");
+    params->set(CameraProperties::AUTO_EXPOSURE_LOCK, DEFAULT_AE_LOCK);
+
+	params->set(CameraProperties::SUPPORTED_EV_MAX, 4);
+	params->set(CameraProperties::SUPPORTED_EV_MIN, -4);
+    params->set(CameraProperties::EV_COMPENSATION, 0);
+    params->set(CameraProperties::SUPPORTED_EV_STEP, 1);
+
+	//don't support digital zoom now
+	#if 0
+	params->set(CameraProperties::ZOOM_SUPPORTED,"true");
+	params->set(CameraProperties::SMOOTH_ZOOM_SUPPORTED,1);
+	params->set(CameraProperties::SUPPORTED_ZOOM_RATIOS,"1,2,3,4,5,6,7,8");
+	params->set(CameraProperties::SUPPORTED_ZOOM_STAGES,7);	//think the zoom ratios as a array, the max zoom is the max index
+	params->set(CameraProperties::ZOOM, 0);//default should be 0
+	#else
+	params->set(CameraProperties::ZOOM_SUPPORTED,"false");
+	params->set(CameraProperties::SMOOTH_ZOOM_SUPPORTED,0);
+	params->set(CameraProperties::SUPPORTED_ZOOM_RATIOS,"1");
+	params->set(CameraProperties::SUPPORTED_ZOOM_STAGES,0);	//think the zoom ratios as a array, the max zoom is the max index
+	params->set(CameraProperties::ZOOM, 0);//default should be 0
+	#endif
+
     params->set(CameraProperties::SUPPORTED_ISO_VALUES, "auto");
+    params->set(CameraProperties::ISO_MODE, DEFAULT_ISO_MODE);
+
+    params->set(CameraProperties::SUPPORTED_IPP_MODES, DEFAULT_IPP);
+    params->set(CameraProperties::IPP, DEFAULT_IPP);
+
     params->set(CameraProperties::SUPPORTED_SCENE_MODES, "auto");
-    params->set(CameraProperties::SUPPORTED_FLASH_MODES, "off");
-    params->set(CameraProperties::SUPPORTED_EFFECTS, "none");
-    params->set(CameraProperties::SUPPORTED_VIDEO_SIZES, "352x288,640x480");
+    params->set(CameraProperties::SCENE_MODE, DEFAULT_SCENE_MODE);
+
+
+    params->set(CameraProperties::BRIGHTNESS, DEFAULT_BRIGHTNESS);
+    params->set(CameraProperties::CONTRAST, DEFAULT_CONTRAST);
+    params->set(CameraProperties::GBCE, DEFAULT_GBCE);
+    params->set(CameraProperties::SATURATION, DEFAULT_SATURATION);
+    params->set(CameraProperties::SHARPNESS, DEFAULT_SHARPNESS);
+    params->set(CameraProperties::VSTAB, DEFAULT_VSTAB);
+    params->set(CameraProperties::VSTAB_SUPPORTED, DEFAULT_VSTAB_SUPPORTED);
+    params->set(CameraProperties::MAX_FD_HW_FACES, DEFAULT_MAX_FD_HW_FACES);
+    params->set(CameraProperties::MAX_FD_SW_FACES, DEFAULT_MAX_FD_SW_FACES);
+	params->set(CameraProperties::REQUIRED_PREVIEW_BUFS, DEFAULT_NUM_PREV_BUFS);
+    params->set(CameraProperties::REQUIRED_IMAGE_BUFS, DEFAULT_NUM_PIC_BUFS);
+    params->set(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED, DEFAULT_VIDEO_SNAPSHOT_SUPPORTED);
+    params->set(CameraProperties::VIDEO_SIZE, DEFAULT_VIDEO_SIZE);
+    params->set(CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO, DEFAULT_PREFERRED_PREVIEW_SIZE_FOR_VIDEO);
 
 }
 
+extern "C" int set_white_balance(int camera_fd,const char *swb)
+{
+ 	int ret = 0;
+	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	ctl.id = V4L2_CID_DO_WHITE_BALANCE;
+
+	if(strcasecmp(swb,"auto")==0)
+		ctl.value=CAM_WB_AUTO;
+	else if(strcasecmp(swb,"daylight")==0)
+		ctl.value=CAM_WB_DAYLIGHT;
+	else if(strcasecmp(swb,"incandescent")==0)
+		ctl.value=CAM_WB_INCANDESCENCE;
+	else if(strcasecmp(swb,"fluorescent")==0)
+		ctl.value=CAM_WB_FLUORESCENT;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+	return ret ;
+}
+
+extern "C" int SetExposure(int camera_fd,const char *sbn)
+{
+ 	int ret = 0;
+	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	ctl.id = V4L2_CID_EXPOSURE;
+
+	if(strcasecmp(sbn,"4")==0)
+		ctl.value=EXPOSURE_P4_STEP;
+	else if(strcasecmp(sbn,"3")==0)
+		ctl.value=EXPOSURE_P3_STEP;
+	else if(strcasecmp(sbn,"2")==0)
+		ctl.value=EXPOSURE_P2_STEP;
+	else if(strcasecmp(sbn,"1")==0)
+		ctl.value=EXPOSURE_P1_STEP;
+	else if(strcasecmp(sbn,"0")==0)
+		ctl.value=EXPOSURE_0_STEP;
+	else if(strcasecmp(sbn,"-1")==0)
+		ctl.value=EXPOSURE_N1_STEP;
+	else if(strcasecmp(sbn,"-2")==0)
+		ctl.value=EXPOSURE_N2_STEP;
+	else if(strcasecmp(sbn,"-3")==0)
+		ctl.value=EXPOSURE_N3_STEP;
+	else if(strcasecmp(sbn,"-4")==0)
+		ctl.value=EXPOSURE_N4_STEP;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+
+	return ret ;
+}
+
+extern "C" int set_effect(int camera_fd,const char *sef)
+{
+ 	int ret = 0;
+	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	ctl.id = V4L2_CID_COLORFX;
+
+	if(strcasecmp(sef,"none")==0)
+		ctl.value=CAM_EFFECT_ENC_NORMAL;
+	else if(strcasecmp(sef,"negative")==0)
+		ctl.value=CAM_EFFECT_ENC_COLORINV;
+	else if(strcasecmp(sef,"sepia")==0)
+		ctl.value=CAM_EFFECT_ENC_SEPIA;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+
+	return ret ;
+}
+
+extern "C" int set_night_mode(int camera_fd,const char *snm)
+{
+ 	int ret = 0;
+ 	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	if(strcasecmp(snm,"auto")==0)
+		ctl.value=CAM_NM_AUTO;
+	else if(strcasecmp(snm,"night")==0)
+		ctl.value=CAM_NM_ENABLE;
+
+	ctl.id = V4L2_CID_DO_WHITE_BALANCE;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+	return ret ;
+}
+
+extern "C" int set_banding(int camera_fd,const char *snm)
+{
+ 	int ret = 0;
+ 	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	if(strcasecmp(snm,"50hz")==0)
+		ctl.value=CAM_NM_AUTO;
+	else if(strcasecmp(snm,"60hz")==0)
+		ctl.value=CAM_NM_ENABLE;
+
+	ctl.id = V4L2_CID_WHITENESS;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+	return ret ;
+}
+
+
 };
 
 
diff --git a/inc/CameraProperties.h b/inc/CameraProperties.h
index 1afebc0..973fe6c 100644..100755
--- a/inc/CameraProperties.h
+++ b/inc/CameraProperties.h
@@ -141,7 +141,6 @@ public:
     static const char VIDEO_SNAPSHOT_SUPPORTED[];

 

     static const char VIDEO_SIZE[];

-    static const char SUPPORTED_VIDEO_SIZES[];

     static const char PREFERRED_PREVIEW_SIZE_FOR_VIDEO[];

 

     static const char PIXEL_FORMAT_RGB24[];

diff --git a/inc/V4LCameraAdapter/V4LCameraAdapter.h b/inc/V4LCameraAdapter/V4LCameraAdapter.h
index 213a7fc..8e89121 100755
--- a/inc/V4LCameraAdapter/V4LCameraAdapter.h
+++ b/inc/V4LCameraAdapter/V4LCameraAdapter.h
@@ -43,6 +43,133 @@ struct VideoInfo {
     int framesizeIn;
 };
 
+typedef enum camera_light_mode_e {
+    ADVANCED_AWB = 0,
+    SIMPLE_AWB,
+    MANUAL_DAY,
+    MANUAL_A,
+    MANUAL_CWF,
+    MANUAL_CLOUDY,
+}camera_light_mode_t;
+
+typedef enum camera_saturation_e {
+    SATURATION_N4_STEP = 0,
+    SATURATION_N3_STEP,
+    SATURATION_N2_STEP,
+    SATURATION_N1_STEP,
+    SATURATION_0_STEP,
+    SATURATION_P1_STEP,
+    SATURATION_P2_STEP,
+    SATURATION_P3_STEP,
+    SATURATION_P4_STEP,
+}camera_saturation_t;
+
+
+typedef enum camera_brightness_e {
+    BRIGHTNESS_N4_STEP = 0,
+    BRIGHTNESS_N3_STEP,
+    BRIGHTNESS_N2_STEP,
+    BRIGHTNESS_N1_STEP,
+    BRIGHTNESS_0_STEP,
+    BRIGHTNESS_P1_STEP,
+    BRIGHTNESS_P2_STEP,
+    BRIGHTNESS_P3_STEP,
+    BRIGHTNESS_P4_STEP,
+}camera_brightness_t;
+
+typedef enum camera_contrast_e {
+    CONTRAST_N4_STEP = 0,
+    CONTRAST_N3_STEP,
+    CONTRAST_N2_STEP,
+    CONTRAST_N1_STEP,
+    CONTRAST_0_STEP,
+    CONTRAST_P1_STEP,
+    CONTRAST_P2_STEP,
+    CONTRAST_P3_STEP,
+    CONTRAST_P4_STEP,
+}camera_contrast_t;
+
+typedef enum camera_hue_e {
+    HUE_N180_DEGREE = 0,
+    HUE_N150_DEGREE,
+    HUE_N120_DEGREE,
+    HUE_N90_DEGREE,
+    HUE_N60_DEGREE,
+    HUE_N30_DEGREE,
+    HUE_0_DEGREE,
+    HUE_P30_DEGREE,
+    HUE_P60_DEGREE,
+    HUE_P90_DEGREE,
+    HUE_P120_DEGREE,
+    HUE_P150_DEGREE,
+}camera_hue_t;
+
+typedef enum camera_special_effect_e {
+    SPECIAL_EFFECT_NORMAL = 0,
+    SPECIAL_EFFECT_BW,
+    SPECIAL_EFFECT_BLUISH,
+    SPECIAL_EFFECT_SEPIA,
+    SPECIAL_EFFECT_REDDISH,
+    SPECIAL_EFFECT_GREENISH,
+    SPECIAL_EFFECT_NEGATIVE,
+}camera_special_effect_t;
+
+typedef enum camera_exposure_e {
+    EXPOSURE_N4_STEP = 0,
+    EXPOSURE_N3_STEP,
+    EXPOSURE_N2_STEP,
+    EXPOSURE_N1_STEP,
+    EXPOSURE_0_STEP,
+    EXPOSURE_P1_STEP,
+    EXPOSURE_P2_STEP,
+    EXPOSURE_P3_STEP,
+    EXPOSURE_P4_STEP,
+}camera_exposure_t;
+
+
+typedef enum camera_sharpness_e {
+    SHARPNESS_1_STEP = 0,
+    SHARPNESS_2_STEP,
+    SHARPNESS_3_STEP,
+    SHARPNESS_4_STEP,
+    SHARPNESS_5_STEP,
+    SHARPNESS_6_STEP,
+    SHARPNESS_7_STEP,
+    SHARPNESS_8_STEP,
+    SHARPNESS_AUTO_STEP,
+}camera_sharpness_t;
+
+typedef enum camera_mirror_flip_e {
+    MF_NORMAL = 0,
+    MF_MIRROR,
+    MF_FLIP,
+    MF_MIRROR_FLIP,
+}camera_mirror_flip_t;
+
+
+typedef enum camera_wb_flip_e {
+    CAM_WB_AUTO = 0,
+    CAM_WB_CLOUD,
+    CAM_WB_DAYLIGHT,
+    CAM_WB_INCANDESCENCE,
+    CAM_WB_TUNGSTEN,
+    CAM_WB_FLUORESCENT,
+    CAM_WB_MANUAL,
+}camera_wb_flip_t;
+typedef enum camera_night_mode_flip_e {
+    CAM_NM_AUTO = 0,
+	CAM_NM_ENABLE,
+}camera_night_mode_flip_t;
+typedef enum camera_effect_flip_e {
+    CAM_EFFECT_ENC_NORMAL = 0,
+	CAM_EFFECT_ENC_GRAYSCALE,
+	CAM_EFFECT_ENC_SEPIA,
+	CAM_EFFECT_ENC_SEPIAGREEN,
+	CAM_EFFECT_ENC_SEPIABLUE,
+	CAM_EFFECT_ENC_COLORINV,
+}camera_effect_flip_t;
+
+
 
 /**
   * Class which completely abstracts the camera hardware interaction from camera hal