don't use globel mVideoinfo->buf to control the V4L2 in two thread

4 files changed, 507 insertions, 535 deletions

diff --git a/ANativeWindowDisplayAdapter.cpp b/ANativeWindowDisplayAdapter.cpp
index 65765bf..7df64b1 100755
--- a/ANativeWindowDisplayAdapter.cpp
+++ b/ANativeWindowDisplayAdapter.cpp
@@ -209,7 +209,7 @@ status_t ANativeWindowDisplayAdapter::initialize()
     ///Create the display thread
     mDisplayThread = new DisplayThread(this);
     if ( !mDisplayThread.get() )
-        {
+    {
         CAMHAL_LOGEA("Couldn't create display thread");
         LOG_FUNCTION_NAME_EXIT;
         return NO_MEMORY;
@@ -218,7 +218,7 @@ status_t ANativeWindowDisplayAdapter::initialize()
     ///Start the display thread
     status_t ret = mDisplayThread->run("DisplayThread", PRIORITY_URGENT_DISPLAY);
     if ( ret != NO_ERROR )
-        {
+    {
         CAMHAL_LOGEA("Couldn't run display thread");
         LOG_FUNCTION_NAME_EXIT;
         return ret;
@@ -234,7 +234,7 @@ int ANativeWindowDisplayAdapter::setPreviewWindow(preview_stream_ops_t* window)
     LOG_FUNCTION_NAME;
     ///Note that Display Adapter cannot work without a valid window object
     if ( !window)
-        {
+    {
         CAMHAL_LOGEA("NULL window object passed to DisplayAdapter");
         LOG_FUNCTION_NAME_EXIT;
         return BAD_VALUE;
@@ -284,13 +284,13 @@ int ANativeWindowDisplayAdapter::setErrorHandler(ErrorNotifier *errorNotifier)
     LOG_FUNCTION_NAME;
 
     if ( NULL == errorNotifier )
-        {
+    {
         CAMHAL_LOGEA("Invalid Error Notifier reference");
         ret = -EINVAL;
     }
 
     if ( NO_ERROR == ret )
-        {
+    {
         mErrorNotifier = errorNotifier;
     }
 
@@ -308,7 +308,7 @@ status_t ANativeWindowDisplayAdapter::setSnapshotTimeRef(struct timeval *refTime
     LOG_FUNCTION_NAME;
 
     if ( NULL != refTime )
-        {
+    {
         Mutex::Autolock lock(mLock);
         memcpy(&mStartCapture, refTime, sizeof(struct timeval));
     }
@@ -329,7 +329,7 @@ int ANativeWindowDisplayAdapter::enableDisplay(int width, int height, struct tim
     LOG_FUNCTION_NAME;
 
     if ( mDisplayEnabled )
-        {
+    {
         CAMHAL_LOGDA("Display is already enabled");
         LOG_FUNCTION_NAME_EXIT;
 
@@ -345,7 +345,7 @@ int ANativeWindowDisplayAdapter::enableDisplay(int width, int height, struct tim
 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
 
     if ( NULL != refTime )
-        {
+    {
         Mutex::Autolock lock(mLock);
         memcpy(&mStandbyToShot, refTime, sizeof(struct timeval));
         mMeasureStandby = true;
@@ -388,7 +388,7 @@ int ANativeWindowDisplayAdapter::disableDisplay(bool cancel_buffer)
     LOG_FUNCTION_NAME;
 
     if(!mDisplayEnabled)
-        {
+    {
         CAMHAL_LOGDA("Display is already disabled");
         LOG_FUNCTION_NAME_EXIT;
         return ALREADY_EXISTS;
@@ -399,7 +399,7 @@ int ANativeWindowDisplayAdapter::disableDisplay(bool cancel_buffer)
     mFrameProvider->removeFramePointers();
 
     if ( NULL != mDisplayThread.get() )
-        {
+    {
         //Send STOP_DISPLAY COMMAND to display thread. Display thread will stop and dequeue all messages
         // and then wait for message
         Semaphore sem;
@@ -434,19 +434,17 @@ int ANativeWindowDisplayAdapter::disableDisplay(bool cancel_buffer)
         mPreviewWidth = 0;
         mPreviewHeight = 0;
 
-       if(cancel_buffer)
+        if(cancel_buffer)
         {
-        // Return the buffers to ANativeWindow here, the mFramesWithCameraAdapterMap is also cleared inside
-        returnBuffersToWindow();
+            // Return the buffers to ANativeWindow here, the mFramesWithCameraAdapterMap is also cleared inside
+            returnBuffersToWindow();
         }
-       else
+        else
         {
-        mANativeWindow = NULL;
-        // Clear the frames with camera adapter map
-        mFramesWithCameraAdapterMap.clear();
+            mANativeWindow = NULL;
+            // Clear the frames with camera adapter map
+            mFramesWithCameraAdapterMap.clear();
         }
-
-
     }
     LOG_FUNCTION_NAME_EXIT;
 
@@ -777,35 +775,36 @@ status_t ANativeWindowDisplayAdapter::returnBuffersToWindow()
 {
     status_t ret = NO_ERROR;
 
-     GraphicBufferMapper &mapper = GraphicBufferMapper::get();
+    GraphicBufferMapper &mapper = GraphicBufferMapper::get();
     //Give the buffers back to display here -  sort of free it
-     if (mANativeWindow)
-         for(unsigned int i = 0; i < mFramesWithCameraAdapterMap.size(); i++) {
-             int value = mFramesWithCameraAdapterMap.valueAt(i);
-
-             // unlock buffer before giving it up
-             mapper.unlock((buffer_handle_t) mGrallocHandleMap[value]);
-
-             ret = mANativeWindow->cancel_buffer(mANativeWindow, mBufferHandleMap[value]);
-             if ( ENODEV == ret ) {
-                 CAMHAL_LOGEA("Preview surface abandoned!");
-                 mANativeWindow = NULL;
-                 return -ret;
-             } else if ( NO_ERROR != ret ) {
-                 CAMHAL_LOGEB("cancel_buffer() failed: %s (%d)",
+    if (mANativeWindow)
+    {
+        for(unsigned int i = 0; i < mFramesWithCameraAdapterMap.size(); i++) {
+            int value = mFramesWithCameraAdapterMap.valueAt(i);
+
+            // unlock buffer before giving it up
+            mapper.unlock((buffer_handle_t) mGrallocHandleMap[value]);
+
+            ret = mANativeWindow->cancel_buffer(mANativeWindow, mBufferHandleMap[value]);
+            if ( ENODEV == ret ) {
+                CAMHAL_LOGEA("Preview surface abandoned!");
+                mANativeWindow = NULL;
+                return -ret;
+            } else if ( NO_ERROR != ret ) {
+                CAMHAL_LOGEB("cancel_buffer() failed: %s (%d)",
                               strerror(-ret),
                               -ret);
                 return -ret;
-             }
-         }
-     else
-         LOGE("mANativeWindow is NULL");
-
-     ///Clear the frames with camera adapter map
-     mFramesWithCameraAdapterMap.clear();
-
-     return ret;
+            }
+        }
+    }
+    else{
+        LOGE("mANativeWindow is NULL");
+    }
+    ///Clear the frames with camera adapter map
+    mFramesWithCameraAdapterMap.clear();
 
+    return ret;
 }
 
 int ANativeWindowDisplayAdapter::freeBuffer(void* buf)
@@ -875,33 +874,32 @@ void ANativeWindowDisplayAdapter::displayThread()
     LOG_FUNCTION_NAME;
 
     while(shouldLive)
-        {
+    {
         ret = TIUTILS::MessageQueue::waitForMsg(&mDisplayThread->msgQ()
                                                                 ,  &mDisplayQ
                                                                 , NULL
                                                                 , ANativeWindowDisplayAdapter::DISPLAY_TIMEOUT);
 
         if ( !mDisplayThread->msgQ().isEmpty() )
-            {
+        {
             ///Received a message from CameraHal, process it
             shouldLive = processHalMsg();
 
-            }
+        }
         else  if( !mDisplayQ.isEmpty())
-            {
+        {
             if ( mDisplayState== ANativeWindowDisplayAdapter::DISPLAY_INIT )
-                {
-
+            {
                 ///If display adapter is not started, continue
                 continue;
 
-                }
+            }
             else
-                {
+            {
                 TIUTILS::Message msg;
                 ///Get the dummy msg from the displayQ
                 if(mDisplayQ.get(&msg)!=NO_ERROR)
-                    {
+                {
                     CAMHAL_LOGEA("Error in getting message from display Q");
                     continue;
                 }
@@ -914,7 +912,7 @@ void ANativeWindowDisplayAdapter::displayThread()
                 }
 
                 if (mDisplayState == ANativeWindowDisplayAdapter::DISPLAY_EXITED)
-                    {
+                {
                     ///we exit the thread even though there are frames still to dequeue. They will be dequeued
                     ///in disableDisplay
                     shouldLive = false;
@@ -938,28 +936,20 @@ bool ANativeWindowDisplayAdapter::processHalMsg()
     bool ret = true, invalidCommand = false;
 
     switch ( msg.command )
-        {
-
+    {
         case DisplayThread::DISPLAY_START:
-
             CAMHAL_LOGDA("Display thread received DISPLAY_START command from Camera HAL");
             mDisplayState = ANativeWindowDisplayAdapter::DISPLAY_STARTED;
-
             break;
-
         case DisplayThread::DISPLAY_STOP:
-
             ///@bug There is no API to disable SF without destroying it
             ///@bug Buffers might still be w/ display and will get displayed
             ///@remarks Ideal seqyence should be something like this
             ///mOverlay->setParameter("enabled", false);
             CAMHAL_LOGDA("Display thread received DISPLAY_STOP command from Camera HAL");
             mDisplayState = ANativeWindowDisplayAdapter::DISPLAY_STOPPED;
-
             break;
-
         case DisplayThread::DISPLAY_EXIT:
-
             CAMHAL_LOGDA("Display thread received DISPLAY_EXIT command from Camera HAL.");
             CAMHAL_LOGDA("Stopping display thread...");
             mDisplayState = ANativeWindowDisplayAdapter::DISPLAY_EXITED;
@@ -968,28 +958,21 @@ bool ANativeWindowDisplayAdapter::processHalMsg()
             ///This is to ensure that the user experience is not impacted
             ret = false;
             break;
-
         default:
-
             CAMHAL_LOGEB("Invalid Display Thread Command 0x%x.", msg.command);
             invalidCommand = true;
-
             break;
     }
 
     ///Signal the semaphore if it is sent as part of the message
     if ( ( msg.arg1 ) && ( !invalidCommand ) )
-        {
-
+    {
         CAMHAL_LOGDA("+Signalling display semaphore");
         Semaphore &sem = *((Semaphore*)msg.arg1);
-
         sem.Signal();
-
         CAMHAL_LOGDA("-Signalling display semaphore");
     }
 
-
     LOG_FUNCTION_NAME_EXIT;
     return ret;
 }
@@ -1015,9 +998,9 @@ status_t ANativeWindowDisplayAdapter::PostFrame(ANativeWindowDisplayAdapter::Dis
     }
 
     for ( i = 0; i < mBufferCount; i++ )
-        {
+    {
         if ( ((int) dispFrame.mBuffer ) == (int)mGrallocHandleMap[i] )
-            {
+        {
             break;
         }
     }
@@ -1084,17 +1067,17 @@ status_t ANativeWindowDisplayAdapter::PostFrame(ANativeWindowDisplayAdapter::Dis
 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
 
         if ( mMeasureStandby )
-            {
+        {
             CameraHal::PPM("Standby to first shot: Sensor Change completed - ", &mStandbyToShot);
             mMeasureStandby = false;
-            }
+        }
         else if (CameraFrame::CameraFrame::SNAPSHOT_FRAME == dispFrame.mType)
-            {
+        {
             CameraHal::PPM("Shot to snapshot: ", &mStartCapture);
             mShotToShot = true;
-            }
+        }
         else if ( mShotToShot )
-            {
+        {
             CameraHal::PPM("Shot to shot: ", &mStartCapture);
             mShotToShot = false;
         }
@@ -1180,14 +1163,14 @@ bool ANativeWindowDisplayAdapter::handleFrameReturn()
 
     int lock_try_count = 0;
     while (mapper.lock((buffer_handle_t) mGrallocHandleMap[i], CAMHAL_GRALLOC_USAGE, bounds, y_uv) < 0){
-      if (++lock_try_count > LOCK_BUFFER_TRIES){
-        if ( NULL != mErrorNotifier.get() ){
-          mErrorNotifier->errorNotify(CAMERA_ERROR_UNKNOWN);
+        if (++lock_try_count > LOCK_BUFFER_TRIES){
+            if ( NULL != mErrorNotifier.get() ){
+                mErrorNotifier->errorNotify(CAMERA_ERROR_UNKNOWN);
+            }
+            return false;
         }
-        return false;
-      }
-      CAMHAL_LOGEA("Gralloc Lock FrameReturn Error: Sleeping 15ms");
-      usleep(15000);
+        CAMHAL_LOGEA("Gralloc Lock FrameReturn Error: Sleeping 15ms");
+        usleep(15000);
     }
 
     mFramesWithCameraAdapterMap.add((int) mGrallocHandleMap[i], i);
@@ -1201,22 +1184,21 @@ void ANativeWindowDisplayAdapter::frameCallbackRelay(CameraFrame* caFrame)
 {
 
     if ( NULL != caFrame )
-        {
+    {
         if ( NULL != caFrame->mCookie )
-            {
+        {
             ANativeWindowDisplayAdapter *da = (ANativeWindowDisplayAdapter*) caFrame->mCookie;
             da->frameCallback(caFrame);
         }
         else
-            {
+        {
             CAMHAL_LOGEB("Invalid Cookie in Camera Frame = %p, Cookie = %p", caFrame, caFrame->mCookie);
-            }
         }
+    }
     else
-        {
+    {
         CAMHAL_LOGEB("Invalid Camera Frame = %p", caFrame);
     }
-
 }
 
 void ANativeWindowDisplayAdapter::frameCallback(CameraFrame* caFrame)
diff --git a/BaseCameraAdapter.cpp b/BaseCameraAdapter.cpp
index 9a37b06..9d34c61 100755
--- a/BaseCameraAdapter.cpp
+++ b/BaseCameraAdapter.cpp
@@ -358,25 +358,25 @@ status_t BaseCameraAdapter::sendCommand(CameraCommands operation, int value1, in
                     mPreviewBuffersLength = desc->mLength;
                     mPreviewBuffersAvailable.clear();
                     for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
-                        {
+                    {
                         mPreviewBuffersAvailable.add(mPreviewBuffers[i], 0);
-                        }
+                    }
                     // initial ref count for undeqeueued buffers is 1 since buffer provider
                     // is still holding on to it
                     for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
-                        {
+                    {
                         mPreviewBuffersAvailable.add(mPreviewBuffers[i], 1);
-                        }
                     }
+                }
 
                 if ( NULL != desc )
-                    {
+                {
                     ret = useBuffers(CameraAdapter::CAMERA_PREVIEW,
                                      desc->mBuffers,
                                      desc->mCount,
                                      desc->mLength,
                                      desc->mMaxQueueable);
-                    }
+                }
 
                 if ( ret == NO_ERROR )
                     {
diff --git a/CameraHal.cpp b/CameraHal.cpp
index 60b7c54..0c39861 100755
--- a/CameraHal.cpp
+++ b/CameraHal.cpp
@@ -48,31 +48,31 @@ namespace android {
 
 int SYS_enable_colorkey(short key_rgb565)
 {
-	int ret = -1;
-	int fd_fb0 = open("/dev/graphics/fb0", O_RDWR);
-	if (fd_fb0 >= 0)
-	{
-		uint32_t myKeyColor = key_rgb565;
-		uint32_t myKeyColor_en = 1;
-		printf("enablecolorkey color=%#x\n", myKeyColor);
-		ret = ioctl(fd_fb0, FBIOPUT_OSD_SRCCOLORKEY, &myKeyColor);
-		ret += ioctl(fd_fb0, FBIOPUT_OSD_SRCKEY_ENABLE, &myKeyColor_en);
-		close(fd_fb0);
-	}
-	return ret;
+    int ret = -1;
+    int fd_fb0 = open("/dev/graphics/fb0", O_RDWR);
+    if (fd_fb0 >= 0)
+    {
+        uint32_t myKeyColor = key_rgb565;
+        uint32_t myKeyColor_en = 1;
+        printf("enablecolorkey color=%#x\n", myKeyColor);
+        ret = ioctl(fd_fb0, FBIOPUT_OSD_SRCCOLORKEY, &myKeyColor);
+        ret += ioctl(fd_fb0, FBIOPUT_OSD_SRCKEY_ENABLE, &myKeyColor_en);
+        close(fd_fb0);
+    }
+    return ret;
 }
 
 int SYS_disable_colorkey()
 {
-	int ret = -1;
-	int fd_fb0 = open("/dev/graphics/fb0", O_RDWR);
-	if (fd_fb0 >= 0)
-	{
-		uint32_t myKeyColor_en = 0;
-		ret = ioctl(fd_fb0, FBIOPUT_OSD_SRCKEY_ENABLE, &myKeyColor_en);
-		close(fd_fb0);
-	}
-	return ret;
+    int ret = -1;
+    int fd_fb0 = open("/dev/graphics/fb0", O_RDWR);
+    if (fd_fb0 >= 0)
+    {
+        uint32_t myKeyColor_en = 0;
+        ret = ioctl(fd_fb0, FBIOPUT_OSD_SRCKEY_ENABLE, &myKeyColor_en);
+        close(fd_fb0);
+    }
+    return ret;
 }
 
 static void write_sys_int(const char *path, int val)
@@ -83,7 +83,7 @@ static void write_sys_int(const char *path, int val)
     if(fd >= 0) {
         sprintf(cmd, "%d", val);
         write(fd, cmd, strlen(cmd));
-       	close(fd);
+        close(fd);
     }
 }
 
@@ -93,7 +93,7 @@ static void write_sys_string(const char *path, const char *s)
 
     if(fd >= 0) {
         write(fd, s, strlen(s));
-       	close(fd);
+        close(fd);
     }
 }
 
@@ -3005,14 +3005,14 @@ CameraHal::CameraHal(int cameraId)
     mFalsePreview = 0;
     mImageOffsets = NULL;
     mImageLength = 0;
-    mImageFd = 0;
+    mImageFd = -1;
     mVideoOffsets = NULL;
-    mVideoFd = 0;
+    mVideoFd = -1;
     mVideoLength = 0;
     mPreviewDataOffsets = NULL;
-    mPreviewDataFd = 0;
+    mPreviewDataFd = -1;
     mPreviewDataLength = 0;
-    mPreviewFd = 0;
+    mPreviewFd = -1;
     mPreviewWidth = 0;
     mPreviewHeight = 0;
     mPreviewLength = 0;
diff --git a/V4LCameraAdapter/V4LCameraAdapter.cpp b/V4LCameraAdapter/V4LCameraAdapter.cpp
index 6ea2bb4..1f7ca24 100755
--- a/V4LCameraAdapter/V4LCameraAdapter.cpp
+++ b/V4LCameraAdapter/V4LCameraAdapter.cpp
@@ -152,11 +152,11 @@ status_t V4LCameraAdapter::initialize(CameraProperties::Properties* caps)
 	    return -EINVAL;
     }
 
-	if (strcmp(caps->get(CameraProperties::FACING_INDEX), (const char *) android::TICameraParameters::FACING_FRONT) == 0)
-		mbFrontCamera = true;
-	else
-		mbFrontCamera = false;
-	LOGD("mbFrontCamera=%d",mbFrontCamera);
+    if (strcmp(caps->get(CameraProperties::FACING_INDEX), (const char *) android::TICameraParameters::FACING_FRONT) == 0)
+        mbFrontCamera = true;
+    else
+        mbFrontCamera = false;
+    LOGD("mbFrontCamera=%d",mbFrontCamera);
 
     // Initialize flags
     mPreviewing = false;
@@ -176,6 +176,8 @@ status_t V4LCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType
 {
 
     status_t ret = NO_ERROR;
+    v4l2_buffer hbuf_query;
+    memset(&hbuf_query,0,sizeof(v4l2_buffer));
 
     //LOGD("fillThisBuffer frameType=%d", frameType);
     if (CameraFrame::IMAGE_FRAME == frameType)
@@ -200,18 +202,17 @@ status_t V4LCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType
         return BAD_VALUE;
     }
 
-    mVideoInfo->buf.index = i;
-    mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
+    hbuf_query.index = i;
+    hbuf_query.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    hbuf_query.memory = V4L2_MEMORY_MMAP;
 
-    ret = ioctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
+    ret = ioctl(mCameraHandle, VIDIOC_QBUF, &hbuf_query);
     if (ret < 0) {
        CAMHAL_LOGEB("Init: VIDIOC_QBUF %d Failed",i);
        return -1;
     }
-	//CAMHAL_LOGEB("fillThis Buffer %d",i);
-
-    nQueued++;	
+    //CAMHAL_LOGEB("fillThis Buffer %d",i);
+    nQueued++;
     return ret;
 
 }
@@ -223,46 +224,46 @@ status_t V4LCameraAdapter::setParameters(const CameraParameters &params)
     status_t rtn = NO_ERROR;
 
     // Udpate the current parameter set
-	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;
-	}
+    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 rtn;
@@ -291,22 +292,19 @@ status_t V4LCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, si
     Mutex::Autolock lock(mLock);
 
     switch(mode)
-        {
+    {
         case CAMERA_PREVIEW:
             ret = UseBuffersPreview(bufArr, num);
-			maxQueueable = queueable;
+            maxQueueable = queueable;
             break;
-
         case CAMERA_IMAGE_CAPTURE:
             ret = UseBuffersCapture(bufArr, num);
             break;
-
         case CAMERA_VIDEO:
             //@warn Video capture is not fully supported yet
             ret = UseBuffersPreview(bufArr, num);
             break;
-
-        }
+    }
 
     LOG_FUNCTION_NAME_EXIT;
 
@@ -343,9 +341,9 @@ status_t V4LCameraAdapter::UseBuffersPreview(void* bufArr, int num)
     int ret = NO_ERROR;
 
     if(NULL == bufArr)
-        {
+    {
         return BAD_VALUE;
-        }
+    }
 
     int width, height;
     mParams.getPreviewSize(&width, &height);
@@ -398,10 +396,10 @@ status_t V4LCameraAdapter::UseBuffersPreview(void* bufArr, int num)
 
     }
 
-	for(int i = 0;i < num; i++)
-	{
-		mPreviewIdxs.add(mPreviewBufs.valueAt(i),i);
-	}
+    for(int i = 0;i < num; i++)
+    {
+        mPreviewIdxs.add(mPreviewBufs.valueAt(i),i);
+    }
 
     // Update the preview buffer count
     mPreviewBufferCount = num;
@@ -414,14 +412,14 @@ status_t V4LCameraAdapter::UseBuffersCapture(void* bufArr, int num)
     int ret = NO_ERROR;
 
     if(NULL == bufArr)
-        {
+    {
         return BAD_VALUE;
-        }
+    }
 
     if (num != 1)
-        {
+    {
         LOGD("----------------- UseBuffersCapture num=%d", num);
-        }
+    }
 
     /* This will only be called right before taking a picture, so
      * stop preview now so that we can set buffer format here.
@@ -491,54 +489,50 @@ status_t V4LCameraAdapter::takePicture()
 
 status_t V4LCameraAdapter::startPreview()
 {
-	status_t ret = NO_ERROR;
+    status_t ret = NO_ERROR;
 
-	Mutex::Autolock lock(mPreviewBufsLock);
+    Mutex::Autolock lock(mPreviewBufsLock);
 
-	if(mPreviewing)
-	{
-		return BAD_VALUE;
-	}
+    if(mPreviewing)
+    {
+        return BAD_VALUE;
+    }
 
-	writefile(SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
+    writefile(SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
     nQueued = 0;
-	for (int i = 0; i < maxQueueable; i++) 
-	{
-	   mVideoInfo->buf.index = i;
-	   mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-	   mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
-	   ret = ioctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
-	   if (ret < 0) {
-	       CAMHAL_LOGEA("VIDIOC_QBUF Failed");
-	       return -EINVAL;
-	   }
-	   LOGD("startPreview .length=%d", mVideoInfo->buf.length);
-       nQueued++;
-	}
-
-	enum v4l2_buf_type bufType;
-	if (!mVideoInfo->isStreaming) 
-	{
-	   bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-	   ret = ioctl (mCameraHandle, VIDIOC_STREAMON, &bufType);
-	   if (ret < 0) {
-	       CAMHAL_LOGEB("StartStreaming: Unable to start capture: %s", strerror(errno));
-	       return ret;
-	   }
-
-	   mVideoInfo->isStreaming = true;
-	}
-
-	// Create and start preview thread for receiving buffers from V4L Camera
-	mPreviewThread = new PreviewThread(this);
-
-	CAMHAL_LOGDA("Created preview thread");
-
-	//Update the flag to indicate we are previewing
-	mPreviewing = true;
-
-	return ret;
+    for (int i = 0; i < maxQueueable; i++) 
+    {
+        mVideoInfo->buf.index = i;
+	 mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	 mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
+	 ret = ioctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
+	 if (ret < 0) {
+            CAMHAL_LOGEA("VIDIOC_QBUF Failed");
+            return -EINVAL;
+        }
+        LOGD("startPreview .length=%d", mVideoInfo->buf.length);
+        nQueued++;
+    }
+
+    enum v4l2_buf_type bufType;
+    if (!mVideoInfo->isStreaming) 
+    {
+        bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        ret = ioctl (mCameraHandle, VIDIOC_STREAMON, &bufType);
+        if (ret < 0) {
+            CAMHAL_LOGEB("StartStreaming: Unable to start capture: %s", strerror(errno));
+            return ret;
+        }
+
+        mVideoInfo->isStreaming = true;
+    }
+
+    // Create and start preview thread for receiving buffers from V4L Camera
+    mPreviewThread = new PreviewThread(this);
+    CAMHAL_LOGDA("Created preview thread");
+    //Update the flag to indicate we are previewing
+    mPreviewing = true;
+    return ret;
 }
 
 status_t V4LCameraAdapter::stopPreview()
@@ -585,7 +579,7 @@ status_t V4LCameraAdapter::stopPreview()
 
     LOGD("stopPreview clearexit..");
     mPreviewBufs.clear();
-	mPreviewIdxs.clear();
+    mPreviewIdxs.clear();
     return ret;
 
 }
@@ -668,7 +662,7 @@ status_t V4LCameraAdapter::recalculateFPS()
     mFrameCount++;
 
     if ( ( mFrameCount % FPS_PERIOD ) == 0 )
-        {
+    {
         nsecs_t now = systemTime();
         nsecs_t diff = now - mLastFPSTime;
         currentFPS =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
@@ -676,18 +670,18 @@ status_t V4LCameraAdapter::recalculateFPS()
         mLastFrameCount = mFrameCount;
 
         if ( 1 == mIter )
-            {
+        {
             mFPS = currentFPS;
-            }
+        }
         else
-            {
+        {
             //cumulative moving average
             mFPS = mLastFPS + (currentFPS - mLastFPS)/mIter;
-            }
+        }
 
         mLastFPS = mFPS;
         mIter++;
-        }
+    }
 
     return NO_ERROR;
 }
@@ -717,10 +711,10 @@ V4LCameraAdapter::~V4LCameraAdapter()
     close(mCameraHandle);
 
     if (mVideoInfo)
-      {
+    {
         free(mVideoInfo);
         mVideoInfo = NULL;
-      }
+    }
 
     LOG_FUNCTION_NAME_EXIT;
 }
@@ -755,7 +749,7 @@ int V4LCameraAdapter::previewThread()
             return BAD_VALUE;
         }
 
-		uint8_t* dest = NULL;
+        uint8_t* dest = NULL;
 #ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT
         camera_memory_t* VideoCameraBufferMemoryBase = (camera_memory_t*)ptr;
         dest = (uint8_t*)VideoCameraBufferMemoryBase->data; //ptr;
@@ -771,7 +765,7 @@ int V4LCameraAdapter::previewThread()
         frame.mFrameMask |= CameraFrame::PREVIEW_FRAME_SYNC;
         
         if(mRecording){
-       	    frame.mFrameMask |= CameraFrame::VIDEO_FRAME_SYNC;
+            frame.mFrameMask |= CameraFrame::VIDEO_FRAME_SYNC;
         }
         frame.mBuffer = ptr; //dest
         frame.mLength = width*height*3/2;
@@ -798,151 +792,150 @@ int V4LCameraAdapter::GenExif(ExifElementsTable* exiftable)
 {
     char exifcontent[256];
 
-	//Make
+    //Make
     exiftable->insertElement("Make",(const char*)mParams.get(TICameraParameters::KEY_EXIF_MAKE));
 
-	//Model
+    //Model
     exiftable->insertElement("Model",(const char*)mParams.get(TICameraParameters::KEY_EXIF_MODEL));
 
-	//Image orientation
-	int orientation = mParams.getInt(CameraParameters::KEY_ROTATION);
-	//covert 0 90 180 270 to 0 1 2 3
-	LOGE("get orientaion %d",orientation);
-	if(orientation == 0)
-		orientation = 1;
-	else if(orientation == 90)
-		orientation = 6;
-	else if(orientation == 180)
-		orientation = 3;
-	else if(orientation == 270)
-		orientation = 8;
-	sprintf(exifcontent,"%d",orientation);
-	LOGD("exifcontent %s",exifcontent);
+    //Image orientation
+    int orientation = mParams.getInt(CameraParameters::KEY_ROTATION);
+    //covert 0 90 180 270 to 0 1 2 3
+    LOGE("get orientaion %d",orientation);
+    if(orientation == 0)
+        orientation = 1;
+    else if(orientation == 90)
+        orientation = 6;
+    else if(orientation == 180)
+        orientation = 3;
+    else if(orientation == 270)
+        orientation = 8;
+    sprintf(exifcontent,"%d",orientation);
+    LOGD("exifcontent %s",exifcontent);
     exiftable->insertElement("Orientation",(const char*)exifcontent);
 
     //Image width,height
-	int width,height;
-	mParams.getPictureSize(&width,&height);
-	sprintf(exifcontent,"%d",width);
+    int width,height;
+    mParams.getPictureSize(&width,&height);
+    sprintf(exifcontent,"%d",width);
     exiftable->insertElement("ImageWidth",(const char*)exifcontent);
     sprintf(exifcontent,"%d",height);
     exiftable->insertElement("ImageLength",(const char*)exifcontent);
 
-	//focal length  RATIONAL
-	float focallen = mParams.getFloat(CameraParameters::KEY_FOCAL_LENGTH);
+    //focal length  RATIONAL
+    float focallen = mParams.getFloat(CameraParameters::KEY_FOCAL_LENGTH);
     if(focallen >= 0)
     {
-    	int focalNum = focallen*1000;
-    	int focalDen = 1000;
+        int focalNum = focallen*1000;
+        int focalDen = 1000;
         sprintf(exifcontent,"%d/%d",focalNum,focalDen);
         exiftable->insertElement("FocalLength",(const char*)exifcontent);
     }
 
     //datetime of photo
     time_t times;
-	{
-		time_t curtime = 0;
-		time(&curtime);
-		struct tm tmstruct;
-		tmstruct = *(localtime(&times)); //convert to local time
-
-		//date&time
-    	strftime(exifcontent, 30, "%Y:%m:%d %H:%M:%S", &tmstruct);
+    {
+        time_t curtime = 0;
+        time(&curtime);
+        struct tm tmstruct;
+        tmstruct = *(localtime(&times)); //convert to local time
+
+        //date&time
+        strftime(exifcontent, 30, "%Y:%m:%d %H:%M:%S", &tmstruct);
         exiftable->insertElement("DateTime",(const char*)exifcontent);
-	}
+    }
 
     //gps date stamp & time stamp
     times = mParams.getInt(CameraParameters::KEY_GPS_TIMESTAMP);
-	if(times != -1)
-	{
-		struct tm tmstruct;
-		tmstruct = *(gmtime(&times));//convert to standard time
-		//date
-		strftime(exifcontent, 20, "%Y:%m:%d", &tmstruct);
+    if(times != -1)
+    {
+        struct tm tmstruct;
+        tmstruct = *(gmtime(&times));//convert to standard time
+        //date
+        strftime(exifcontent, 20, "%Y:%m:%d", &tmstruct);
         exiftable->insertElement("GPSDateStamp",(const char*)exifcontent);
-		//time
-		sprintf(exifcontent,"%d/%d,%d/%d,%d/%d",tmstruct.tm_hour,1,tmstruct.tm_min,1,tmstruct.tm_sec,1);
+        //time
+        sprintf(exifcontent,"%d/%d,%d/%d,%d/%d",tmstruct.tm_hour,1,tmstruct.tm_min,1,tmstruct.tm_sec,1);
         exiftable->insertElement("GPSTimeStamp",(const char*)exifcontent);
-	}
-
-	//gps latitude info
-	char* latitudestr = (char*)mParams.get(CameraParameters::KEY_GPS_LATITUDE);
-	if(latitudestr!=NULL)
-	{
-		int offset = 0;
-		float latitude = mParams.getFloat(CameraParameters::KEY_GPS_LATITUDE);
-		if(latitude < 0.0)
-		{
-			offset = 1;
-			latitude*= (float)(-1);
-		}
-
-		int latitudedegree = latitude;
-		float latitudeminuts = (latitude-(float)latitudedegree)*60;
-		int latitudeminuts_int = latitudeminuts;
-		float latituseconds = (latitudeminuts-(float)latitudeminuts_int)*60;
-		int latituseconds_int = latituseconds;
-		sprintf(exifcontent,"%d/%d,%d/%d,%d/%d",latitudedegree,1,latitudeminuts_int,1,latituseconds_int,1);
+    }
+
+    //gps latitude info
+    char* latitudestr = (char*)mParams.get(CameraParameters::KEY_GPS_LATITUDE);
+    if(latitudestr!=NULL)
+    {
+        int offset = 0;
+        float latitude = mParams.getFloat(CameraParameters::KEY_GPS_LATITUDE);
+        if(latitude < 0.0)
+        {
+            offset = 1;
+            latitude*= (float)(-1);
+        }
+
+        int latitudedegree = latitude;
+        float latitudeminuts = (latitude-(float)latitudedegree)*60;
+        int latitudeminuts_int = latitudeminuts;
+        float latituseconds = (latitudeminuts-(float)latitudeminuts_int)*60;
+        int latituseconds_int = latituseconds;
+        sprintf(exifcontent,"%d/%d,%d/%d,%d/%d",latitudedegree,1,latitudeminuts_int,1,latituseconds_int,1);
         exiftable->insertElement("GPSLatitude",(const char*)exifcontent);
 
         exiftable->insertElement("GPSLatitudeRef",(offset==1)?"S":"N");
-	}
-
-	//gps Longitude info
-	char* longitudestr = (char*)mParams.get(CameraParameters::KEY_GPS_LONGITUDE);
-	if(longitudestr!=NULL)
-	{
-		int offset = 0;
-		float longitude = mParams.getFloat(CameraParameters::KEY_GPS_LONGITUDE);
-		if(longitude < 0.0)
-		{
-			offset = 1;
-			longitude*= (float)(-1);
-		}
-
-		int longitudedegree = longitude;
-		float longitudeminuts = (longitude-(float)longitudedegree)*60;
-		int longitudeminuts_int = longitudeminuts;
-		float longitudeseconds = (longitudeminuts-(float)longitudeminuts_int)*60;
-		int longitudeseconds_int = longitudeseconds;
-		sprintf(exifcontent,"%d/%d,%d/%d,%d/%d",longitudedegree,1,longitudeminuts_int,1,longitudeseconds_int,1);
+    }
+
+    //gps Longitude info
+    char* longitudestr = (char*)mParams.get(CameraParameters::KEY_GPS_LONGITUDE);
+    if(longitudestr!=NULL)
+    {
+        int offset = 0;
+        float longitude = mParams.getFloat(CameraParameters::KEY_GPS_LONGITUDE);
+        if(longitude < 0.0)
+        {
+            offset = 1;
+            longitude*= (float)(-1);
+        }
+
+        int longitudedegree = longitude;
+        float longitudeminuts = (longitude-(float)longitudedegree)*60;
+        int longitudeminuts_int = longitudeminuts;
+        float longitudeseconds = (longitudeminuts-(float)longitudeminuts_int)*60;
+        int longitudeseconds_int = longitudeseconds;
+        sprintf(exifcontent,"%d/%d,%d/%d,%d/%d",longitudedegree,1,longitudeminuts_int,1,longitudeseconds_int,1);
         exiftable->insertElement("GPSLongitude",(const char*)exifcontent);
 
         exiftable->insertElement("GPSLongitudeRef",(offset==1)?"S":"N");
-	}
-
-	//gps Altitude info
-	char* altitudestr = (char*)mParams.get(CameraParameters::KEY_GPS_ALTITUDE);
-	if(altitudestr!=NULL)
-	{
-		int offset = 0;
-		float altitude = mParams.getFloat(CameraParameters::KEY_GPS_ALTITUDE);
-		if(altitude < 0.0)
-		{
-			offset = 1;
-			altitude*= (float)(-1);
-		}
+    }
 
-		int altitudenum = altitude*1000;
-		int altitudedec= 1000;
-		sprintf(exifcontent,"%d/%d",altitudenum,altitudedec);
+    //gps Altitude info
+    char* altitudestr = (char*)mParams.get(CameraParameters::KEY_GPS_ALTITUDE);
+    if(altitudestr!=NULL)
+    {
+        int offset = 0;
+        float altitude = mParams.getFloat(CameraParameters::KEY_GPS_ALTITUDE);
+        if(altitude < 0.0)
+        {
+            offset = 1;
+            altitude*= (float)(-1);
+        }
+
+        int altitudenum = altitude*1000;
+        int altitudedec= 1000;
+        sprintf(exifcontent,"%d/%d",altitudenum,altitudedec);
         exiftable->insertElement("GPSAltitude",(const char*)exifcontent);
 
-		sprintf(exifcontent,"%d",offset);
+        sprintf(exifcontent,"%d",offset);
         exiftable->insertElement("GPSAltitudeRef",(const char*)exifcontent);
-	}
-
-	//gps processing method
-	char* processmethod = (char*)mParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
-	if(processmethod!=NULL)
-	{
-		char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };//asicii
-		memcpy(exifcontent,ExifAsciiPrefix,8);
-		memcpy(exifcontent+8,processmethod,strlen(processmethod));
-        exiftable->insertElement("GPSProcessingMethods",(const char*)exifcontent);
-	}
+    }
 
-	return 1;
+    //gps processing method
+    char* processmethod = (char*)mParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
+    if(processmethod!=NULL)
+    {
+        char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };//asicii
+        memcpy(exifcontent,ExifAsciiPrefix,8);
+        memcpy(exifcontent+8,processmethod,strlen(processmethod));
+        exiftable->insertElement("GPSProcessingMethods",(const char*)exifcontent);
+    }
+    return 1;
 }
 
 /*static*/ int V4LCameraAdapter::beginPictureThread(void *cookie)
@@ -957,10 +950,10 @@ int V4LCameraAdapter::pictureThread()
     int width, height;
     CameraFrame frame;
 
-	writefile(SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
+    writefile(SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
 
     if (true)
-	{
+    {
         mVideoInfo->buf.index = 0;
         mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
@@ -1031,12 +1024,12 @@ int V4LCameraAdapter::pictureThread()
         frame.mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
         
         if (mVideoInfo->isStreaming) 
-		{
+        {
             bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
             ret = ioctl (mCameraHandle, VIDIOC_STREAMOFF, &bufType);
             if (ret < 0) 
-			{
+            {
                 CAMHAL_LOGEB("StopStreaming: Unable to stop capture: %s", strerror(errno));
                 return ret;
             }
@@ -1108,7 +1101,7 @@ extern "C" int CameraAdapter_Capabilities(CameraProperties::Properties* properti
     }
 
     while (starting_camera + num_cameras_supported < max_camera)
-	{
+    {
         properties = properties_array + starting_camera + num_cameras_supported;
         properties->set(CameraProperties::CAMERA_NAME, "Camera");
         extern void loadCaps(int camera_id, CameraProperties::Properties* params);
@@ -1211,14 +1204,14 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     else
         params->set(CameraProperties::ORIENTATION_INDEX,"90");
 
-	params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,DEFAULT_PREVIEW_FORMAT);
-	params->set(CameraProperties::PREVIEW_FORMAT,DEFAULT_PREVIEW_FORMAT);
+    params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,DEFAULT_PREVIEW_FORMAT);
+    params->set(CameraProperties::PREVIEW_FORMAT,DEFAULT_PREVIEW_FORMAT);
 
     params->set(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES, "10,15");
-	params->set(CameraProperties::PREVIEW_FRAME_RATE, "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_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");
 
@@ -1234,27 +1227,27 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
         //set last size as default
         char * b = strrchr(sizes, ',');
         if (b) 
-			b++;
+            b++;
         else 
-			b = sizes;
+            b = sizes;
         params->set(CameraProperties::PREVIEW_SIZE, b);
     }
-	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
+    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){
@@ -1267,62 +1260,62 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
         if (b) b++;
         else b = sizes;
         params->set(CameraProperties::PICTURE_SIZE, b);
-    } else
-	{
-	    params->set(CameraProperties::SUPPORTED_PICTURE_SIZES, "640x480");
-		params->set(CameraProperties::PICTURE_SIZE, "640x480");
-	}
-
+    } 
+    else
+    {
+        params->set(CameraProperties::SUPPORTED_PICTURE_SIZES, "640x480");
+        params->set(CameraProperties::PICTURE_SIZE, "640x480");
+    }
 
-	params->set(CameraProperties::SUPPORTED_FOCUS_MODES, "fixed");
-	params->set(CameraProperties::FOCUS_MODE, "fixed");
+    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::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::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_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");
+    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");
+    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(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::AUTO_EXPOSURE_LOCK, DEFAULT_AE_LOCK);
 
-	params->set(CameraProperties::SUPPORTED_EV_MAX, 4);
-	params->set(CameraProperties::SUPPORTED_EV_MIN, -4);
+    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
+    //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);
@@ -1333,7 +1326,6 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     params->set(CameraProperties::SUPPORTED_SCENE_MODES, "auto");
     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);
@@ -1343,7 +1335,7 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     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_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);
@@ -1353,136 +1345,134 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
 
 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 ;
+    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 ;
+    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 ;
+    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 ;
+    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 ;
-}
+    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 ;
+}
 
 };