S5PC11X: libcamera: fix a number of bugs in camera HAL

* don't save parameters that aren't valid
* correct the focal length exif info - should be 3.43mm
* update with right focus distance info for front camera
* correct thumbnail size in params to match HAL code
* fix advertized 1M picture size to match recent driver change
* don't generate thumbnails if size set to 0x0
* set right max preview size
* don't set scene mode if we don't have any in front camera
* update to latest fps ranges in rear sensor (min of 15fps in normal mode, 4fps in night mode)
* add support for GPS_TIMESTAMP, GPS_DATESTAMP, GPS_PROCESSING_METHOD
* remove gps settings if passed NULL
* move recording-size info to internal params
* workaround front camera not supporting get_iso and get_shot_time for now
* remove antibanding code since we don't support it
* ignore invalid jpeg quality settings
* reject fps max and min different than our current setting
* simplify scene mode settings. driver should have all the
  right settings already for things like iso, sharpness, saturation,
  etc.  the HAL shouldn't set these separately because that will
  just confuse and override the sensors own settings.

Change-Id: Ib6121cc1ceb650a993661d0ec7498a3472a1dd89
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

3 files changed, 370 insertions, 417 deletions

diff --git a/libcamera/SecCamera.cpp b/libcamera/SecCamera.cpp
index 8a85d09..78a760d 100644
--- a/libcamera/SecCamera.cpp
+++ b/libcamera/SecCamera.cpp
@@ -40,17 +40,20 @@ using namespace android;
 //#define PERFORMANCE //Uncomment to measure performance
 //#define DUMP_YUV    //Uncomment to take a dump of YUV frame during capture
 
-#define CHECK(return_value)                                                             \
-            if (return_value < 0) {                                                     \
-                LOGE("%s::%d fail. errno: %s\n", __func__,__LINE__, strerror(errno));   \
-                return -1;                                                              \
-            }
+#define CHECK(return_value)                                          \
+    if (return_value < 0) {                                          \
+        LOGE("%s::%d fail. errno: %s, m_camera_id = %d\n",           \
+             __func__, __LINE__, strerror(errno), m_camera_id);      \
+        return -1;                                                   \
+    }
 
-#define CHECK_PTR(return_value)                                                         \
-            if (return_value < 0) {                                                     \
-                LOGE("%s::%d fail\n", __func__,__LINE__);                               \
-                return NULL;                                                            \
-            }
+
+#define CHECK_PTR(return_value)                                      \
+    if (return_value < 0) {                                          \
+        LOGE("%s::%d fail, errno: %s, m_camera_id = %d\n",           \
+             __func__,__LINE__, strerror(errno), m_camera_id);       \
+        return NULL;                                                 \
+    }
 
 #define ALIGN_TO_32B(x)   ((((x) + (1 <<  5) - 1) >>  5) <<  5)
 #define ALIGN_TO_128B(x)  ((((x) + (1 <<  7) - 1) >>  7) <<  7)
@@ -531,7 +534,8 @@ static int fimc_v4l2_g_ctrl(int fp, unsigned int id)
 
     ret = ioctl(fp, VIDIOC_G_CTRL, &ctrl);
     if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_G_CTRL(id = 0x%x) failed\n", __func__, id);
+        LOGE("ERR(%s): VIDIOC_G_CTRL(id = 0x%x (%d)) failed, ret = %d\n",
+             __func__, id, id-V4L2_CID_PRIVATE_BASE, ret);
         return ret;
     }
 
@@ -548,8 +552,9 @@ static int fimc_v4l2_s_ctrl(int fp, unsigned int id, unsigned int value)
 
     ret = ioctl(fp, VIDIOC_S_CTRL, &ctrl);
     if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_S_CTRL failed, ret: %d, value = %d, id = %#x\n",
-             __func__, ret, value, id);
+        LOGE("ERR(%s):VIDIOC_S_CTRL(id = %#x (%d), value = %d) failed ret = %d\n",
+             __func__, id, id-V4L2_CID_PRIVATE_BASE, value, ret);
+
         return ret;
     }
 
@@ -589,11 +594,11 @@ static int fimc_v4l2_g_parm(int fp, struct v4l2_streamparm *streamparm)
         LOGE("ERR(%s):VIDIOC_G_PARM failed\n", __func__);
         return -1;
     }
-/*
-    LOGV("timeperframe: numerator %d, denominator %d\n",
-            stream.parm.capture.timeperframe.numerator,
-            stream.parm.capture.timeperframe.denominator);
-*/
+
+    LOGV("%s : timeperframe: numerator %d, denominator %d\n", __func__,
+            streamparm->parm.capture.timeperframe.numerator,
+            streamparm->parm.capture.timeperframe.denominator);
+
     return 0;
 }
 
@@ -665,7 +670,7 @@ SecCamera::SecCamera() :
 #endif // ENABLE_ESD_PREVIEW_CHECK
 {
     m_params = (struct sec_cam_parm*)&m_streamparm.parm.raw_data;
-	struct v4l2_captureparm capture;
+    struct v4l2_captureparm capture;
     m_params->capture.timeperframe.numerator = 1;
     m_params->capture.timeperframe.denominator = 0;
     m_params->contrast = -1;
@@ -958,17 +963,19 @@ int SecCamera::startPreview(void)
     CHECK(ret);
 
 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
-    m_flag_camera_start = 1;  //Kamat check
+    m_flag_camera_start = 1;
 
     if (m_camera_id == CAMERA_ID_BACK) {
         ret = fimc_v4l2_s_parm(m_cam_fd, &m_streamparm);
         CHECK(ret);
     } else {    // In case VGA camera
         /* Brightness setting */
+	    LOGE("m_params->brightness = %d", m_params->brightness);
         ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS,
                                m_params->brightness);
         CHECK(ret);
         /* Blur setting */
+	    LOGE("m_blur_level = %d", m_blur_level);
         ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VGA_BLUR,
                                m_blur_level);
         CHECK(ret);
@@ -984,7 +991,7 @@ int SecCamera::startPreview(void)
 #endif  /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
 
 #ifndef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
-    m_flag_camera_start = 1;  //Kamat check
+    m_flag_camera_start = 1;
 #endif  /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
 
 #ifdef ENABLE_HDMI_DISPLAY
@@ -1021,7 +1028,7 @@ int SecCamera::stopPreview(void)
 
     int ret = fimc_v4l2_streamoff(m_cam_fd);
 
-    m_flag_camera_start = 0; //Kamat check
+    m_flag_camera_start = 0;
     CHECK(ret);
 
     return ret;
@@ -1048,7 +1055,7 @@ int SecCamera::startRecord(void)
     m_events_c2.fd = m_cam_fd2;
     m_events_c2.events = POLLIN | POLLERR;
 
-    int m_record_v4lformat = V4L2_PIX_FMT_NV12T; //Kamat: set suitably
+    int m_record_v4lformat = V4L2_PIX_FMT_NV12T;
     /* enum_fmt, s_fmt sample */
     int ret = fimc_v4l2_enum_fmt(m_cam_fd2,m_record_v4lformat);
     CHECK(ret);
@@ -1086,7 +1093,7 @@ int SecCamera::startRecord(void)
     ret = fimc_poll(&m_events_c2);
     CHECK(ret);
 
-    m_flag_record_start = 1;  //Kamat check
+    m_flag_record_start = 1;
 
     return 0;
 }
@@ -1107,7 +1114,7 @@ int SecCamera::stopRecord(void)
 
     int ret = fimc_v4l2_streamoff(m_cam_fd2);
 
-    m_flag_record_start = 0; //Kamat check
+    m_flag_record_start = 0;
     CHECK(ret);
 
     return 0;
@@ -1244,9 +1251,9 @@ int SecCamera::getPreview()
     }
 
 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
-    ret = fimc_v4l2_qbuf(m_cam_fd, index); //Kamat: is it overhead?
+    ret = fimc_v4l2_qbuf(m_cam_fd, index);
 #else   /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
-    int ret = fimc_v4l2_qbuf(m_cam_fd, index); //Kamat: is it overhead?
+    int ret = fimc_v4l2_qbuf(m_cam_fd, index);
 #endif  /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
 
     CHECK(ret);
@@ -1294,7 +1301,7 @@ int SecCamera::getRecord()
         return -1;
     }
 
-    int ret = fimc_v4l2_qbuf(m_cam_fd2, index); //Kamat: is it overhead?
+    int ret = fimc_v4l2_qbuf(m_cam_fd2, index);
     CHECK(ret);
 
     return index;
@@ -1390,21 +1397,21 @@ int SecCamera::setSnapshotCmd(void)
     int nframe = 1;
 
     ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat);
-    CHECK_PTR(ret);
+    CHECK(ret);
     ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, V4L2_PIX_FMT_JPEG);
-    CHECK_PTR(ret);
+    CHECK(ret);
     init_yuv_buffers(m_buffers_c, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat);
 
     ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
-    CHECK_PTR(ret);
+    CHECK(ret);
     ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
-    CHECK_PTR(ret);
+    CHECK(ret);
 
     ret = fimc_v4l2_qbuf(m_cam_fd, 0);
-    CHECK_PTR(ret);
+    CHECK(ret);
 
     ret = fimc_v4l2_streamon(m_cam_fd);
-    CHECK_PTR(ret);
+    CHECK(ret);
     LOG_TIME_END(1)
 
     return 0;
@@ -1421,32 +1428,8 @@ unsigned char* SecCamera::getJpeg(int *jpeg_size, unsigned int *phyaddr)
     unsigned char *addr;
 
     LOG_TIME_DEFINE(2)
-    /* kidggang (10.7.5) - Problem - After jpegquality is capture, operation setting is normal.
-
-    ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_QUALITY, m_jpeg_quality);
-    CHECK_PTR(ret);
-    */
 
 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
-    //exif orient info
-//  ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EXIF_ORIENTATION, m_exif_orientation); //kidggang
-//  CHECK_PTR(ret);
-#if  0//def SWP1_CAMERA_ADD_ADVANCED_FUNCTION
-    //set gps information
-    ret = fimc_v4l2_s_ext_ctrl(m_cam_fd, V4L2_CID_CAMERA_GPS_LATITUDE, &m_gps_latitude);
-    CHECK_PTR(ret);
-    ret = fimc_v4l2_s_ext_ctrl(m_cam_fd, V4L2_CID_CAMERA_GPS_LONGITUDE, &m_gps_longitude);
-    CHECK_PTR(ret);
-    ret = fimc_v4l2_s_ext_ctrl(m_cam_fd, V4L2_CID_CAMERA_GPS_ALTITUDE, &m_gps_altitude);
-    CHECK_PTR(ret);
-    ret = fimc_v4l2_s_ext_ctrl(m_cam_fd, V4L2_CID_CAMERA_GPS_TIMESTAMP, &m_gps_timestamp);
-    CHECK_PTR(ret);
-#endif
-
-/* kidggang
-    ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CAPTURE, 0);
-    CHECK_PTR(ret);*/
-
     // capture
     ret = fimc_poll(&m_events_c);
     CHECK_PTR(ret);
@@ -1467,8 +1450,8 @@ unsigned char* SecCamera::getJpeg(int *jpeg_size, unsigned int *phyaddr)
 
     ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
     CHECK_PTR(ret);
-    LOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d\n\n",
-            index, m_snapshot_width, m_snapshot_height);
+    LOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d, size = %d\n\n",
+            index, m_snapshot_width, m_snapshot_height, *jpeg_size);
 
     addr = (unsigned char*)(m_buffers_c[index].start) + main_offset;
     *phyaddr = getPhyAddrY(index) + m_postview_offset;
@@ -1485,49 +1468,57 @@ int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc)
 {
     JpegEncoder jpgEnc;
 #if ADD_THUMB_IMG
-    int inFormat = JPG_MODESEL_YCBCR;
-    int outFormat = JPG_422;
-    switch (m_snapshot_v4lformat) {
-    case V4L2_PIX_FMT_NV12:
-    case V4L2_PIX_FMT_NV21:
-    case V4L2_PIX_FMT_NV12T:
-    case V4L2_PIX_FMT_YUV420:
-        outFormat = JPG_420;
-        break;
-    case V4L2_PIX_FMT_YUYV:
-    case V4L2_PIX_FMT_UYVY:
-    case V4L2_PIX_FMT_YUV422P:
-        outFormat = JPG_422;
-        break;
-    }
+    LOGV("%s : m_jpeg_thumbnail_width = %d, height = %d",
+         __func__, m_jpeg_thumbnail_width, m_jpeg_thumbnail_height);
+    if ((m_jpeg_thumbnail_width > 0) && (m_jpeg_thumbnail_height > 0)) {
+        int inFormat = JPG_MODESEL_YCBCR;
+        int outFormat = JPG_422;
+        switch (m_snapshot_v4lformat) {
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV21:
+        case V4L2_PIX_FMT_NV12T:
+        case V4L2_PIX_FMT_YUV420:
+            outFormat = JPG_420;
+            break;
+        case V4L2_PIX_FMT_YUYV:
+        case V4L2_PIX_FMT_UYVY:
+        case V4L2_PIX_FMT_YUV422P:
+            outFormat = JPG_422;
+            break;
+        }
 
-    if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS)
-        return -1;
+        if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS)
+            return -1;
 
-    if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS)
-        return -1;
+        if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS)
+            return -1;
 
-    if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, JPG_QUALITY_LEVEL_2) != JPG_SUCCESS)
-        return -1;
+        if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, JPG_QUALITY_LEVEL_2) != JPG_SUCCESS)
+            return -1;
 
-    int thumbWidth, thumbHeight, thumbSrcSize;
-    getThumbnailConfig(&thumbWidth, &thumbHeight, &thumbSrcSize);
-    if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, thumbWidth) != JPG_SUCCESS)
-        return -1;
+        int thumbWidth, thumbHeight, thumbSrcSize;
+        getThumbnailConfig(&thumbWidth, &thumbHeight, &thumbSrcSize);
+        if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, thumbWidth) != JPG_SUCCESS)
+            return -1;
 
-    if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, thumbHeight) != JPG_SUCCESS)
-        return -1;
+        if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, thumbHeight) != JPG_SUCCESS)
+            return -1;
 
-    char *pInBuf = (char *)jpgEnc.getInBuf(thumbSrcSize);
-    if (pInBuf == NULL)
-        return -1;
-    memcpy(pInBuf, pThumbSrc, thumbSrcSize);
+        char *pInBuf = (char *)jpgEnc.getInBuf(thumbSrcSize);
+        if (pInBuf == NULL)
+            return -1;
+        memcpy(pInBuf, pThumbSrc, thumbSrcSize);
 
-    unsigned int thumbSize;
+        unsigned int thumbSize;
 
-    jpgEnc.encode(&thumbSize, NULL);
+        jpgEnc.encode(&thumbSize, NULL);
 
-    mExifInfo.enableThumb = true;
+        LOGV("%s : enableThumb set to true", __func__);
+        mExifInfo.enableThumb = true;
+    } else {
+        LOGV("%s : enableThumb set to false", __func__);
+        mExifInfo.enableThumb = false;
+    }
 #else
     mExifInfo.enableThumb = false;
 #endif
@@ -1535,6 +1526,10 @@ int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc)
     unsigned int exifSize;
 
     setExifChangedAttribute();
+
+    LOGV("%s: calling jpgEnc.makeExif, mExifInfo.width set to %d, height to %d\n",
+         __func__, mExifInfo.width, mExifInfo.height);
+
     jpgEnc.makeExif(pExifDst, &mExifInfo, &exifSize, true);
 
     return exifSize;
@@ -1670,7 +1665,7 @@ int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_bu
     fimc_poll(&m_events_c);
     index = fimc_v4l2_dqbuf(m_cam_fd);
     fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
-    LOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d\n\n",
+    LOGV("\nsnapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d\n\n",
             index, m_snapshot_width, m_snapshot_height);
 
 #ifdef DUMP_YUV
@@ -2008,7 +2003,7 @@ int SecCamera::getRotate(void)
     return m_angle;
 }
 
-void SecCamera::setFrameRate(int frame_rate)
+int SecCamera::setFrameRate(int frame_rate)
 {
 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
     LOGV("%s(FrameRate(%d))", __func__, frame_rate);
@@ -2019,14 +2014,16 @@ void SecCamera::setFrameRate(int frame_rate)
     if (m_params->capture.timeperframe.denominator != (unsigned)frame_rate) {
         m_params->capture.timeperframe.denominator = frame_rate;
         if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, frame_rate) < 0)
+            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, frame_rate) < 0) {
                 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FRAME_RATE", __func__);
+                return -1;
+            }
         }
     }
 #else
     m_params->capture.timeperframe.denominator = frame_rate;
 #endif
-
+    return 0;
 }
 
 // -----------------------------------
@@ -2097,7 +2094,7 @@ int SecCamera::setWhiteBalance(int white_balance)
 
 int SecCamera::getWhiteBalance(void)
 {
-    LOGV("%s : white_balance(%d)", __func__, m_parmas.white_balance);
+    LOGV("%s : white_balance(%d)", __func__, m_params->white_balance);
     return m_params->white_balance;
 }
 
@@ -2796,6 +2793,20 @@ int SecCamera::setGPSTimeStamp(const char *gps_timestamp)
     return 0;
 }
 
+int SecCamera::setGPSProcessingMethod(const char *gps_processing_method)
+{
+    LOGV("%s(gps_processing_method(%s))", __func__, gps_processing_method);
+    memset(mExifInfo.gps_processing_method, 0, sizeof(mExifInfo.gps_processing_method));
+    if (gps_processing_method != NULL) {
+        size_t len = strlen(gps_processing_method);
+        if (len > sizeof(mExifInfo.gps_processing_method)) {
+            len = sizeof(mExifInfo.gps_processing_method);
+        }
+        memcpy(mExifInfo.gps_processing_method, gps_processing_method, len);
+    }
+    return 0;
+}
+
 int SecCamera::setFaceDetectLockUnlock(int facedetect_lockunlock)
 {
     LOGV("%s(facedetect_lockunlock(%d))", __func__, facedetect_lockunlock);
@@ -3173,14 +3184,14 @@ unsigned char* SecCamera::yuv2Jpeg(unsigned char *raw_data, int raw_size, int *j
 
 #endif
 
-    if (raw_size == 0) { //Kamat: This is our code path
+    if (raw_size == 0) {
         unsigned int addr_y;
         int width, height,frame_size;
         getSnapshotSize(&width, &height, &frame_size);
         if (raw_data == NULL) {
             LOGE("%s %d] Raw data is NULL \n", __func__, __LINE__);
             goto YUV2JPEG_END;
-        } else { //Kamat: our path
+        } else {
             addr_y = (unsigned int)raw_data;
         }
 
@@ -3288,7 +3299,7 @@ void SecCamera::setExifFixedAttribute()
     //3 Flash
     mExifInfo.flash = EXIF_DEF_FLASH;
     //3 Lens Focal Length
-    mExifInfo.focal_length.num = EXIF_DEF_FOCAL_LEN_NUM;
+    mExifInfo.focal_length.num = 343; /* focal length of 3.43mm */
     mExifInfo.focal_length.den = EXIF_DEF_FOCAL_LEN_DEN;
     //3 User Comments
     strcpy((char *)mExifInfo.user_comment, EXIF_DEF_USERCOMMENTS);
@@ -3346,11 +3357,27 @@ void SecCamera::setExifChangedAttribute()
     //3 Exposure Time
     int shutterSpeed = fimc_v4l2_g_ctrl(m_cam_fd,
                                             V4L2_CID_CAMERA_GET_SHT_TIME);
+    /* TBD - front camera needs to be fixed to support this g_ctrl,
+       it current returns a negative err value, so avoid putting
+       odd value into exif for now */
+    if (shutterSpeed < 0) {
+        LOGE("%s: error %d getting shutterSpeed, camera_id = %d, using 100",
+             __func__, shutterSpeed, m_camera_id);
+        shutterSpeed = 100;
+    }
     mExifInfo.exposure_time.num = 1;
     mExifInfo.exposure_time.den = 1000.0 / shutterSpeed;   /* ms -> sec */
 
     //3 ISO Speed Rating
     int iso = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_ISO);
+    /* TBD - front camera needs to be fixed to support this g_ctrl,
+       it current returns a negative err value, so avoid putting
+       odd value into exif for now */
+    if (iso < 0) {
+        LOGE("%s: error %d getting iso, camera_id = %d, using 100",
+             __func__, iso, m_camera_id);
+        iso = 100;
+    }
     if (m_params->iso == ISO_AUTO) {
         mExifInfo.iso_speed_rating = iso;
     } else {
@@ -3478,17 +3505,25 @@ void SecCamera::setExifChangedAttribute()
         mExifInfo.gps_altitude.num = (uint32_t)altitude;
         mExifInfo.gps_altitude.den = 1;
 
+        struct tm tm_data;
+        gmtime_r(&m_gps_timestamp, &tm_data);
+        mExifInfo.gps_timestamp[0].num = tm_data.tm_hour;
+        mExifInfo.gps_timestamp[0].den = 1;
+        mExifInfo.gps_timestamp[1].num = tm_data.tm_min;
+        mExifInfo.gps_timestamp[1].den = 1;
+        mExifInfo.gps_timestamp[2].num = tm_data.tm_sec;
+        mExifInfo.gps_timestamp[2].den = 1;
+        snprintf((char*)mExifInfo.gps_datestamp, sizeof(mExifInfo.gps_datestamp),
+                "%04d:%02d:%02d", tm_data.tm_year, tm_data.tm_mon, tm_data.tm_mday);
+
         mExifInfo.enableGps = true;
     } else {
         mExifInfo.enableGps = false;
     }
 
     //2 1th IFD TIFF Tags
-    int thumbWidth, thumbHeight, thumbSrcSize;
-
-    getThumbnailConfig(&thumbWidth, &thumbHeight, &thumbSrcSize);
-    mExifInfo.widthThumb = thumbWidth;
-    mExifInfo.heightThumb = thumbHeight;
+    mExifInfo.widthThumb = m_jpeg_thumbnail_width;
+    mExifInfo.heightThumb = m_jpeg_thumbnail_height;
 }
 
 // ======================================================================
diff --git a/libcamera/SecCamera.h b/libcamera/SecCamera.h
index 30cad23..f1efcb9 100644
--- a/libcamera/SecCamera.h
+++ b/libcamera/SecCamera.h
@@ -95,25 +95,25 @@ namespace android {
 #define JOIN_AGAIN(x, y) x ## y
 
 #define FRONT_CAM VGA
-#define BACK_CAM ISX006
+#define BACK_CAM S5K4ECGX
 
 #if !defined (FRONT_CAM) || !defined(BACK_CAM)
 #error "Please define the Camera module"
 #endif
 
-#define ISX006_PREVIEW_WIDTH            640
-#define ISX006_PREVIEW_HEIGHT           480
-#define ISX006_SNAPSHOT_WIDTH           2560
-#define ISX006_SNAPSHOT_HEIGHT          1920
+#define S5K4ECGX_PREVIEW_WIDTH            720
+#define S5K4ECGX_PREVIEW_HEIGHT           480
+#define S5K4ECGX_SNAPSHOT_WIDTH           2560
+#define S5K4ECGX_SNAPSHOT_HEIGHT          1920
 
-#define ISX006_POSTVIEW_WIDTH           640
-#define ISX006_POSTVIEW_WIDE_WIDTH      800
-#define ISX006_POSTVIEW_HEIGHT          480
-#define ISX006_POSTVIEW_BPP             16
+#define S5K4ECGX_POSTVIEW_WIDTH           640
+#define S5K4ECGX_POSTVIEW_WIDE_WIDTH      800
+#define S5K4ECGX_POSTVIEW_HEIGHT          480
+#define S5K4ECGX_POSTVIEW_BPP             16
 
-#define ISX006_THUMBNAIL_WIDTH          320
-#define ISX006_THUMBNAIL_HEIGHT         240
-#define ISX006_THUMBNAIL_BPP            16
+#define S5K4ECGX_THUMBNAIL_WIDTH          320
+#define S5K4ECGX_THUMBNAIL_HEIGHT         240
+#define S5K4ECGX_THUMBNAIL_BPP            16
 
 #define VGA_PREVIEW_WIDTH               640
 #define VGA_PREVIEW_HEIGHT              480
@@ -415,6 +415,7 @@ public:
     int             setGPSLongitude(const char *gps_longitude);
     int             setGPSAltitude(const char *gps_altitude);
     int             setGPSTimeStamp(const char *gps_timestamp);
+    int             setGPSProcessingMethod(const char *gps_timestamp);
     int             cancelAutofocus(void);
     int             setFaceDetectLockUnlock(int facedetect_lockunlock);
     int             setObjectPosition(int x, int y);
@@ -449,7 +450,7 @@ public:
 #endif // ENABLE_ESD_PREVIEW_CHECK
 #endif
 
-    void setFrameRate(int frame_rate);
+    int setFrameRate(int frame_rate);
     unsigned char*  getJpeg(int*, unsigned int*);
     int             getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf,
                                         unsigned int *output_size);
diff --git a/libcamera/SecCameraHWInterface.cpp b/libcamera/SecCameraHWInterface.cpp
index eccc881..27c30cc 100644
--- a/libcamera/SecCameraHWInterface.cpp
+++ b/libcamera/SecCameraHWInterface.cpp
@@ -51,8 +51,7 @@
 #define BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR       "0.10,1.20,Infinity"
 #define BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR      "0.10,0.20,Infinity"
 #define BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR   "0.10,1.20,Infinity"
-/* TBD: placeholder values, to be adjusted */
-#define FRONT_CAMERA_FOCUS_DISTANCES_STR           "0.30,0.30,Infinity"
+#define FRONT_CAMERA_FOCUS_DISTANCES_STR           "0.20,0.25,Infinity"
 
 namespace android {
 
@@ -180,14 +179,13 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
     int snapshot_max_width  = 0;
     int snapshot_max_height = 0;
 
-    ip.set("camera-id", cameraId);
     /* set camera ID & reset camera */
     mSecCamera->setCameraId(cameraId);
     if (cameraId == SecCamera::CAMERA_ID_BACK) {
         p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
-              "640x480,720x480,352x288,176x144");
+              "720x480,640x480,352x288,176x144");
         p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
-              "2560x1920,2048x1536,1600x1200,1024x768,640x480");
+              "2560x1920,2048x1536,1600x1200,1280x960,640x480");
     } else {
         p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
               "640x480");
@@ -223,11 +221,8 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
     p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "30");
     p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
           CameraParameters::PIXEL_FORMAT_JPEG);
-    p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
-          "160x120,0x0");
     p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
           CameraParameters::PIXEL_FORMAT_YUV420SP);
-    p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "7500,30000");
 
     String8 parameterString;
 
@@ -243,6 +238,10 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
               CameraParameters::FOCUS_MODE_AUTO);
         p.set(CameraParameters::KEY_FOCUS_DISTANCES,
               BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
+        p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
+              "320x240,0x0");
+        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "320");
+        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "240");
     } else {
         parameterString = CameraParameters::FOCUS_MODE_FIXED;
         p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
@@ -251,6 +250,10 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
               CameraParameters::FOCUS_MODE_FIXED);
         p.set(CameraParameters::KEY_FOCUS_DISTANCES,
               FRONT_CAMERA_FOCUS_DISTANCES_STR);
+        p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
+              "160x120,0x0");
+        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "160");
+        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "120");
     }
 
     parameterString = CameraParameters::EFFECT_NONE;
@@ -298,11 +301,18 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
         parameterString.append(CameraParameters::SCENE_MODE_CANDLELIGHT);
         p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
               parameterString.string());
+        p.set(CameraParameters::KEY_SCENE_MODE,
+              CameraParameters::SCENE_MODE_AUTO);
 
-        p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(3780,30000)");
+        /* we have two ranges, 4-30fps for night mode and
+         * 15-30fps for all others
+         */
+        p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)");
+        p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "15000,30000");
 
     } else {
         p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(7500,30000)");
+        p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "7500,30000");
     }
 
     parameterString = CameraParameters::WHITE_BALANCE_AUTO;
@@ -325,21 +335,16 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
     ip.set("contrast-max", 4);
 #endif
 
-    // These values must be multiples of 16, so we can't do 427x320, which is the exact size on
-    // screen we want to display at. 480x360 doesn't work either since it's a multiple of 8.
-    p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "160");
-    p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "120");
     p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "100");
 
     p.set(CameraParameters::KEY_ROTATION, 0);
     p.set(CameraParameters::KEY_WHITE_BALANCE, CameraParameters::WHITE_BALANCE_AUTO);
 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
     p.set(CameraParameters::KEY_EFFECT, CameraParameters::EFFECT_NONE);
-    p.set(CameraParameters::KEY_SCENE_MODE, CameraParameters::SCENE_MODE_AUTO);
 
-    ip.set("sharpness", 2);
-    ip.set("contrast", 2);
-    ip.set("saturation", 2);
+    ip.set("sharpness", SHARPNESS_DEFAULT);
+    ip.set("contrast", CONTRAST_DEFAULT);
+    ip.set("saturation", SATURATION_DEFAULT);
     ip.set("iso", "auto");
     ip.set("metering", "center");
 
@@ -353,7 +358,7 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
     ip.set("image-effects", "original");
 #endif
 
-    p.set(CameraParameters::KEY_FOCAL_LENGTH, "3.79");
+    p.set(CameraParameters::KEY_FOCAL_LENGTH, "3.43");
 
     p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, "51.2");
     p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, "39.4");
@@ -361,7 +366,7 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
     p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0");
     p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "4");
     p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-4");
-    p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "1.0");
+    p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.5");
 
     mParameters = p;
     mInternalParameters = ip;
@@ -371,6 +376,12 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
      * want to change something.
      */
     setParameters(p);
+    mSecCamera->setISO(ISO_AUTO);
+    mSecCamera->setMetering(METERING_CENTER);
+    mSecCamera->setContrast(CONTRAST_DEFAULT);
+    mSecCamera->setSharpness(SHARPNESS_DEFAULT);
+    mSecCamera->setSaturation(SATURATION_DEFAULT);
+    mSecCamera->setFrameRate(30);
 }
 
 CameraHardwareSec::~CameraHardwareSec()
@@ -1103,14 +1114,10 @@ int CameraHardwareSec::pictureThread()
     int JpegImageSize, JpegExifSize;
     bool isLSISensor = false;
 
-    isLSISensor = !strncmp((const char*)mCameraSensorName, "S5K4ECGX", 8);
-    if (isLSISensor)
-        LOGE("== Camera Sensor Detect LSI SOC 5M ==\n");
-    else
-        LOGE("== Camera Sensor Detect Sony SOC 5M ==\n");
-
     if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) {
+        isLSISensor = !strncmp((const char*)mCameraSensorName, "S5K4ECGX", 8);
         if(isLSISensor) {
+            LOGI("== Camera Sensor Detect %s - Samsung LSI SOC 5M ==\n", mCameraSensorName);
             // LSI 5M SOC
             SplitFrame(jpeg_data, SecCamera::getInterleaveDataSize(),
                        SecCamera::getJpegLineLength(),
@@ -1118,6 +1125,7 @@ int CameraHardwareSec::pictureThread()
                        JpegHeap->base(), &JpegImageSize,
                        PostviewHeap->base(), &mPostViewSize);
         } else {
+            LOGI("== Camera Sensor Detect %s Sony SOC 5M ==\n", mCameraSensorName);
             decodeInterleaveData(jpeg_data, SecCamera::getInterleaveDataSize(), mPostViewWidth, mPostViewHeight,
                                 &JpegImageSize, JpegHeap->base(), PostviewHeap->base());
 
@@ -1483,22 +1491,13 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
 
     status_t ret = NO_ERROR;
 
-    mParameters = params;
-
-    // set camera id
-    int new_camera_id = mInternalParameters.getInt("camera-id");
-    if (0 <= new_camera_id) {
-        if (mSecCamera->setCameraId(new_camera_id) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setCameraId(camera_id(%d))", __func__, new_camera_id);
-            ret = UNKNOWN_ERROR;
-        }
-    }
-
     // preview size
     int new_preview_width  = 0;
     int new_preview_height = 0;
     params.getPreviewSize(&new_preview_width, &new_preview_height);
     const char *new_str_preview_format = params.getPreviewFormat();
+    LOGV("%s : new_preview_widthxnew_preview_height = %dx%d, format = %s",
+         __func__, new_preview_width, new_preview_height, new_str_preview_format);
 
     if (0 < new_preview_width && 0 < new_preview_height && new_str_preview_format != NULL) {
         int new_preview_format = 0;
@@ -1524,6 +1523,9 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
             LOGE("ERR(%s):Fail on mSecCamera->setPreviewSize(width(%d), height(%d), format(%d))",
                     __func__, new_preview_width, new_preview_height, new_preview_format);
             ret = UNKNOWN_ERROR;
+        } else {
+                mParameters.setPreviewSize(new_preview_width, new_preview_height);
+                mParameters.setPreviewFormat(new_str_preview_format);
         }
 #if defined(BOARD_USES_OVERLAY)
         if (mUseOverlay == true && mOverlay != 0) {
@@ -1539,17 +1541,20 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
     int new_picture_height = 0;
 
     params.getPictureSize(&new_picture_width, &new_picture_height);
+    LOGV("%s : new_picture_widthxnew_picture_height = %dx%d", __func__, new_picture_width, new_picture_height);
     if (0 < new_picture_width && 0 < new_picture_height) {
         if (mSecCamera->setSnapshotSize(new_picture_width, new_picture_height) < 0) {
             LOGE("ERR(%s):Fail on mSecCamera->setSnapshotSize(width(%d), height(%d))",
                     __func__, new_picture_width, new_picture_height);
             ret = UNKNOWN_ERROR;
+        } else {
+            mParameters.setPictureSize(new_picture_width, new_picture_height);
         }
     }
 
     // picture format
     const char *new_str_picture_format = params.getPictureFormat();
-
+    LOGV("%s : new_str_picture_format %s", __func__, new_str_picture_format);
     if (new_str_picture_format != NULL) {
         int new_picture_format = 0;
 
@@ -1579,28 +1584,30 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
         if (mSecCamera->setSnapshotPixelFormat(new_picture_format) < 0) {
             LOGE("ERR(%s):Fail on mSecCamera->setSnapshotPixelFormat(format(%d))", __func__, new_picture_format);
             ret = UNKNOWN_ERROR;
+        } else {
+            mParameters.setPictureFormat(new_str_picture_format);
         }
     }
 
 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
     //JPEG image quality
     int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
-
-    if (new_jpeg_quality < 1 || new_jpeg_quality > 100) {
-        LOGE("ERR(%s): Invalid quality(%d))", __func__, new_jpeg_quality);
-
-        new_jpeg_quality = 100;
-
-        mParameters.set(CameraParameters::KEY_JPEG_QUALITY, "100");
+    LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality);
+    /* we ignore bad values */
+    if (new_jpeg_quality >=1 && new_jpeg_quality <= 100) {
+        if (mSecCamera->setJpegQuality(new_jpeg_quality) < 0) {
+            LOGE("ERR(%s):Fail on mSecCamera->setJpegQuality(quality(%d))", __func__, new_jpeg_quality);
+            ret = UNKNOWN_ERROR;
+        } else {
+            mParameters.set(CameraParameters::KEY_JPEG_QUALITY, new_jpeg_quality);
+        }
     }
-
-    mSecCamera->setJpegQuality(new_jpeg_quality);
 #else
     //JPEG image quality
     int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
-
+    LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality);
     if (new_jpeg_quality < 0) {
-    LOGW("JPEG-image quality is not specified or is negative, defaulting to 100");
+        LOGW("JPEG-image quality is not specified or is negative, defaulting to 100");
         new_jpeg_quality = 100;
         mParameters.set(CameraParameters::KEY_JPEG_QUALITY, "100");
     }
@@ -1610,300 +1617,165 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
     // JPEG thumbnail size
     int new_jpeg_thumbnail_width = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
     int new_jpeg_thumbnail_height= params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
-
-    if (0 < new_jpeg_thumbnail_width && 0 < new_jpeg_thumbnail_height) {
+    if (0 <= new_jpeg_thumbnail_width && 0 <= new_jpeg_thumbnail_height) {
         if (mSecCamera->setJpegThumbnailSize(new_jpeg_thumbnail_width, new_jpeg_thumbnail_height) < 0) {
             LOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height);
             ret = UNKNOWN_ERROR;
+        } else {
+            mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, new_jpeg_thumbnail_width);
+            mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, new_jpeg_thumbnail_height);
         }
     }
 
     // frame rate
     int new_frame_rate = params.getPreviewFrameRate();
-
-    if (new_frame_rate < 5 || new_frame_rate > 30) {
-        new_frame_rate = 30;
-    }
-
-    mParameters.setPreviewFrameRate(new_frame_rate);
-    // Calculate how long to wait between frames.
-    mPreviewFrameRateMicrosec = (int)(1000000.0f / float(new_frame_rate));
-
-    LOGD("frame rate:%d, mPreviewFrameRateMicrosec:%d", new_frame_rate, mPreviewFrameRateMicrosec);
-
-    mSecCamera->setFrameRate(new_frame_rate);
-
-    //vt mode
-    int new_vtmode = mInternalParameters.getInt("vtmode");
-
-    if (0 <= new_vtmode) {
-        if (mSecCamera->setVTmode(new_vtmode) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setVTMode(%d)", __func__, new_vtmode);
-            ret = UNKNOWN_ERROR;
-        }
+    /* ignore any fps request, we're determine fps automatically based
+     * on scene mode.  don't return an error because it causes CTS failure.
+     */
+    if (new_frame_rate != 30) {
+        LOGW("WARN(%s): request for frame rate setting (%d) not allowed\n", __func__, new_frame_rate);
     }
 
     // rotation
     int new_rotation = params.getInt(CameraParameters::KEY_ROTATION);
-    int new_exif_rotation = 1;
-
+    LOGV("%s : new_rotation %d", __func__, new_rotation);
     if (0 <= new_rotation) {
         LOGV("%s : set orientation:%d\n", __func__, new_rotation);
         if (mSecCamera->setExifOrientationInfo(new_rotation) < 0) {
             LOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __func__, new_rotation);
             ret = UNKNOWN_ERROR;
+        } else {
+            mParameters.set(CameraParameters::KEY_ROTATION, new_rotation);
+        }
+    }
+
+    // brightness
+    int new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
+    int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION);
+    int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION);
+    LOGV("%s : new_exposure_compensation %d", __func__, new_exposure_compensation);
+    if ((min_exposure_compensation <= new_exposure_compensation) &&
+        (max_exposure_compensation >= new_exposure_compensation)) {
+        if (mSecCamera->setBrightness(new_exposure_compensation) < 0) {
+            LOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_exposure_compensation);
+            ret = UNKNOWN_ERROR;
+        } else {
+            mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, new_exposure_compensation);
+        }
+    }
+
+    // whitebalance
+    const char *new_white_str = params.get(CameraParameters::KEY_WHITE_BALANCE);
+    LOGV("%s : new_white_str %s", __func__, new_white_str);
+    if (new_white_str != NULL) {
+        int new_white = -1;
+
+        if (!strcmp(new_white_str, CameraParameters::WHITE_BALANCE_AUTO))
+            new_white = WHITE_BALANCE_AUTO;
+        else if (!strcmp(new_white_str,
+                         CameraParameters::WHITE_BALANCE_DAYLIGHT))
+            new_white = WHITE_BALANCE_SUNNY;
+        else if (!strcmp(new_white_str,
+                         CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT))
+            new_white = WHITE_BALANCE_CLOUDY;
+        else if (!strcmp(new_white_str,
+                         CameraParameters::WHITE_BALANCE_FLUORESCENT))
+            new_white = WHITE_BALANCE_FLUORESCENT;
+        else if (!strcmp(new_white_str,
+                         CameraParameters::WHITE_BALANCE_INCANDESCENT))
+            new_white = WHITE_BALANCE_TUNGSTEN;
+        else {
+            LOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent
+            ret = UNKNOWN_ERROR;
+        }
+
+        if (0 <= new_white) {
+            if (mSecCamera->setWhiteBalance(new_white) < 0) {
+                LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white);
+                ret = UNKNOWN_ERROR;
+            } else {
+                mParameters.set(CameraParameters::KEY_WHITE_BALANCE, new_white_str);
+            }
         }
     }
 
     // scene mode
     const char *new_scene_mode_str = params.get(CameraParameters::KEY_SCENE_MODE);
 
-    LOGV("%s : new_scene_mode_str %s", __func__,new_scene_mode_str);
+    LOGV("%s : new_scene_mode_str %s", __func__, new_scene_mode_str);
 
     if (new_scene_mode_str != NULL) {
         int  new_scene_mode = -1;
 
-        const char *new_iso_str = NULL;
-        const char *new_metering_str = NULL;
-        int new_exposure_compensation = 0;
-        const char *new_white_str = NULL;
-        int new_sharpness = 0;
-        int new_saturation = 0;
-        const char *new_focus_mode_str = NULL;
-        const char *new_flash_mode_str = NULL;
+        const char *new_flash_mode_str = params.get(CameraParameters::KEY_FLASH_MODE);
+        const char *new_focus_mode_str;
+
+        if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) {
+            new_focus_mode_str = params.get(CameraParameters::KEY_FOCUS_MODE);
+        } else {
+            new_focus_mode_str = NULL;
+        }
 
         if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_AUTO)) {
             new_scene_mode = SCENE_MODE_NONE;
-
         } else {
-            // defaults for the scene modes
-            mInternalParameters.set("iso", "auto");
-            mInternalParameters.set("metering", "center");
-            mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
-                            EV_DEFAULT);
-            mParameters.set(CameraParameters::KEY_WHITE_BALANCE,
-                            CameraParameters::WHITE_BALANCE_AUTO);
-            mInternalParameters.set("sharpness", SHARPNESS_DEFAULT);
-            mInternalParameters.set("saturation", SATURATION_DEFAULT);
-            if (new_camera_id == SecCamera::CAMERA_ID_BACK) {
-                mParameters.set(CameraParameters::KEY_FOCUS_MODE,
-                                CameraParameters::FOCUS_MODE_AUTO);
+            // defaults for non-auto scene modes
+            if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) {
+                new_focus_mode_str = CameraParameters::FOCUS_MODE_AUTO;
             }
+            new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
+            mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)");
             mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
-                            "7500,30000");
+                            "15000,30000");
 
             if (!strcmp(new_scene_mode_str,
                        CameraParameters::SCENE_MODE_PORTRAIT)) {
                 new_scene_mode = SCENE_MODE_PORTRAIT;
-
-                mInternalParameters.set("sharpness", SHARPNESS_MINUS_1);
+                new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO;
             } else if (!strcmp(new_scene_mode_str,
                                CameraParameters::SCENE_MODE_LANDSCAPE)) {
                 new_scene_mode = SCENE_MODE_LANDSCAPE;
-
-                mInternalParameters.set("metering", "matrix");
-                mInternalParameters.set("sharpness", SHARPNESS_PLUS_1);
-                mInternalParameters.set("saturation", SATURATION_PLUS_1);
-                mParameters.set(CameraParameters::KEY_FLASH_MODE,
-                                CameraParameters::FLASH_MODE_OFF);
             } else if (!strcmp(new_scene_mode_str,
                                CameraParameters::SCENE_MODE_SPORTS)) {
                 new_scene_mode = SCENE_MODE_SPORTS;
-
-                mInternalParameters.set("iso", "sports");
-                mParameters.set(CameraParameters::KEY_FLASH_MODE,
-                                CameraParameters::FLASH_MODE_OFF);
             } else if (!strcmp(new_scene_mode_str,
                                CameraParameters::SCENE_MODE_PARTY)) {
                 new_scene_mode = SCENE_MODE_PARTY_INDOOR;
-
-                mInternalParameters.set("iso", "200");
-                mInternalParameters.set("saturation", SATURATION_PLUS_1);
+                new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO;
             } else if ((!strcmp(new_scene_mode_str,
                                 CameraParameters::SCENE_MODE_BEACH)) ||
                         (!strcmp(new_scene_mode_str,
                                  CameraParameters::SCENE_MODE_SNOW))) {
                 new_scene_mode = SCENE_MODE_BEACH_SNOW;
-
-                mInternalParameters.set("iso", "50");
-                mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
-                                EV_PLUS_2);
-                mInternalParameters.set("saturation", SATURATION_PLUS_1);
-                mParameters.set(CameraParameters::KEY_FLASH_MODE,
-                                CameraParameters::FLASH_MODE_OFF);
             } else if (!strcmp(new_scene_mode_str,
                                CameraParameters::SCENE_MODE_SUNSET)) {
                 new_scene_mode = SCENE_MODE_SUNSET;
-
-                mParameters.set(CameraParameters::KEY_WHITE_BALANCE,
-                                CameraParameters::WHITE_BALANCE_DAYLIGHT);
-                mParameters.set(CameraParameters::KEY_FLASH_MODE,
-                                CameraParameters::FLASH_MODE_OFF);
             } else if (!strcmp(new_scene_mode_str,
                                CameraParameters::SCENE_MODE_NIGHT)) {
                 new_scene_mode = SCENE_MODE_NIGHTSHOT;
+                mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(4000,30000)");
                 mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
-                                "3780,30000");
-
-                mInternalParameters.set("iso", "night");
-                mParameters.set(CameraParameters::KEY_FLASH_MODE,
-                                CameraParameters::FLASH_MODE_OFF);
+                                "4000,30000");
             } else if (!strcmp(new_scene_mode_str,
                                CameraParameters::SCENE_MODE_FIREWORKS)) {
                 new_scene_mode = SCENE_MODE_FIREWORKS;
-
-                mInternalParameters.set("iso", "50");
-                mParameters.set(CameraParameters::KEY_FLASH_MODE,
-                                CameraParameters::FLASH_MODE_OFF);
             } else if (!strcmp(new_scene_mode_str,
                                CameraParameters::SCENE_MODE_CANDLELIGHT)) {
                 new_scene_mode = SCENE_MODE_CANDLE_LIGHT;
-
-                mParameters.set(CameraParameters::KEY_WHITE_BALANCE,
-                                CameraParameters::WHITE_BALANCE_DAYLIGHT);
-                mParameters.set(CameraParameters::KEY_FLASH_MODE,
-                                CameraParameters::FLASH_MODE_OFF);
             } else {
                 LOGE("%s::unmatched scene_mode(%s)",
                         __func__, new_scene_mode_str); //action, night-portrait, theatre, steadyphoto
                 ret = UNKNOWN_ERROR;
             }
         }
-        new_iso_str = mInternalParameters.get("iso");
-        new_metering_str = mInternalParameters.get("metering");
-        new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
-        new_white_str = params.get(CameraParameters::KEY_WHITE_BALANCE);
-        new_sharpness = mInternalParameters.getInt("sharpness");
-        new_saturation = mInternalParameters.getInt("saturation");
-        if (new_camera_id == SecCamera::CAMERA_ID_BACK) {
-            new_focus_mode_str = params.get(CameraParameters::KEY_FOCUS_MODE);
-        }
-        new_flash_mode_str = params.get(CameraParameters::KEY_FLASH_MODE);
-
-        // 1. ISO
-        if (new_iso_str != NULL) {
-            int  new_iso = -1;
-            if (!strcmp(new_iso_str, "auto"))
-                new_iso = ISO_AUTO;
-            else if (!strcmp(new_iso_str, "50"))
-                new_iso = ISO_50;
-            else if (!strcmp(new_iso_str, "100"))
-                new_iso = ISO_100;
-            else if (!strcmp(new_iso_str, "200"))
-                new_iso = ISO_200;
-            else if (!strcmp(new_iso_str, "400"))
-                new_iso = ISO_400;
-            else if (!strcmp(new_iso_str, "800"))
-                new_iso = ISO_800;
-            else if (!strcmp(new_iso_str, "1600"))
-                new_iso = ISO_1600;
-            else if (!strcmp(new_iso_str, "sports"))
-                new_iso = ISO_SPORTS;
-            else if (!strcmp(new_iso_str, "night"))
-                new_iso = ISO_NIGHT;
-            else if (!strcmp(new_iso_str, "movie"))
-                new_iso = ISO_MOVIE;
-            else {
-                LOGE("%s::unmatched iso(%d)", __func__, new_iso);
-                ret = UNKNOWN_ERROR;
-            }
-
-           if (0 <= new_iso) {
-                if (mSecCamera->setISO(new_iso) < 0) {
-                    LOGE("%s::mSecCamera->setISO(%d) fail", __func__, new_iso);
-                    ret = UNKNOWN_ERROR;
-                }
-            }
-        }
-
-        // 2. metering
-        if (new_metering_str != NULL) {
-            int  new_metering = -1;
-            if (!strcmp(new_metering_str, "matrix"))
-                new_metering = METERING_MATRIX;
-            else if (!strcmp(new_metering_str, "center"))
-                new_metering = METERING_CENTER;
-            else if (!strcmp(new_metering_str, "spot"))
-                new_metering = METERING_SPOT;
-            else {
-                LOGE("%s::unmatched metering(%s)", __func__, new_metering_str);
-                ret = UNKNOWN_ERROR;
-            }
-            if (0 <= new_metering) {
-                if (mSecCamera->setMetering(new_metering) < 0) {
-                    LOGE("%s::mSecCamera->setMetering(%d) fail", __func__, new_metering);
-                    ret = UNKNOWN_ERROR;
-                }
-            }
-        }
-
-        // 3. brightness
-        int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION);
-        int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION);
-
-        if ((min_exposure_compensation <= new_exposure_compensation) &&
-            (max_exposure_compensation >= new_exposure_compensation)) {
-            if (mSecCamera->setBrightness(new_exposure_compensation) < 0) {
-                LOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_exposure_compensation);
-                ret = UNKNOWN_ERROR;
-            }
-        }
 
-        // 4. whitebalance
-        if (new_white_str != NULL) {
-            int new_white = -1;
-
-            if (!strcmp(new_white_str, CameraParameters::WHITE_BALANCE_AUTO))
-                new_white = WHITE_BALANCE_AUTO;
-            else if (!strcmp(new_white_str,
-                             CameraParameters::WHITE_BALANCE_DAYLIGHT))
-                new_white = WHITE_BALANCE_SUNNY;
-            else if (!strcmp(new_white_str,
-                             CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT))
-                new_white = WHITE_BALANCE_CLOUDY;
-            else if (!strcmp(new_white_str,
-                             CameraParameters::WHITE_BALANCE_FLUORESCENT))
-                new_white = WHITE_BALANCE_FLUORESCENT;
-            else if (!strcmp(new_white_str,
-                             CameraParameters::WHITE_BALANCE_INCANDESCENT))
-                new_white = WHITE_BALANCE_TUNGSTEN;
-            else {
-                LOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent
-                ret = UNKNOWN_ERROR;
-            }
-
-            if (0 <= new_white) {
-                // white_balance
-                if (mSecCamera->setWhiteBalance(new_white) < 0) {
-                    LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white);
-                    ret = UNKNOWN_ERROR;
-                }
-            }
-        }
-
-        //5. sharpness
-        if (0 <= new_sharpness) {
-            if (mSecCamera->setSharpness(new_sharpness) < 0) {
-                LOGE("ERR(%s):Fail on mSecCamera->setSharpness(%d)", __func__,new_sharpness);
-                ret = UNKNOWN_ERROR;
-            }
-        }
-
-        //6. saturation
-        if (0 <= new_saturation) {
-            if (mSecCamera->setSaturation(new_saturation) < 0) {
-                LOGE("ERR(%s):Fail on mSecCamera->setSaturation(%d)", __func__, new_saturation);
-                ret = UNKNOWN_ERROR;
-            }
-        }
-
-        // 7. focus mode
+        // focus mode
         if (new_focus_mode_str != NULL) {
             int  new_focus_mode = -1;
 
             if (!strcmp(new_focus_mode_str,
                         CameraParameters::FOCUS_MODE_AUTO)) {
-                new_focus_mode = FOCUS_MODE_AUTO; 
+                new_focus_mode = FOCUS_MODE_AUTO;
                 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
                                 BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
             }
@@ -1928,11 +1800,13 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
                 if (mSecCamera->setFocusMode(new_focus_mode) < 0) {
                     LOGE("%s::mSecCamera->setFocusMode(%d) fail", __func__, new_focus_mode);
                     ret = UNKNOWN_ERROR;
+                } else {
+                    mParameters.set(CameraParameters::KEY_FOCUS_MODE, new_focus_mode_str);
                 }
             }
         }
 
-        //  8. flash..
+        // flash..
         if (new_flash_mode_str != NULL) {
             int  new_flash_mode = -1;
 
@@ -1952,21 +1826,42 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
                 if (mSecCamera->setFlashMode(new_flash_mode) < 0) {
                     LOGE("%s::mSecCamera->setFlashMode(%d) fail", __func__, new_flash_mode);
                     ret = UNKNOWN_ERROR;
+                } else {
+                    mParameters.set(CameraParameters::KEY_FLASH_MODE, new_flash_mode_str);
                 }
             }
         }
 
-        //  9. scene..
+        //  scene..
         if (0 <= new_scene_mode) {
             if (mSecCamera->setSceneMode(new_scene_mode) < 0) {
                 LOGE("%s::mSecCamera->setSceneMode(%d) fail", __func__, new_scene_mode);
                 ret = UNKNOWN_ERROR;
+            } else {
+                mParameters.set(CameraParameters::KEY_SCENE_MODE, new_scene_mode_str);
             }
         }
     }
 
     // ---------------------------------------------------------------------------
 
+    // fps range
+    int new_min_fps = 0;
+    int new_max_fps = 0;
+    int current_min_fps, current_max_fps;
+    params.getPreviewFpsRange(&new_min_fps, &new_max_fps);
+    mParameters.getPreviewFpsRange(&current_min_fps, &current_max_fps);
+    /* our fps range is determined by the sensor, reject any request
+     * that isn't exactly what we're already at.
+     */
+    if ((new_min_fps != current_min_fps) || (new_max_fps != current_max_fps)) {
+        LOGW("%s : requested new_min_fps = %d, new_max_fps = %d not allowed",
+             __func__, new_min_fps, new_max_fps);
+        LOGE("%s : current_min_fps = %d, current_max_fps = %d",
+             __func__, current_min_fps, current_max_fps);
+        ret = UNKNOWN_ERROR;
+    }
+
     // image effect
     const char *new_image_effect_str = params.get(CameraParameters::KEY_EFFECT);
     if (new_image_effect_str != NULL) {
@@ -1993,35 +1888,19 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
             if (mSecCamera->setImageEffect(new_image_effect) < 0) {
                 LOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __func__, new_image_effect);
                 ret = UNKNOWN_ERROR;
+            } else {
+                mParameters.set(CameraParameters::KEY_EFFECT, new_image_effect_str);
             }
         }
     }
 
-    //antiBanding
-    const char *new_antibanding_str = params.get(CameraParameters::KEY_ANTIBANDING);
-
-    if (new_antibanding_str != NULL) {
-        int new_antibanding = -1;
-
-        if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_AUTO))
-            new_antibanding = ANTI_BANDING_AUTO;
-        else if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_50HZ))
-            new_antibanding = ANTI_BANDING_50HZ;
-        else if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_60HZ))
-            new_antibanding = ANTI_BANDING_60HZ;
-        else if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_OFF))
-            new_antibanding = ANTI_BANDING_OFF;
-        else {
-            LOGE("%s::unmatched antibanding(%s)", __func__, new_antibanding_str);
+    //vt mode
+    int new_vtmode = mInternalParameters.getInt("vtmode");
+    if (0 <= new_vtmode) {
+        if (mSecCamera->setVTmode(new_vtmode) < 0) {
+            LOGE("ERR(%s):Fail on mSecCamera->setVTMode(%d)", __func__, new_vtmode);
             ret = UNKNOWN_ERROR;
         }
-
-        if (0 <= new_antibanding) {
-            if (mSecCamera->setAntiBanding(new_antibanding) < 0) {
-                LOGE("%s::mSecCamera->setAntiBanding(%d) fail", __func__, new_antibanding);
-                ret = UNKNOWN_ERROR;
-            }
-        }
     }
 
     //contrast
@@ -2056,18 +1935,29 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
 
     // gps latitude
     const char *new_gps_latitude_str = params.get(CameraParameters::KEY_GPS_LATITUDE);
-
     if (mSecCamera->setGPSLatitude(new_gps_latitude_str) < 0) {
         LOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __func__, new_gps_latitude_str);
         ret = UNKNOWN_ERROR;
+    } else {
+        if (new_gps_latitude_str) {
+            mParameters.set(CameraParameters::KEY_GPS_LATITUDE, new_gps_latitude_str);
+        } else {
+            mParameters.remove(CameraParameters::KEY_GPS_LATITUDE);
+        }
     }
 
     // gps longitude
-    const char *new_gps_longitute_str = params.get(CameraParameters::KEY_GPS_LONGITUDE);
+    const char *new_gps_longitude_str = params.get(CameraParameters::KEY_GPS_LONGITUDE);
 
-    if (mSecCamera->setGPSLongitude(new_gps_longitute_str) < 0) {
-        LOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitute_str);
+    if (mSecCamera->setGPSLongitude(new_gps_longitude_str) < 0) {
+        LOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitude_str);
         ret = UNKNOWN_ERROR;
+    } else {
+        if (new_gps_longitude_str) {
+            mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, new_gps_longitude_str);
+        } else {
+            mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE);
+        }
     }
 
     // gps altitude
@@ -2076,6 +1966,12 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
     if (mSecCamera->setGPSAltitude(new_gps_altitude_str) < 0) {
         LOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __func__, new_gps_altitude_str);
         ret = UNKNOWN_ERROR;
+    } else {
+        if (new_gps_altitude_str) {
+            mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, new_gps_altitude_str);
+        } else {
+            mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE);
+        }
     }
 
     // gps timestamp
@@ -2084,11 +1980,31 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
     if (mSecCamera->setGPSTimeStamp(new_gps_timestamp_str) < 0) {
         LOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __func__, new_gps_timestamp_str);
         ret = UNKNOWN_ERROR;
+    } else {
+        if (new_gps_timestamp_str) {
+            mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, new_gps_timestamp_str);
+        } else {
+            mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP);
+        }
+    }
+
+    // gps processing method
+    const char *new_gps_processing_method_str = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
+
+    if (mSecCamera->setGPSProcessingMethod(new_gps_processing_method_str) < 0) {
+        LOGE("%s::mSecCamera->setGPSProcessingMethod(%s) fail", __func__, new_gps_processing_method_str);
+        ret = UNKNOWN_ERROR;
+    } else {
+        if (new_gps_processing_method_str) {
+            mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, new_gps_processing_method_str);
+        } else {
+            mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD);
+        }
     }
 
     // Recording size
-    int new_recording_width = params.getInt("recording-size-width");
-    int new_recording_height= params.getInt("recording-size-height");
+    int new_recording_width = mInternalParameters.getInt("recording-size-width");
+    int new_recording_height= mInternalParameters.getInt("recording-size-height");
 
     if (0 < new_recording_width && 0 < new_recording_height) {
         if (mSecCamera->setRecordingSize(new_recording_width, new_recording_height) < 0) {
@@ -2191,6 +2107,7 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
             ret = UNKNOWN_ERROR;
         }
     }
+    LOGV("%s return ret = %d", __func__, ret);
 
     return ret;
 }