for cts

5 files changed, 239 insertions, 125 deletions

diff --git a/AppCallbackNotifier.cpp b/AppCallbackNotifier.cpp
index 5be4b0f..1b59711 100755
--- a/AppCallbackNotifier.cpp
+++ b/AppCallbackNotifier.cpp
@@ -63,47 +63,47 @@ void AppCallbackNotifier::EncoderDoneCb(void* main_jpeg, void* thumb_jpeg, Camer
     camera_memory_t* picture = NULL;
 
     {
-    Mutex::Autolock lock(mLock);
+        Mutex::Autolock lock(mLock);
 
-    if (!main_jpeg) {
-        goto exit;
-    }
+        if (!main_jpeg) {
+            goto exit;
+        }
 
-    encoded_mem = (camera_memory_t*) cookie1;
-    main_param = (Encoder_libjpeg::params *) main_jpeg;
-    jpeg_size = main_param->jpeg_size;
-    src = main_param->src;
+        encoded_mem = (camera_memory_t*) cookie1;
+        main_param = (Encoder_libjpeg::params *) main_jpeg;
+        jpeg_size = main_param->jpeg_size;
+        src = main_param->src;
 
-    if(encoded_mem && encoded_mem->data && (jpeg_size > 0)) {
-        if (cookie2) {
-            ExifElementsTable* exif = (ExifElementsTable*) cookie2;
-            Section_t* exif_section = NULL;
+        if(encoded_mem && encoded_mem->data && (jpeg_size > 0)) {
+            if (cookie2) {
+                ExifElementsTable* exif = (ExifElementsTable*) cookie2;
+                Section_t* exif_section = NULL;
 
-            exif->insertExifToJpeg((unsigned char*) encoded_mem->data, jpeg_size);
+                exif->insertExifToJpeg((unsigned char*) encoded_mem->data, jpeg_size);
 
-            if(thumb_jpeg) {
-                thumb_param = (Encoder_libjpeg::params *) thumb_jpeg;
-                exif->insertExifThumbnailImage((const char*)thumb_param->dst,
-                                               (int)thumb_param->jpeg_size);
-            }
+                if(thumb_jpeg) {
+                    thumb_param = (Encoder_libjpeg::params *) thumb_jpeg;
+                    if((thumb_param->in_width>0)&&(thumb_param->in_height>0)&&(thumb_param->out_width>0)&&(thumb_param->out_height>0))
+                        exif->insertExifThumbnailImage((const char*)thumb_param->dst,(int)thumb_param->jpeg_size);
+                }
 
-            exif_section = FindSection(M_EXIF);
+                exif_section = FindSection(M_EXIF);
 
-            if (exif_section) {
-                picture = mRequestMemory(-1, jpeg_size + exif_section->Size, 1, NULL);
+                if (exif_section) {
+                    picture = mRequestMemory(-1, jpeg_size + exif_section->Size, 1, NULL);
+                    if (picture && picture->data) {
+                        exif->saveJpeg((unsigned char*) picture->data, jpeg_size + exif_section->Size);
+                    }
+                }
+                delete exif;
+                cookie2 = NULL;
+            } else {
+                picture = mRequestMemory(-1, jpeg_size, 1, NULL);
                 if (picture && picture->data) {
-                    exif->saveJpeg((unsigned char*) picture->data, jpeg_size + exif_section->Size);
+                    memcpy(picture->data, encoded_mem->data, jpeg_size);
                 }
             }
-            delete exif;
-            cookie2 = NULL;
-        } else {
-            picture = mRequestMemory(-1, jpeg_size, 1, NULL);
-            if (picture && picture->data) {
-                memcpy(picture->data, encoded_mem->data, jpeg_size);
-            }
         }
-    }
     } // scope for mutex lock
 
     if (!mRawAvailable) {
@@ -136,10 +136,10 @@ void AppCallbackNotifier::EncoderDoneCb(void* main_jpeg, void* thumb_jpeg, Camer
     }
 
     if (thumb_jpeg) {
-       if (((Encoder_libjpeg::params *) thumb_jpeg)->dst) {
-           free(((Encoder_libjpeg::params *) thumb_jpeg)->dst);
-       }
-       free(thumb_jpeg);
+        if (((Encoder_libjpeg::params *) thumb_jpeg)->dst) {
+            free(((Encoder_libjpeg::params *) thumb_jpeg)->dst);
+        }
+        free(thumb_jpeg);
     }
 
     if (encoded_mem) {
@@ -825,8 +825,9 @@ void AppCallbackNotifier::notifyFrame()
                           (NULL != mCameraHal) &&
                           (NULL != mDataCb) &&
                           ((CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG & frame->mQuirks) ||
-                           (CameraFrame::ENCODE_RAW_RGB24_TO_JPEG & frame->mQuirks)) )
-                    {
+                           (CameraFrame::ENCODE_RAW_RGB24_TO_JPEG & frame->mQuirks)|| 
+                           (CameraFrame::ENCODE_RAW_YUV420SP_TO_JPEG & frame->mQuirks)))
+                {
 
                     LOGD("IMAGE_FRAME ENCODE_RAW.. %d", __LINE__);
                     int encode_quality = 100, tn_quality = 100;
@@ -838,6 +839,9 @@ void AppCallbackNotifier::notifyFrame()
 
                     if(raw_picture) {
                         buf = raw_picture->data;
+                    }else{
+                        CAMHAL_LOGEA("Error! Main Jpeg encoder request memory fail!");
+                        break;
                     }
 
                     CameraParameters parameters;
@@ -873,8 +877,10 @@ void AppCallbackNotifier::notifyFrame()
                         main_jpeg->out_height = frame->mHeight;
                         if ((CameraFrame::ENCODE_RAW_RGB24_TO_JPEG & frame->mQuirks))
                             main_jpeg->format = CameraProperties::PIXEL_FORMAT_RGB24;
-                        else
+                        else if ((CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG & frame->mQuirks))
                             main_jpeg->format = CameraParameters::PIXEL_FORMAT_YUV422I;
+                        else if ((CameraFrame::ENCODE_RAW_YUV420SP_TO_JPEG & frame->mQuirks))
+                            main_jpeg->format = CameraParameters::PIXEL_FORMAT_YUV420SP;
                     }
 
 // disable thumbnail for now. preview was stopped and mPreviewBufs was
@@ -907,6 +913,42 @@ void AppCallbackNotifier::notifyFrame()
                         tn_jpeg->out_height = tn_height;
                         tn_jpeg->format = CameraParameters::PIXEL_FORMAT_YUV420SP;;
                     }
+#else
+                    tn_width = parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
+                    tn_height = parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
+
+                    if ((tn_width > 0) && (tn_height > 0)) {
+                        tn_jpeg = (Encoder_libjpeg::params*)
+                                      malloc(sizeof(Encoder_libjpeg::params));
+                        // if malloc fails just keep going and encode main jpeg
+                        if (!tn_jpeg) {
+                            tn_jpeg = NULL;
+                        }
+                    }
+
+                    if (tn_jpeg) {
+                        tn_jpeg->dst = (uint8_t*) malloc(frame->mLength);
+                        if(tn_jpeg->dst){
+                            tn_jpeg->src = (uint8_t*) frame->mBuffer;
+                            tn_jpeg->src_size = frame->mLength;
+                            tn_jpeg->dst_size = frame->mLength;
+                            tn_jpeg->quality = tn_quality;
+                            tn_jpeg->in_width = frame->mWidth;
+                            tn_jpeg->in_height = frame->mHeight;
+                            tn_jpeg->out_width = tn_width;
+                            tn_jpeg->out_height = tn_height;
+                            if ((CameraFrame::ENCODE_RAW_RGB24_TO_JPEG & frame->mQuirks))
+                                tn_jpeg->format = CameraProperties::PIXEL_FORMAT_RGB24;
+                            else if ((CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG & frame->mQuirks))
+                                tn_jpeg->format = CameraParameters::PIXEL_FORMAT_YUV422I;
+                            else if ((CameraFrame::ENCODE_RAW_YUV420SP_TO_JPEG & frame->mQuirks))
+                                tn_jpeg->format = CameraParameters::PIXEL_FORMAT_YUV420SP;
+                        }else{
+                            free(tn_jpeg);
+                            tn_jpeg = NULL;
+                            CAMHAL_LOGEA("Error! Thumbnail Jpeg encoder malloc memory fail!");
+                        }
+                    }
 #endif
 
                     LOGD("IMAGE_FRAME ENCODE_RAW.. %d", __LINE__);
@@ -921,14 +963,14 @@ void AppCallbackNotifier::notifyFrame()
                     gEncoderQueue.add(frame->mBuffer, encoder);
                     encoder.clear();
                     if (params != NULL)
-                      {
+                    {
                         mCameraHal->putParameters(params);
-                      }
                     }
+                }
                 else if ( ( CameraFrame::IMAGE_FRAME == frame->mFrameType ) &&
                              ( NULL != mCameraHal ) &&
                              ( NULL != mDataCb) )
-                    {
+                {
 
                     // CTS, MTS requirements: Every 'takePicture()' call
                     // who registers a raw callback should receive one
diff --git a/BaseCameraAdapter.cpp b/BaseCameraAdapter.cpp
index 5cb556b..495666c 100755
--- a/BaseCameraAdapter.cpp
+++ b/BaseCameraAdapter.cpp
@@ -809,34 +809,34 @@ status_t BaseCameraAdapter::sendCommand(CameraCommands operation, int value1, in
             }
 
         case CameraAdapter::CAMERA_PERFORM_AUTOFOCUS:
-			if(getState() != AF_STATE)
-			{
+            if(getState() != AF_STATE)
+            {
 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
-	            refTimestamp = ( struct timeval * ) value1;
-	            if ( NULL != refTimestamp )
-	            {
-		            memcpy( &mStartFocus, refTimestamp, sizeof( struct timeval ));
-	            }
+                refTimestamp = ( struct timeval * ) value1;
+                if ( NULL != refTimestamp )
+                {
+                    memcpy( &mStartFocus, refTimestamp, sizeof( struct timeval ));
+                }
 #endif
-	            if ( ret == NO_ERROR )
-	            {
-		            ret = setState(operation);
-	            }
-
-	            if ( ret == NO_ERROR )
-	            {
-		            ret = autoFocus();
-	            }
-
-	            if ( ret == NO_ERROR )
-	            {
-		            ret = commitState();
-	            }
-	            else
-	            {
-		            ret |= rollbackState();
-	            }
-			}
+                if ( ret == NO_ERROR )
+                {
+                    ret = setState(operation);
+                }
+
+                if ( ret == NO_ERROR )
+                {
+                    ret = autoFocus();
+                }
+
+                if ( ret == NO_ERROR )
+                {
+                    ret = commitState();
+                }
+                else
+                {
+                    ret |= rollbackState();
+                }
+            }
             break;
 
         case CameraAdapter::CAMERA_CANCEL_AUTOFOCUS:
@@ -1538,7 +1538,7 @@ status_t BaseCameraAdapter::stopImageCapture()
     status_t ret = NO_ERROR;
 
     LOG_FUNCTION_NAME;
-
+   
     LOG_FUNCTION_NAME_EXIT;
 
     return ret;
@@ -1569,11 +1569,11 @@ status_t BaseCameraAdapter::stopBracketing()
 int beginAutoFocusThread(void *cookie)
 {
     BaseCameraAdapter *c = (BaseCameraAdapter *)cookie;
-	//should add wait focus end
-	c->notifyFocusSubscribers(true);
-	c->setState(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS);
-	c->commitState();
-	return 1;
+    //should add wait focus end
+    c->setState(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS);
+    c->commitState();
+    c->notifyFocusSubscribers(true);
+    return 1;
 }
 
 status_t BaseCameraAdapter::autoFocus()
@@ -1582,10 +1582,10 @@ status_t BaseCameraAdapter::autoFocus()
 
     LOG_FUNCTION_NAME;
 
-	if (createThread(beginAutoFocusThread, this) == false)
-	{
-		ret = UNKNOWN_ERROR;
-	}
+    if (createThread(beginAutoFocusThread, this) == false)
+    {
+        ret = UNKNOWN_ERROR;
+    }
 
     LOG_FUNCTION_NAME_EXIT;
 
diff --git a/CameraHal.cpp b/CameraHal.cpp
index 64e214a..8f87f65 100755
--- a/CameraHal.cpp
+++ b/CameraHal.cpp
@@ -664,7 +664,7 @@ int CameraHal::setParameters(const CameraParameters& params)
         //Perform parameter validation
         if(!isParameterValid(valstr
                         , mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED))
-                        || !isParameterValid(framerate,
+                        || !isParameterInRange(framerate,
                                       mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)))
         {
             CAMHAL_LOGEA("Invalid frame rate range or frame rate");
@@ -2721,7 +2721,7 @@ status_t CameraHal::takePicture( )
 
             if ( NO_ERROR != ret )
             {
-                CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
+                CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x, count:%d", ret,bufferCount);
             }
         }
 
@@ -3270,29 +3270,29 @@ bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const
     LOG_FUNCTION_NAME;
 
     if ( NULL == supportedResolutions )
-        {
+    {
         CAMHAL_LOGEA("Invalid supported resolutions string");
         ret = false;
         goto exit;
-        }
+    }
 
     status = snprintf(tmpBuffer, PARAM_BUFFER, "%dx%d", width, height);
     if ( 0 > status )
-        {
+    {
         CAMHAL_LOGEA("Error encountered while generating validation string");
         ret = false;
         goto exit;
-        }
+    }
 
     pos = strstr(supportedResolutions, tmpBuffer);
     if ( NULL == pos )
-        {
+    {
         ret = false;
-        }
+    }
     else
-        {
+    {
         ret = true;
-        }
+    }
 
 exit:
 
@@ -3301,6 +3301,7 @@ exit:
     return ret;
 }
 #endif
+
 bool CameraHal::isParameterValid(const char *param, const char *supportedParams)
 {
     bool ret = true;
@@ -3309,28 +3310,28 @@ bool CameraHal::isParameterValid(const char *param, const char *supportedParams)
     LOG_FUNCTION_NAME;
 
     if ( NULL == supportedParams )
-        {
+    {
         CAMHAL_LOGEA("Invalid supported parameters string");
         ret = false;
         goto exit;
-        }
+    }
 
     if ( NULL == param )
-        {
+    {
         CAMHAL_LOGEA("Invalid parameter string");
         ret = false;
         goto exit;
-        }
+    }
 
     pos = strstr(supportedParams, param);
     if ( NULL == pos )
-        {
+    {
         ret = false;
-        }
+    }
     else
-        {
+    {
         ret = true;
-        }
+    }
 
 exit:
 
@@ -3349,30 +3350,73 @@ bool CameraHal::isParameterValid(int param, const char *supportedParams)
     LOG_FUNCTION_NAME;
 
     if ( NULL == supportedParams )
-        {
+    {
         CAMHAL_LOGEA("Invalid supported parameters string");
         ret = false;
         goto exit;
-        }
+    }
 
     status = snprintf(tmpBuffer, PARAM_BUFFER, "%d", param);
     if ( 0 > status )
-        {
+    {
         CAMHAL_LOGEA("Error encountered while generating validation string");
         ret = false;
         goto exit;
-        }
+    }
 
     pos = strstr(supportedParams, tmpBuffer);
     if ( NULL == pos )
-        {
+    {
         ret = false;
-        }
+    }
     else
-        {
+    {
         ret = true;
-        }
+    }
+
+exit:
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+bool CameraHal::isParameterInRange(int param, const char *supportedParams)
+{
+    bool ret = true;
+    char *pos = NULL;
+    status_t status;
+    int min_range = 0, max_range = 0;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == supportedParams )
+    {
+        CAMHAL_LOGEA("Invalid supported parameters string");
+        ret = false;
+        goto exit;
+    }
+    if (sscanf(supportedParams, "%d,%d", &min_range, &max_range) != 2){
+        CAMHAL_LOGEA("Error encountered while get Parameter Range");
+        ret = false;
+        goto exit;
+    }
+    if(min_range==max_range){
+        CAMHAL_LOGEA("Parameter Range Invalid");
+        ret = false;
+        goto exit;
+    }
+
+    if(min_range>max_range){
+        int temp = max_range;
+        max_range = min_range;
+        min_range = temp;
+    }
 
+    if((min_range<=param)&&(param<=max_range))
+        ret = true;
+    else
+        ret = false;  
 exit:
 
     LOG_FUNCTION_NAME_EXIT;
@@ -3380,7 +3424,8 @@ exit:
     return ret;
 }
 
-status_t CameraHal::doesSetParameterNeedUpdate(const char* new_param, const char* old_param, bool& update) {
+status_t CameraHal::doesSetParameterNeedUpdate(const char* new_param, const char* old_param, bool& update) 
+{
     if (!new_param || !old_param) {
         return -EINVAL;
     }
@@ -3471,7 +3516,12 @@ void CameraHal::insertSupportedParams()
     p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE));
     p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS));
     p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
-    p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES));
+
+    const char *flashmode = mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES);
+    if(flashmode&&(flashmode[0]!=0)){
+        p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, flashmode);
+    }
+
     p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES));
     p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING));
     p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX));
@@ -3497,6 +3547,8 @@ void CameraHal::insertSupportedParams()
     p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED));
     p.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, mCameraProperties->get(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED));
 
+    //p.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES));
+
     p.set(CameraParameters::KEY_FOCUS_DISTANCES,"0.95,1.9,Infinity");
 
     LOG_FUNCTION_NAME_EXIT;
@@ -3560,11 +3612,15 @@ void CameraHal::initDefaultParameters()
     p.set(CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE));
     p.set(CameraParameters::KEY_EFFECT,  mCameraProperties->get(CameraProperties::EFFECT));
     p.set(CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING));
-    p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
     p.set(CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE));
     p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION));
     p.set(CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE));
-    p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
+
+    const char *flashmode = mCameraProperties->get(CameraProperties::FLASH_MODE);
+    if(flashmode&&(flashmode[0]!=0)){
+        p.set(CameraParameters::KEY_FLASH_MODE, flashmode);
+    }
+
     p.set(CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM));
     p.set(TICameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST));
     p.set(TICameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION));
@@ -3598,7 +3654,7 @@ void CameraHal::initDefaultParameters()
     p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK));
     p.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_AREAS));
     p.set(CameraParameters::KEY_VIDEO_SIZE, mCameraProperties->get(CameraProperties::VIDEO_SIZE));
-    p.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, mCameraProperties->get(CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO));
+    //p.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, mCameraProperties->get(CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO));
 
     LOG_FUNCTION_NAME_EXIT;
 }
diff --git a/V4LCameraAdapter/V4LCameraAdapter.cpp b/V4LCameraAdapter/V4LCameraAdapter.cpp
index 2541aeb..00cd463 100755
--- a/V4LCameraAdapter/V4LCameraAdapter.cpp
+++ b/V4LCameraAdapter/V4LCameraAdapter.cpp
@@ -244,14 +244,14 @@ status_t V4LCameraAdapter::setParameters(const CameraParameters &params)
     //const char *night_mode=NULL;
     const char *qulity=NULL;
     const char *banding=NULL;
-    const char *flashmode=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);
+    //flashmode = mParams.get(CameraParameters::KEY_FLASH_MODE);
     if(exposure)
         SetExposure(mCameraHandle,exposure);
     if(white_balance)
@@ -655,16 +655,16 @@ status_t V4LCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t buffer
 status_t V4LCameraAdapter::getPictureBufferSize(size_t &length, size_t bufferCount)
 {
     int width, height;
-    int bytes_per_pixel = 3;
     mParams.getPictureSize(&width, &height);
     if(DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT == V4L2_PIX_FMT_RGB24){ // rgb24
-        bytes_per_pixel =3;
+        length = width * height * 3;
     }else if(DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT == V4L2_PIX_FMT_YUYV){ //   422I
-        bytes_per_pixel = 2;
-    }else{ //default case
-        bytes_per_pixel = 3;
+        length = width * height * 2;
+    }else if(DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT == V4L2_PIX_FMT_NV21){
+        length = width * height * 3/2;
+    }else{
+        length = width * height * 3;
     }
-    length = width * height * bytes_per_pixel;
     return NO_ERROR;
 }
 
@@ -918,7 +918,7 @@ int V4LCameraAdapter::GenExif(ExifElementsTable* exiftable)
         int latitudedegree = latitude;
         float latitudeminuts = (latitude-(float)latitudedegree)*60;
         int latitudeminuts_int = latitudeminuts;
-        float latituseconds = (latitudeminuts-(float)latitudeminuts_int)*60;
+        float latituseconds = (latitudeminuts-(float)latitudeminuts_int)*60+0.5;
         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);
@@ -941,7 +941,7 @@ int V4LCameraAdapter::GenExif(ExifElementsTable* exiftable)
         int longitudedegree = longitude;
         float longitudeminuts = (longitude-(float)longitudedegree)*60;
         int longitudeminuts_int = longitudeminuts;
-        float longitudeseconds = (longitudeminuts-(float)longitudeminuts_int)*60;
+        float longitudeseconds = (longitudeminuts-(float)longitudeminuts_int)*60+0.5;
         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);
@@ -974,10 +974,11 @@ int V4LCameraAdapter::GenExif(ExifElementsTable* exiftable)
     char* processmethod = (char*)mParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
     if(processmethod!=NULL)
     {
+        memset(exifcontent,0,sizeof(exifcontent));
         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);
+        exiftable->insertElement("GPSProcessingMethod",(const char*)exifcontent);
     }
     return 1;
 }
@@ -1047,14 +1048,25 @@ int V4LCameraAdapter::pictureThread()
         if(DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT == V4L2_PIX_FMT_RGB24){ // rgb24
             frame.mLength = width*height*3;
             frame.mQuirks = CameraFrame::ENCODE_RAW_RGB24_TO_JPEG | CameraFrame::HAS_EXIF_DATA;
+            memcpy(dest, src, mVideoInfo->buf.length);
         }else if(DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT == V4L2_PIX_FMT_YUYV){ //   422I
             frame.mLength = width*height*2;
             frame.mQuirks = CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG | CameraFrame::HAS_EXIF_DATA;
+            memcpy(dest, src, mVideoInfo->buf.length);
+        }else if(DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT == V4L2_PIX_FMT_NV21){ //   420sp
+            frame.mLength = width*height*3/2;
+            frame.mQuirks = CameraFrame::ENCODE_RAW_YUV420SP_TO_JPEG | CameraFrame::HAS_EXIF_DATA;
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+            //convert yuyv to nv21
+            yuyv422_to_nv21(src,dest,width,height);
+#else
+            memcpy(dest,src,frame.mLength);
+#endif
         }else{ //default case
             frame.mLength = width*height*3;
             frame.mQuirks = CameraFrame::ENCODE_RAW_RGB24_TO_JPEG | CameraFrame::HAS_EXIF_DATA;
+            memcpy(dest, src, mVideoInfo->buf.length);
         }
-        memcpy(dest, src, mVideoInfo->buf.length);
 
         notifyShutterSubscribers();
         //TODO correct time to call this?
@@ -1302,22 +1314,24 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
         params->set(CameraProperties::ORIENTATION_INDEX,"90");
 #endif
     }
+
+    params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,"yuv420sp,yuv420p"); //yuv420p for cts
     if(DEFAULT_PREVIEW_PIXEL_FORMAT == V4L2_PIX_FMT_YUYV){ // 422I
-        params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,PREVIEW_FORMAT_422I);
+        //params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,PREVIEW_FORMAT_422I);
         params->set(CameraProperties::PREVIEW_FORMAT,PREVIEW_FORMAT_422I);
     }else if(DEFAULT_PREVIEW_PIXEL_FORMAT == V4L2_PIX_FMT_NV21){ //420sp
-        params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,PREVIEW_FORMAT_420SP);
+        //params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,PREVIEW_FORMAT_420SP);
         params->set(CameraProperties::PREVIEW_FORMAT,PREVIEW_FORMAT_420SP);
     }else{ //default case
-        params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,PREVIEW_FORMAT_420SP);
+        //params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,PREVIEW_FORMAT_420SP);
         params->set(CameraProperties::PREVIEW_FORMAT,PREVIEW_FORMAT_420SP);
     }
 
     params->set(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES, "10,15");
     params->set(CameraProperties::PREVIEW_FRAME_RATE, "15");
 
-    params->set(CameraProperties::FRAMERATE_RANGE_SUPPORTED, "(10500,26623)");
-    params->set(CameraProperties::FRAMERATE_RANGE, "10500,26623");
+    params->set(CameraProperties::FRAMERATE_RANGE_SUPPORTED, "(8000,26623)");
+    params->set(CameraProperties::FRAMERATE_RANGE, "8000,26623");
     params->set(CameraProperties::FRAMERATE_RANGE_IMAGE, "10000,15000");
     params->set(CameraProperties::FRAMERATE_RANGE_VIDEO, "10000,15000");
 
diff --git a/inc/CameraHal.h b/inc/CameraHal.h
index 781061f..5143c95 100755
--- a/inc/CameraHal.h
+++ b/inc/CameraHal.h
@@ -258,7 +258,8 @@ class CameraFrame
     {
         ENCODE_RAW_YUV422I_TO_JPEG = 0x1 << 0,
         ENCODE_RAW_RGB24_TO_JPEG = 0x1 << 1,
-        HAS_EXIF_DATA = 0x1 << 2,
+        ENCODE_RAW_YUV420SP_TO_JPEG = 0x1 << 2,
+        HAS_EXIF_DATA = 0x1 << 3,
     };
 
     //default contrustor
@@ -1140,6 +1141,7 @@ private:
     // instance
     bool isParameterValid(const char *param, const char *supportedParams);
     bool isParameterValid(int param, const char *supportedParams);
+    bool isParameterInRange(int param, const char *supportedParams);
     status_t doesSetParameterNeedUpdate(const char *new_param, const char *old_params, bool &update);
 
     /** Initialize default parameters */