add usb camera support

14 files changed, 753 insertions, 221 deletions

diff --git a/ANativeWindowDisplayAdapter.cpp b/ANativeWindowDisplayAdapter.cpp
index 7df64b1..0f31fd0 100755
--- a/ANativeWindowDisplayAdapter.cpp
+++ b/ANativeWindowDisplayAdapter.cpp
@@ -133,6 +133,7 @@ ANativeWindowDisplayAdapter::ANativeWindowDisplayAdapter():mDisplayThread(NULL),
 #endif
 
     mPixelFormat = NULL;
+    mNativeWindowPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
     mBufferHandleMap = NULL;
     mGrallocHandleMap = NULL;
     mOffsetsMap = NULL;
@@ -531,13 +532,33 @@ void* ANativeWindowDisplayAdapter::allocateBuffer(int width, int height, const c
     CAMHAL_LOGDB("Configuring %d buffers for ANativeWindow", numBufs);
     mBufferCount = numBufs;
 
-
+    uint32_t win_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
+    if ( format != NULL ) {
+        if (strcmp(format, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0) {
+            win_format = HAL_PIXEL_FORMAT_YCbCr_422_I;
+        }else if((strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) == 0) ||
+                (strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) == 0)) {
+            win_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
+        }else if(strcmp(format, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0) {
+            win_format = HAL_PIXEL_FORMAT_RGB_565;
+        } else {
+            win_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
+            CAMHAL_LOGEA("Invalid format");
+        }
+    } else {
+        win_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
+        CAMHAL_LOGEA("Preview format is NULL");
+    }
+	
+    mNativeWindowPixelFormat = win_format;
+	
+    CAMHAL_LOGDB("native_window_set_buffers_geometry format:0x%x",mNativeWindowPixelFormat);
     // Set window geometry
     err = mANativeWindow->set_buffers_geometry(
             mANativeWindow,
             width,
             height,
-            HAL_PIXEL_FORMAT_YCrCb_420_SP); //NV21
+            mNativeWindowPixelFormat); //NV21
 
     if (err != 0) {
         LOGE("native_window_set_buffers_geometry failed: %s (%d)", strerror(-err), -err);
diff --git a/Android.mk b/Android.mk
index bbc4226..cbd8c09 100644..100755
--- a/Android.mk
+++ b/Android.mk
@@ -70,7 +70,7 @@ endif
 
 ifeq ($(BOARD_USE_USB_CAMERA),true)
     LOCAL_CFLAGS += -DAMLOGIC_USB_CAMERA_SUPPORT
-    LOCAL_SRC_FILES += util.cpp
+    CAMERA_UTILS_SRC += utils/util.cpp
 else
     ifeq ($(BOARD_HAVE_MULTI_CAMERAS),true)
         LOCAL_CFLAGS += -DAMLOGIC_MULTI_CAMERA_SUPPORT
diff --git a/AppCallbackNotifier.cpp b/AppCallbackNotifier.cpp
index 276ae25..5be4b0f 100755
--- a/AppCallbackNotifier.cpp
+++ b/AppCallbackNotifier.cpp
@@ -1052,7 +1052,7 @@ void AppCallbackNotifier::notifyFrame()
                             }
                             uint8_t* src = (uint8_t*)gralloc_hnd->base;
                             uint8_t* dest = (uint8_t*)VideoCameraBufferMemoryBase->data;
-                            memcpy(dest,src,frame->mWidth*frame->mHeight*3/2);
+                            memcpy(dest,src,frame->mLength);
                             mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME, VideoCameraBufferMemoryBase, 0, mCallbackCookie);
 #endif					
                         }
@@ -1406,16 +1406,16 @@ status_t AppCallbackNotifier::startPreviewCallbacks(CameraParameters &params, vo
     Mutex::Autolock lock(mLock);
 
     if ( NULL == mFrameProvider )
-        {
+    {
         CAMHAL_LOGEA("Trying to start video recording without FrameProvider");
         return -EINVAL;
-        }
+    }
 
     if ( mPreviewing )
-        {
+    {
         CAMHAL_LOGDA("+Already previewing");
         return NO_INIT;
-        }
+    }
 
     int w,h;
     ///Get preview size
@@ -1425,21 +1425,21 @@ status_t AppCallbackNotifier::startPreviewCallbacks(CameraParameters &params, vo
     mPreviewPixelFormat = params.getPreviewFormat();
 
      if(strcmp(mPreviewPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
-        {
+    {
         size = w*h*2;
         mPreviewPixelFormat = CameraParameters::PIXEL_FORMAT_YUV422I;
-        }
+    }
     else if(strcmp(mPreviewPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0 ||
             strcmp(mPreviewPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV420P) == 0)
-        {
+    {
         size = (w*h*3)/2;
         mPreviewPixelFormat = CameraParameters::PIXEL_FORMAT_YUV420SP;
-        }
+    }
     else if(strcmp(mPreviewPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
-        {
+    {
         size = w*h*2;
         mPreviewPixelFormat = CameraParameters::PIXEL_FORMAT_RGB565;
-        }
+    }
 
     mPreviewMemory = mRequestMemory(-1, size, AppCallbackNotifier::MAX_BUFFERS, NULL);
     if (!mPreviewMemory) {
@@ -1451,7 +1451,7 @@ status_t AppCallbackNotifier::startPreviewCallbacks(CameraParameters &params, vo
     }
 
     if ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME ) ) {
-         mFrameProvider->enableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
+        mFrameProvider->enableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
     }
 
     mPreviewBufCount = 0;
@@ -1491,12 +1491,12 @@ bool AppCallbackNotifier::getUseVideoBuffers()
 
 void AppCallbackNotifier::setVideoRes(int width, int height)
 {
-  LOG_FUNCTION_NAME;
+    LOG_FUNCTION_NAME;
 
-  mVideoWidth = width;
-  mVideoHeight = height;
+    mVideoWidth = width;
+    mVideoHeight = height;
 
-  LOG_FUNCTION_NAME_EXIT;
+    LOG_FUNCTION_NAME_EXIT;
 }
 
 status_t AppCallbackNotifier::stopPreviewCallbacks()
@@ -1507,21 +1507,21 @@ status_t AppCallbackNotifier::stopPreviewCallbacks()
     LOG_FUNCTION_NAME;
 
     if ( NULL == mFrameProvider )
-        {
+    {
         CAMHAL_LOGEA("Trying to stop preview callbacks without FrameProvider");
         return -EINVAL;
-        }
+    }
 
     if ( !mPreviewing )
-        {
+    {
         return NO_INIT;
-        }
+    }
 
     mFrameProvider->disableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
 
     {
-    Mutex::Autolock lock(mLock);
-    mPreviewMemory->release(mPreviewMemory);
+        Mutex::Autolock lock(mLock);
+        mPreviewMemory->release(mPreviewMemory);
     }
 
     mPreviewing = false;
@@ -1546,23 +1546,23 @@ status_t AppCallbackNotifier::startRecording()
 
     LOG_FUNCTION_NAME;
 
-   Mutex::Autolock lock(mRecordingLock);
+    Mutex::Autolock lock(mRecordingLock);
 
     if ( NULL == mFrameProvider )
-        {
+    {
         CAMHAL_LOGEA("Trying to start video recording without FrameProvider");
         ret = -1;
-        }
+    }
 
     if(mRecording)
-        {
+    {
         return NO_INIT;
-        }
+    }
 
     if ( NO_ERROR == ret )
-        {
+    {
          mFrameProvider->enableFrameNotification(CameraFrame::VIDEO_FRAME_SYNC);
-        }
+    }
 
     mRecording = true;
 
@@ -1628,7 +1628,7 @@ status_t AppCallbackNotifier::initSharedVideoBuffers(void *buffers, uint32_t *of
  #ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT
             VideoCameraBufferMemoryBase = (camera_memory_t*)bufArr[i];
  #else
-            VideoCameraBufferMemoryBase = mRequestMemory(-1, length, 1, NULL);
+            VideoCameraBufferMemoryBase = mRequestMemory(-1, mVideoWidth*mVideoHeight*3/2, 1, NULL); // only supported nv21 or nv12;
  #endif
             if((NULL == VideoCameraBufferMemoryBase) || (NULL == VideoCameraBufferMemoryBase->data))
             {
@@ -1656,20 +1656,20 @@ status_t AppCallbackNotifier::stopRecording()
     Mutex::Autolock lock(mRecordingLock);
 
     if ( NULL == mFrameProvider )
-        {
+    {
         CAMHAL_LOGEA("Trying to stop video recording without FrameProvider");
         ret = -1;
-        }
+    }
 
     if(!mRecording)
-        {
+    {
         return NO_INIT;
-        }
+    }
 
     if ( NO_ERROR == ret )
-        {
+    {
          mFrameProvider->disableFrameNotification(CameraFrame::VIDEO_FRAME_SYNC);
-        }
+    }
 
     ///Release the shared video buffers
     releaseSharedVideoBuffers();
@@ -1729,52 +1729,51 @@ status_t AppCallbackNotifier::releaseRecordingFrame(const void* mem)
 
 status_t AppCallbackNotifier::enableMsgType(int32_t msgType)
 {
-    if( msgType & (CAMERA_MSG_POSTVIEW_FRAME | CAMERA_MSG_PREVIEW_FRAME) ) {
+    //if( msgType & (CAMERA_MSG_POSTVIEW_FRAME | CAMERA_MSG_PREVIEW_FRAME) ) {
+    if( msgType & (CAMERA_MSG_PREVIEW_FRAME) ) {
         mFrameProvider->enableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
     }
-
     return NO_ERROR;
 }
 
 status_t AppCallbackNotifier::disableMsgType(int32_t msgType)
 {
-    if(!mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME | CAMERA_MSG_POSTVIEW_FRAME)) {
+    //if(!mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME | CAMERA_MSG_POSTVIEW_FRAME)) {
+    if(!mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) {
         mFrameProvider->disableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
     }
-
     return NO_ERROR;
-
 }
 
 status_t AppCallbackNotifier::start()
 {
     LOG_FUNCTION_NAME;
     if(mNotifierState==AppCallbackNotifier::NOTIFIER_STARTED)
-        {
+    {
         CAMHAL_LOGDA("AppCallbackNotifier already running");
         LOG_FUNCTION_NAME_EXIT;
         return ALREADY_EXISTS;
-        }
+    }
 
     ///Check whether initial conditions are met for us to start
     ///A frame provider should be available, if not return error
     if(!mFrameProvider)
-        {
+    {
         ///AppCallbackNotifier not properly initialized
         CAMHAL_LOGEA("AppCallbackNotifier not properly initialized - Frame provider is NULL");
         LOG_FUNCTION_NAME_EXIT;
         return NO_INIT;
-        }
+    }
 
     ///At least one event notifier should be available, if not return error
     ///@todo Modify here when there is an array of event providers
     if(!mEventProvider)
-        {
+    {
         CAMHAL_LOGEA("AppCallbackNotifier not properly initialized - Event provider is NULL");
         LOG_FUNCTION_NAME_EXIT;
         ///AppCallbackNotifier not properly initialized
         return NO_INIT;
-        }
+    }
 
     mNotifierState = AppCallbackNotifier::NOTIFIER_STARTED;
     CAMHAL_LOGDA(" --> AppCallbackNotifier NOTIFIER_STARTED \n");
@@ -1792,16 +1791,17 @@ status_t AppCallbackNotifier::stop()
     LOG_FUNCTION_NAME;
 
     if(mNotifierState!=AppCallbackNotifier::NOTIFIER_STARTED)
-        {
+    {
         CAMHAL_LOGDA("AppCallbackNotifier already in stopped state");
         LOG_FUNCTION_NAME_EXIT;
         return ALREADY_EXISTS;
-        }
+    }
+
     {
-    Mutex::Autolock lock(mLock);
+        Mutex::Autolock lock(mLock);
 
-    mNotifierState = AppCallbackNotifier::NOTIFIER_STOPPED;
-    CAMHAL_LOGDA(" --> AppCallbackNotifier NOTIFIER_STOPPED \n");
+        mNotifierState = AppCallbackNotifier::NOTIFIER_STOPPED;
+        CAMHAL_LOGDA(" --> AppCallbackNotifier NOTIFIER_STOPPED \n");
     }
 
     while(!gEncoderQueue.isEmpty()) {
diff --git a/BaseCameraAdapter.cpp b/BaseCameraAdapter.cpp
index 9d34c61..f2f707b 100755
--- a/BaseCameraAdapter.cpp
+++ b/BaseCameraAdapter.cpp
@@ -222,34 +222,34 @@ void BaseCameraAdapter::disableMsgType(int32_t msgs, void* cookie)
 
 void BaseCameraAdapter::addFramePointers(void *frameBuf, void *buf)
 {
-  unsigned int *pBuf = (unsigned int *)buf;
-  Mutex::Autolock lock(mSubscriberLock);
+    unsigned int *pBuf = (unsigned int *)buf;
+    Mutex::Autolock lock(mSubscriberLock);
 
-  if ((frameBuf != NULL) && ( pBuf != NULL) )
+    if ((frameBuf != NULL) && ( pBuf != NULL) )
     {
-      CameraFrame *frame = new CameraFrame;
-      frame->mBuffer = frameBuf;
-      frame->mYuv[0] = pBuf[0];
-      frame->mYuv[1] = pBuf[1];
-      mFrameQueue.add(frameBuf, frame);
+        CameraFrame *frame = new CameraFrame;
+        frame->mBuffer = frameBuf;
+        frame->mYuv[0] = pBuf[0];
+        frame->mYuv[1] = pBuf[1];
+        mFrameQueue.add(frameBuf, frame);
 
-      CAMHAL_LOGDB("Adding Frame=0x%x Y=0x%x UV=0x%x", (uint32_t)frame->mBuffer, frame->mYuv[0], frame->mYuv[1]);
+        CAMHAL_LOGDB("Adding Frame=0x%x Y=0x%x UV=0x%x", (uint32_t)frame->mBuffer, frame->mYuv[0], frame->mYuv[1]);
     }
 }
 
 void BaseCameraAdapter::removeFramePointers()
 {
-  Mutex::Autolock lock(mSubscriberLock);
+    Mutex::Autolock lock(mSubscriberLock);
 
-  int size = mFrameQueue.size();
-  CAMHAL_LOGVB("Removing %d Frames = ", size);
-  for (int i = 0; i < size; i++)
+    int size = mFrameQueue.size();
+    CAMHAL_LOGVB("Removing %d Frames = ", size);
+    for (int i = 0; i < size; i++)
     {
-      CameraFrame *frame = (CameraFrame *)mFrameQueue.valueAt(i);
-      CAMHAL_LOGVB("Free Frame=0x%x Y=0x%x UV=0x%x", frame->mBuffer, frame->mYuv[0], frame->mYuv[1]);
-      delete frame;
+        CameraFrame *frame = (CameraFrame *)mFrameQueue.valueAt(i);
+        CAMHAL_LOGVB("Free Frame=0x%x Y=0x%x UV=0x%x", frame->mBuffer, frame->mYuv[0], frame->mYuv[1]);
+        delete frame;
     }
-  mFrameQueue.clear();
+    mFrameQueue.clear();
 }
 
 void BaseCameraAdapter::returnFrame(void* frameBuf, CameraFrame::FrameType frameType)
diff --git a/CameraHal.cpp b/CameraHal.cpp
index 0c39861..d6939dd 100755
--- a/CameraHal.cpp
+++ b/CameraHal.cpp
@@ -564,7 +564,7 @@ int CameraHal::setParameters(const CameraParameters& params)
                 mVideoHeight = h;
                 CAMHAL_LOGVB("%s Video Width=%d Height=%d\n", __FUNCTION__, mVideoWidth, mVideoHeight);
 
-                setPreferredPreviewRes(w, h);
+                //setPreferredPreviewRes(w, h);
                 mParameters.getPreviewSize(&w, &h);
                 CAMHAL_LOGVB("%s Preview Width=%d Height=%d\n", __FUNCTION__, w, h);
                 //Avoid restarting preview for MMS HACK
@@ -743,10 +743,8 @@ int CameraHal::setParameters(const CameraParameters& params)
         CAMHAL_LOGDB("SET FRAMERATE %d", framerate);
         mParameters.setPreviewFrameRate(framerate);
         valstr = params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE);
-        LOGD("adk;slfjasdf;j %s", valstr);
         if (!valstr) valstr = "";
         mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr);
-        LOGD("line %d", __LINE__);
 
         CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS);
         mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS);
@@ -1946,23 +1944,22 @@ void CameraHal::stopPreview()
     LOG_FUNCTION_NAME;
 
     if( (!previewEnabled() && !mDisplayPaused) || mRecordingEnabled)
-        {
+    {
         LOG_FUNCTION_NAME_EXIT;
         return;
-        }
+    }
 
     bool imageCaptureRunning = (mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE) &&
                                     (mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE);
     if(mDisplayPaused && !imageCaptureRunning)
-        {
+    {
         // Display is paused, which essentially means there is no preview active.
         // Note: this is done so that when stopPreview is called by client after
         // an image capture, we do not de-initialize the camera adapter and
         // restart over again.
-
         return;
-        }
-
+    }
+ 
     forceStopPreview();
 
     // Reset Capture-Mode to default, so that when we switch from VideoRecording
@@ -2051,7 +2048,7 @@ status_t CameraHal::startRecording( )
             ret = allocVideoBufs(mVideoWidth, mVideoHeight, count);
             if ( NO_ERROR != ret )
             {
-                CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
+                CAMHAL_LOGEB("allocVideoBufs returned error 0x%x", ret);
                 mParameters.remove(TICameraParameters::KEY_RECORDING_HINT);
                 return ret;
             }
@@ -2638,59 +2635,58 @@ status_t CameraHal::takePicture( )
     LOG_FUNCTION_NAME;
 
     if(!previewEnabled() && !mDisplayPaused)
-        {
+    {
         LOG_FUNCTION_NAME_EXIT;
         CAMHAL_LOGEA("Preview not started...");
         return NO_INIT;
-        }
+    }
 
     // return error if we are already capturing
-    if ( (mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE &&
-          mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) ||
-         (mCameraAdapter->getState() == CameraAdapter::VIDEO_CAPTURE_STATE &&
-          mCameraAdapter->getNextState() != CameraAdapter::VIDEO_STATE) ) {
+    if((mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE &&
+      mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) ||
+      (mCameraAdapter->getState() == CameraAdapter::VIDEO_CAPTURE_STATE &&
+      mCameraAdapter->getNextState() != CameraAdapter::VIDEO_STATE) ) {
         CAMHAL_LOGEA("Already capturing an image...");
         return NO_INIT;
     }
 
     // we only support video snapshot if we are in video mode (recording hint is set)
     valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
-    if ( (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE) &&
-         (valstr && strcmp(valstr, TICameraParameters::VIDEO_MODE)) ) {
+    if((mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE) &&
+      (valstr && strcmp(valstr, TICameraParameters::VIDEO_MODE)) ) {
         CAMHAL_LOGEA("Trying to capture while recording without recording hint set...");
         return INVALID_OPERATION;
     }
 
     if ( !mBracketingRunning )
+    {
+        if ( NO_ERROR == ret )
         {
+            burst = mParameters.getInt(TICameraParameters::KEY_BURST);
+        }
 
-         if ( NO_ERROR == ret )
+        //Allocate all buffers only in burst capture case
+        if ( burst > 1 )
+        {
+            bufferCount = CameraHal::NO_BUFFERS_IMAGE_CAPTURE;
+            if ( NULL != mAppCallbackNotifier.get() )
             {
-            burst = mParameters.getInt(TICameraParameters::KEY_BURST);
+                mAppCallbackNotifier->setBurst(true);
             }
-
-         //Allocate all buffers only in burst capture case
-         if ( burst > 1 )
-             {
-             bufferCount = CameraHal::NO_BUFFERS_IMAGE_CAPTURE;
-             if ( NULL != mAppCallbackNotifier.get() )
-                 {
-                 mAppCallbackNotifier->setBurst(true);
-                 }
-             }
-         else
-             {
-             if ( NULL != mAppCallbackNotifier.get() )
-                 {
-                 mAppCallbackNotifier->setBurst(false);
-                 }
-             }
+        }
+        else
+        {
+            if ( NULL != mAppCallbackNotifier.get() )
+            {
+                mAppCallbackNotifier->setBurst(false);
+            }
+        }
 
         // pause preview during normal image capture
         // do not pause preview if recording (video state)
         if (NO_ERROR == ret &&
-                NULL != mDisplayAdapter.get() &&
-                burst < 1) {
+            NULL != mDisplayAdapter.get() &&
+            burst < 1) {
             if (mCameraAdapter->getState() != CameraAdapter::VIDEO_STATE) {
                 mDisplayPaused = true;
                 mPreviewEnabled = false;
@@ -2717,20 +2713,20 @@ status_t CameraHal::takePicture( )
         }
 
         if ( (NO_ERROR == ret) && (NULL != mCameraAdapter) )
-            {
+        {
             if ( NO_ERROR == ret )
                 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
                                                   ( int ) &frame,
                                                   bufferCount);
 
             if ( NO_ERROR != ret )
-                {
+            {
                 CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
-                }
             }
+        }
 
         if ( NO_ERROR == ret )
-            {
+        {
             mParameters.getPictureSize(( int * ) &frame.mWidth,
                                        ( int * ) &frame.mHeight);
 
@@ -2740,13 +2736,13 @@ status_t CameraHal::takePicture( )
                                  mParameters.getPictureFormat(),
                                  bufferCount);
             if ( NO_ERROR != ret )
-                {
+            {
                 CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
-                }
             }
+        }
 
         if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
-            {
+        {
             desc.mBuffers = mImageBufs;
             desc.mOffsets = mImageOffsets;
             desc.mFd = mImageFd;
@@ -2754,26 +2750,19 @@ status_t CameraHal::takePicture( )
             desc.mCount = ( size_t ) bufferCount;
             desc.mMaxQueueable = ( size_t ) bufferCount;
 
-            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
-                                              ( int ) &desc);
-            }
+            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE, ( int ) &desc);
         }
+    }
 
     if ( ( NO_ERROR == ret ) && ( NULL != mCameraAdapter ) )
-        {
-
+    {
 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
-
          //pass capture timestamp along with the camera adapter command
         ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE,  (int) &mStartCapture);
-
 #else
-
         ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE);
-
 #endif
-
-        }
+    }
 
     return ret;
 }
@@ -3232,6 +3221,45 @@ fail_loop:
 
 }
 
+#ifdef AML_CAMERA_BY_VM_INTERFACE
+//By vm driver, the resolution only need be smaller the max preview size. (1920*1080)
+bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions)
+{
+    bool ret = false;
+    status_t status = NO_ERROR;
+    char *pos = NULL;
+    unsigned int supported_w = 0,  supported_h = 0;
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == supportedResolutions )
+    {
+        CAMHAL_LOGEA("Invalid supported resolutions string");
+        ret = false;
+        goto exit;
+    }
+    pos = (char *)supportedResolutions;
+    while(pos != NULL){
+        if (sscanf(pos, "%dx%d", &supported_w, &supported_h) != 2){
+            CAMHAL_LOGEB("Read supported resolutions string error!(%s)",pos);
+            ret = false;
+            break;
+        }
+        //CAMHAL_LOGVB("Read supported resolutions %dx%d",supported_w,supported_h);
+        if((width<=supported_w)&&(height<=supported_h)){
+            ret = true;
+            break;
+        }
+        pos = strchr(pos, ',');
+        if(pos)
+            pos++;
+    }
+
+exit:
+
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+#else
 bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions)
 {
     bool ret = true;
@@ -3272,7 +3300,7 @@ exit:
 
     return ret;
 }
-
+#endif
 bool CameraHal::isParameterValid(const char *param, const char *supportedParams)
 {
     bool ret = true;
@@ -3701,27 +3729,27 @@ void CameraHal::selectFPSRange(int framerate, int *min_fps, int *max_fps)
 
 void CameraHal::setPreferredPreviewRes(int width, int height)
 {
-  LOG_FUNCTION_NAME;
+    LOG_FUNCTION_NAME;
 
-  if ( (width == 320) && (height == 240)){
-    mParameters.setPreviewSize(640,480);
-  }
-  if ( (width == 176) && (height == 144)){
-    mParameters.setPreviewSize(704,576);
-  }
+    if ( (width == 320) && (height == 240)){
+        mParameters.setPreviewSize(640,480);
+    }
+    if ( (width == 176) && (height == 144)){
+        mParameters.setPreviewSize(704,576);
+    }
 
-  LOG_FUNCTION_NAME_EXIT;
+    LOG_FUNCTION_NAME_EXIT;
 }
 
 void CameraHal::resetPreviewRes(CameraParameters *mParams, int width, int height)
 {
-  LOG_FUNCTION_NAME;
+    LOG_FUNCTION_NAME;
 
-  if ( (width <= 320) && (height <= 240)){
-    mParams->setPreviewSize(mVideoWidth, mVideoHeight);
-  }
+    if ( (width <= 320) && (height <= 240)){
+        mParams->setPreviewSize(mVideoWidth, mVideoHeight);
+    }
 
-  LOG_FUNCTION_NAME_EXIT;
+    LOG_FUNCTION_NAME_EXIT;
 }
 
 };
diff --git a/Encoder_libjpeg.cpp b/Encoder_libjpeg.cpp
index b4ccf4a..2cad9a2 100644..100755
--- a/Encoder_libjpeg.cpp
+++ b/Encoder_libjpeg.cpp
@@ -150,7 +150,7 @@ static void uyvy_to_yuv(uint8_t* dst, uint32_t* src, int width) {
         "   blt 5f                                                      \n\t"
         "0: @ 16 pixel swap                                             \n\t"
         "   vld2.8  {q0, q1} , [%[src]]! @ q0 = uv q1 = y               \n\t"
-        "   vuzp.8 q0, q2                @ d1 = u d5 = v                \n\t"
+        "   vuzp.8 q0, q2                @ d0 = u d4 = v                \n\t"
         "   vmov d1, d0                  @ q0 = u0u1u2..u0u1u2...       \n\t"
         "   vmov d5, d4                  @ q2 = v0v1v2..v0v1v2...       \n\t"
         "   vzip.8 d0, d1                @ q0 = u0u0u1u1u2u2...         \n\t"
@@ -172,6 +172,61 @@ static void uyvy_to_yuv(uint8_t* dst, uint32_t* src, int width) {
     }
 }
 
+static void yuyv_to_yuv(uint8_t* dst, uint32_t* src, int width) {
+    if (!dst || !src) {
+        return;
+    }
+
+    if (width % 2) {
+        return; // not supporting odd widths
+    }
+
+    // currently, neon routine only supports multiple of 16 width
+    if (width % 16) {
+        while ((width-=2) >= 0) {
+            uint8_t y0 = (src[0] >> 0) & 0xFF;
+            uint8_t u0 = (src[0] >> 8) & 0xFF;
+            uint8_t y1 = (src[0] >> 16) & 0xFF;
+            uint8_t v0 = (src[0] >> 24) & 0xFF;
+            dst[0] = y0;
+            dst[1] = u0;
+            dst[2] = v0;
+            dst[3] = y1;
+            dst[4] = u0;
+            dst[5] = v0;
+            dst += 6;
+            src++;
+        }
+    } else {
+        int n = width;
+        asm volatile (
+        "   pld [%[src], %[src_stride], lsl #2]                         \n\t"
+        "   cmp %[n], #16                                               \n\t"
+        "   blt 5f                                                      \n\t"
+        "0: @ 16 pixel swap                                             \n\t"
+        "   vld2.8  {q0, q1} , [%[src]]! @ q0 = y q1 = uv               \n\t"
+        "   vuzp.8 q1, q2                @ d2 = u d4 = v                \n\t"
+        "   vmov d3, d2                  @ q1 = u0u1u2..u0u1u2...       \n\t"
+        "   vmov d5, d4                  @ q2 = v0v1v2..v0v1v2...       \n\t"
+        "   vzip.8 d2, d3                @ q1 = u0u0u1u1u2u2...         \n\t"
+        "   vzip.8 d4, d5                @ q2 = v0v0v1v1v2v2...         \n\t"
+        "   vst3.8  {d0,d2,d4},[%[dst]]!                                \n\t"
+        "   vst3.8  {d1,d3,d5},[%[dst]]!                                \n\t"
+        "   sub %[n], %[n], #16                                         \n\t"
+        "   cmp %[n], #16                                               \n\t"
+        "   bge 0b                                                      \n\t"
+        "5: @ end                                                       \n\t"
+#ifdef NEEDS_ARM_ERRATA_754319_754320
+        "   vmov s0,s0  @ add noop for errata item                      \n\t"
+#endif
+        : [dst] "+r" (dst), [src] "+r" (src), [n] "+r" (n)
+        : [src_stride] "r" (width)
+        : "cc", "memory", "q0", "q1", "q2"
+        );
+    }
+}
+
+
 static void resize_nv12(Encoder_libjpeg::params* params, uint8_t* dst_buffer) {
     structConvImage o_img_ptr, i_img_ptr;
 
@@ -445,7 +500,8 @@ size_t Encoder_libjpeg::encode(params* input) {
             if (informat == Encoder_libjpeg::YUV420SP) {
                 nv21_to_yuv(row_tmp, row_src, row_uv, out_width);
             } else if (informat == Encoder_libjpeg::YUV422I) {
-                uyvy_to_yuv(row_tmp, (uint32_t*)row_src, out_width);
+                //uyvy_to_yuv(row_tmp, (uint32_t*)row_src, out_width);
+                yuyv_to_yuv(row_tmp, (uint32_t*)row_src, out_width);
             }
 
             row[0] = row_tmp;
diff --git a/V4LCameraAdapter/V4LCameraAdapter.cpp b/V4LCameraAdapter/V4LCameraAdapter.cpp
index 46f092b..abf6244 100755
--- a/V4LCameraAdapter/V4LCameraAdapter.cpp
+++ b/V4LCameraAdapter/V4LCameraAdapter.cpp
@@ -86,6 +86,7 @@ extern "C" int set_white_balance(int camera_fd,const char *swb);
 
 
 /*--------------------junk STARTS here-----------------------------*/
+#ifndef AMLOGIC_USB_CAMERA_SUPPORT
 #define SYSFILE_CAMERA_SET_PARA "/sys/class/vm/attr2"
 #define SYSFILE_CAMERA_SET_MIRROR "/sys/class/vm/mirror"
 static int writefile(char* path,char* content)
@@ -107,7 +108,7 @@ static int writefile(char* path,char* content)
         LOGD("open file fail\n");
     return 1;
 }
-
+#endif
 /*--------------------Camera Adapter Class STARTS here-----------------------------*/
 
 status_t V4LCameraAdapter::initialize(CameraProperties::Properties* caps)
@@ -163,10 +164,11 @@ status_t V4LCameraAdapter::initialize(CameraProperties::Properties* caps)
     mVideoInfo->isStreaming = false;
     mRecording = false;
 
+#ifndef AMLOGIC_USB_CAMERA_SUPPORT
     // ---------
     writefile((char*)SYSFILE_CAMERA_SET_PARA, (char*)"1");
     //mirror set at here will not work.
-
+#endif
     LOG_FUNCTION_NAME_EXIT;
 
     return ret;
@@ -295,7 +297,7 @@ status_t V4LCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, si
     {
         case CAMERA_PREVIEW:
             ret = UseBuffersPreview(bufArr, num);
-            maxQueueable = queueable;
+            //maxQueueable = queueable;
             break;
         case CAMERA_IMAGE_CAPTURE:
             ret = UseBuffersCapture(bufArr, num);
@@ -303,6 +305,7 @@ status_t V4LCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, si
         case CAMERA_VIDEO:
             //@warn Video capture is not fully supported yet
             ret = UseBuffersPreview(bufArr, num);
+            //maxQueueable = queueable;
             break;
     }
 
@@ -347,8 +350,11 @@ status_t V4LCameraAdapter::UseBuffersPreview(void* bufArr, int num)
 
     int width, height;
     mParams.getPreviewSize(&width, &height);
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+    setBuffersFormat(width, height, V4L2_PIX_FMT_YUYV);
+#else
     setBuffersFormat(width, height, DEFAULT_PREVIEW_PIXEL_FORMAT);
-
+#endif
     //First allocate adapter internal buffers at V4L level for USB Cam
     //These are the buffers from which we will copy the data into overlay buffers
     /* Check if camera can handle NB_BUFFER buffers */
@@ -490,7 +496,8 @@ status_t V4LCameraAdapter::takePicture()
 status_t V4LCameraAdapter::startPreview()
 {
     status_t ret = NO_ERROR;
-
+    int frame_count = 0,ret_c = 0;
+    void *frame_buf = NULL;
     Mutex::Autolock lock(mPreviewBufsLock);
 
     if(mPreviewing)
@@ -498,19 +505,35 @@ status_t V4LCameraAdapter::startPreview()
         return BAD_VALUE;
     }
 
+#ifndef AMLOGIC_USB_CAMERA_SUPPORT
     writefile(SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
+#endif
+
     nQueued = 0;
-    for (int i = 0; i < maxQueueable; i++) 
+    for (int i = 0; i < mPreviewBufferCount; 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) {
+        frame_count = -1;
+        frame_buf = (void *)mPreviewBufs.keyAt(i);
+
+        if((ret_c = getFrameRefCount(frame_buf,CameraFrame::PREVIEW_FRAME_SYNC))>=0)
+            frame_count = ret_c;
+
+        //if((ret_c = getFrameRefCount(frame_buf,CameraFrame::VIDEO_FRAME_SYNC))>=0)
+        //    frame_count += ret_c;
+ 
+        CAMHAL_LOGDB("startPreview--buffer address:0x%x, refcount:%d",(uint32_t)frame_buf,frame_count);
+        if(frame_count>0)
+            continue;
+        //mVideoInfo->buf.index = i;
+        mVideoInfo->buf.index = mPreviewBufs.valueFor((uint32_t)frame_buf);
+        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);
+        CAMHAL_LOGDB("startPreview --length=%d, index:%d", mVideoInfo->buf.length,mVideoInfo->buf.index);
         nQueued++;
     }
 
@@ -632,8 +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);
-    length = width * height * 3; //rgb24
+    if(DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT == V4L2_PIX_FMT_RGB24){ // rgb24
+        bytes_per_pixel =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 * bytes_per_pixel;
     return NO_ERROR;
 }
 
@@ -760,7 +791,21 @@ int V4LCameraAdapter::previewThread()
         int width, height;
         uint8_t* src = (uint8_t*) fp;
         mParams.getPreviewSize(&width, &height);
-        memcpy(dest,src,width*height*3/2);
+        if(DEFAULT_PREVIEW_PIXEL_FORMAT == V4L2_PIX_FMT_YUYV){ // 422I
+            frame.mLength = width*height*2;
+            memcpy(dest,src,frame.mLength);
+        }else if(DEFAULT_PREVIEW_PIXEL_FORMAT == V4L2_PIX_FMT_NV21){ //420sp
+            frame.mLength = width*height*3/2;
+#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/2;
+            memcpy(dest,src,frame.mLength);            
+        }
 
         frame.mFrameMask |= CameraFrame::PREVIEW_FRAME_SYNC;
         
@@ -768,14 +813,13 @@ int V4LCameraAdapter::previewThread()
             frame.mFrameMask |= CameraFrame::VIDEO_FRAME_SYNC;
         }
         frame.mBuffer = ptr; //dest
-        frame.mLength = width*height*3/2;
         frame.mAlignment = width;
         frame.mOffset = 0;
         frame.mYuv[0] = NULL;
         frame.mYuv[1] = NULL;
         frame.mWidth = width;
         frame.mHeight = height;
-        frame.mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);;
+        frame.mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
         ret = setInitFrameRefCount(frame.mBuffer, frame.mFrameMask);
         if (ret)
             LOGE("setInitFrameRefCount err=%d", ret);
@@ -950,7 +994,9 @@ int V4LCameraAdapter::pictureThread()
     int width, height;
     CameraFrame frame;
 
+#ifndef AMLOGIC_USB_CAMERA_SUPPORT
     writefile(SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
+#endif
 
     if (true)
     {
@@ -998,6 +1044,16 @@ int V4LCameraAdapter::pictureThread()
         LOGD("pictureThread mCaptureBuf=%#x dest=%#x fp=%#x width=%d height=%d", mCaptureBuf, dest, fp, width, height);
         LOGD("length=%d bytesused=%d index=%d", mVideoInfo->buf.length, mVideoInfo->buf.bytesused, index);
 
+        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;
+        }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;
+        }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);
 
         notifyShutterSubscribers();
@@ -1011,11 +1067,9 @@ int V4LCameraAdapter::pictureThread()
 
         frame.mFrameMask = CameraFrame::IMAGE_FRAME;
         frame.mFrameType = CameraFrame::IMAGE_FRAME;
-        frame.mQuirks = CameraFrame::ENCODE_RAW_RGB24_TO_JPEG | CameraFrame::HAS_EXIF_DATA;
         frame.mBuffer = mCaptureBuf->data;
         frame.mCookie2 = (void*)exiftable;
-        frame.mLength = width*height*2;
-        frame.mAlignment = width*2;
+        frame.mAlignment = width;
         frame.mOffset = 0;
         frame.mYuv[0] = NULL;
         frame.mYuv[1] = NULL;
@@ -1026,7 +1080,6 @@ int V4LCameraAdapter::pictureThread()
         if (mVideoInfo->isStreaming) 
         {
             bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
             ret = ioctl (mCameraHandle, VIDIOC_STREAMOFF, &bufType);
             if (ret < 0) 
             {
@@ -1051,10 +1104,9 @@ int V4LCameraAdapter::pictureThread()
     // start preview thread again after stopping it in UseBuffersCapture
     {
         Mutex::Autolock lock(mPreviewBufferLock);
-        UseBuffersPreview(mPreviewBuffers, mPreviewBufferCount);
-        startPreview();
+        UseBuffersPreview(mPreviewBuffers, mPreviewBufferCount);        
     }
-
+    startPreview();
 
     ret = setInitFrameRefCount(frame.mBuffer, frame.mFrameMask);
     if (ret)
@@ -1117,11 +1169,11 @@ extern "C" int CameraAdapter_Capabilities(CameraProperties::Properties* properti
 static int iCamerasNum = -1;
 extern "C"  int CameraAdapter_CameraNum()
 {
-    LOGD("CameraAdapter_CameraNum %d",iCamerasNum);
-
-#if defined(AMLOGIC_FRONT_CAMERA_SUPPORT) || defined(AMLOGIC_BACK_CAMERA_SUPPORT)
-   return MAX_CAMERAS_SUPPORTED;
+#if defined(AMLOGIC_FRONT_CAMERA_SUPPORT) || defined(AMLOGIC_BACK_CAMERA_SUPPORT) ||defined(AMLOGIC_USB_CAMERA_SUPPORT)
+    LOGD("CameraAdapter_CameraNum %d",MAX_CAMERAS_SUPPORTED);
+    return MAX_CAMERAS_SUPPORTED;
 #else
+    LOGD("CameraAdapter_CameraNum %d",iCamerasNum);
     if(iCamerasNum == -1) 
     {
         iCamerasNum = 0;
@@ -1181,7 +1233,8 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     const char DEFAULT_ISO_MODE[] = "auto";
     const char DEFAULT_PICTURE_FORMAT[] = "jpeg";
     const char DEFAULT_PICTURE_SIZE[] = "640x480";
-    const char DEFAULT_PREVIEW_FORMAT[] = "yuv420sp";
+    const char PREVIEW_FORMAT_420SP[] = "yuv420sp";
+    const char PREVIEW_FORMAT_422I[] = "yuv422i-yuyv";
     const char DEFAULT_PREVIEW_SIZE[] = "640x480";
     const char DEFAULT_NUM_PREV_BUFS[] = "6";
     const char DEFAULT_NUM_PIC_BUFS[] = "1";
@@ -1212,6 +1265,8 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
         bFrontCam = false;
 #elif defined(AMLOGIC_FRONT_CAMERA_SUPPORT)
         bFrontCam = true;
+#elif defined(AMLOGIC_USB_CAMERA_SUPPORT)
+        bFrontCam = true;
 #else//defined nothing, we try by ourself
         if(CameraAdapter_CameraNum() > 1) { //when have more than one cameras, this 0 is backcamera
             bFrontCam = false;
@@ -1234,14 +1289,29 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     //should changed while the screen orientation changed.
     if(bFrontCam == true) {
         params->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_FRONT);
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+        params->set(CameraProperties::ORIENTATION_INDEX,"0");
+#else
         params->set(CameraProperties::ORIENTATION_INDEX,"270");
+#endif
     } else {
         params->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_BACK);
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+        params->set(CameraProperties::ORIENTATION_INDEX,"180");
+#else
         params->set(CameraProperties::ORIENTATION_INDEX,"90");
+#endif
+    }
+    if(DEFAULT_PREVIEW_PIXEL_FORMAT == V4L2_PIX_FMT_YUYV){ // 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::PREVIEW_FORMAT,PREVIEW_FORMAT_420SP);
+    }else{ //default case
+        params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS,PREVIEW_FORMAT_420SP);
+        params->set(CameraProperties::PREVIEW_FORMAT,PREVIEW_FORMAT_420SP);
     }
-
-    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");
@@ -1253,25 +1323,52 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
 
 	//get preview size & set
     char sizes[64];
-    if (!getValidFrameSize(camera_id, DEFAULT_PREVIEW_PIXEL_FORMAT, sizes)) {
+    uint32_t preview_format = DEFAULT_PREVIEW_PIXEL_FORMAT;
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+    preview_format = V4L2_PIX_FMT_YUYV;
+#endif
+    if (!getValidFrameSize(camera_id, preview_format, sizes)) {
         int len = strlen(sizes);
+        unsigned int supported_w = 0,  supported_h = 0,w = 0,h = 0;
         if(len>1){
             if(sizes[len-1] == ',')
                 sizes[len-1] = '\0';
         }
         params->set(CameraProperties::SUPPORTED_PREVIEW_SIZES, sizes);
         //set last size as default
-        char * b = strrchr(sizes, ',');
-        if (b) 
-            b++;
-        else 
-            b = sizes;
-        params->set(CameraProperties::PREVIEW_SIZE, b);
+        char * b = (char *)sizes;
+        while(b != NULL){
+            if (sscanf(b, "%dx%d", &supported_w, &supported_h) != 2){
+                break;
+            }
+            if((supported_w*supported_h)>(w*h)){
+                w = supported_w;
+                h = supported_h;
+            }
+            b = strchr(b, ',');
+            if(b)
+                b++;
+        }
+        if((w>0)&&(h>0)){
+            memset(sizes, 0, sizeof(sizes));
+            sprintf(sizes,"%dx%d",w,h);
+        }
+        //char * b = strrchr(sizes, ',');
+        //if (b) 
+        //    b++;
+        //else 
+        //    b = sizes;
+        params->set(CameraProperties::PREVIEW_SIZE, sizes);
     }
     else
     {
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+        params->set(CameraProperties::SUPPORTED_PREVIEW_SIZES, "320x240,176x144,160x120");
+        params->set(CameraProperties::PREVIEW_SIZE,"320x240");
+#else
         params->set(CameraProperties::SUPPORTED_PREVIEW_SIZES, "352x288,640x480");
         params->set(CameraProperties::PREVIEW_SIZE,"640x480");
+#endif
     }
 
     params->set(CameraProperties::SUPPORTED_PICTURE_FORMATS, DEFAULT_PICTURE_FORMAT);
@@ -1286,21 +1383,46 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     //get & set picture size
     if (!getValidFrameSize(camera_id, DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT, sizes)) {
         int len = strlen(sizes);
+        unsigned int supported_w = 0,  supported_h = 0,w = 0,h = 0;
         if(len>1){
             if(sizes[len-1] == ',')
                 sizes[len-1] = '\0';
         }
         params->set(CameraProperties::SUPPORTED_PICTURE_SIZES, sizes);
         //set last size as default
-        char * b = strrchr(sizes, ',');
-        if (b) b++;
-        else b = sizes;
-        params->set(CameraProperties::PICTURE_SIZE, b);
+        char * b = (char *)sizes;
+        while(b != NULL){
+            if (sscanf(b, "%dx%d", &supported_w, &supported_h) != 2){
+                break;
+            }
+            if((supported_w*supported_h)>(w*h)){
+                w = supported_w;
+                h = supported_h;
+            }
+            b = strchr(b, ',');
+            if(b)
+                b++;
+        }
+        if((w>0)&&(h>0)){
+            memset(sizes, 0, sizeof(sizes));
+            sprintf(sizes,"%dx%d",w,h);
+        }
+        //char * b = strrchr(sizes, ',');
+        //if (b) 
+        //    b++;
+        //else 
+        //    b = sizes;
+        params->set(CameraProperties::PICTURE_SIZE, sizes);
     } 
     else
     {
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+        params->set(CameraProperties::SUPPORTED_PICTURE_SIZES, "320x240");
+        params->set(CameraProperties::PICTURE_SIZE,"320x240");
+#else
         params->set(CameraProperties::SUPPORTED_PICTURE_SIZES, "640x480");
-        params->set(CameraProperties::PICTURE_SIZE, "640x480");
+        params->set(CameraProperties::PICTURE_SIZE,"640x480");
+#endif
     }
 
     params->set(CameraProperties::SUPPORTED_FOCUS_MODES, "fixed");
@@ -1374,9 +1496,13 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     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);
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+    params->set(CameraProperties::VIDEO_SIZE,params->get(CameraProperties::PREVIEW_SIZE));
+    params->set(CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO,params->get(CameraProperties::PREVIEW_SIZE));
+#else
     params->set(CameraProperties::VIDEO_SIZE, DEFAULT_VIDEO_SIZE);
     params->set(CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO, DEFAULT_PREFERRED_PREVIEW_SIZE_FOR_VIDEO);
-
+#endif
 }
 
 extern "C" int set_white_balance(int camera_fd,const char *swb)
@@ -1397,11 +1523,9 @@ extern "C" int set_white_balance(int camera_fd,const char *swb)
     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 !! ");
-    }
+    ret = ioctl(camera_fd, VIDIOC_S_CTRL, &ctl);
+    if(ret<0)
+        CAMHAL_LOGEB("AMLOGIC CAMERA Set white balance fail: %s. ret=%d", strerror(errno),ret);
     return ret ;
 }
 
@@ -1432,11 +1556,9 @@ extern "C" int SetExposure(int camera_fd,const char *sbn)
     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 !! ");
-    }
+    ret = ioctl(camera_fd, VIDIOC_S_CTRL, &ctl);
+    if(ret<0)
+        CAMHAL_LOGEB("AMLOGIC CAMERA Set Exposure fail: %s. ret=%d", strerror(errno),ret);
 
     return ret ;
 }
@@ -1456,14 +1578,10 @@ extern "C" int set_effect(int camera_fd,const char *sef)
         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 ;
+    ret = ioctl(camera_fd, VIDIOC_S_CTRL, &ctl);
+    if(ret<0)
+        CAMHAL_LOGEB("AMLOGIC CAMERA Set effect fail: %s. ret=%d", strerror(errno),ret);
+     return ret ;
 }
 
 extern "C" int set_night_mode(int camera_fd,const char *snm)
@@ -1480,12 +1598,10 @@ extern "C" int set_night_mode(int camera_fd,const char *snm)
 
     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 ;
+    ret = ioctl(camera_fd, VIDIOC_S_CTRL, &ctl);
+    if(ret<0)
+        CAMHAL_LOGEB("AMLOGIC CAMERA Set night mode fail: %s. ret=%d", strerror(errno),ret);
+     return ret ;
 }
 
 extern "C" int set_banding(int camera_fd,const char *snm)
@@ -1502,11 +1618,9 @@ extern "C" int set_banding(int camera_fd,const char *snm)
 
     ctl.id = V4L2_CID_WHITENESS;
 
-    if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
-    {
-        ret = -1;
-        LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
-    }
+    ret = ioctl(camera_fd, VIDIOC_S_CTRL, &ctl);
+    if(ret<0)
+        CAMHAL_LOGEB("AMLOGIC CAMERA Set banding fail: %s. ret=%d", strerror(errno),ret);
     return ret ;
 }
 
diff --git a/inc/ANativeWindowDisplayAdapter.h b/inc/ANativeWindowDisplayAdapter.h
index 1d1118b..40589ec 100644..100755
--- a/inc/ANativeWindowDisplayAdapter.h
+++ b/inc/ANativeWindowDisplayAdapter.h
@@ -173,6 +173,8 @@ private:
 

     const char *mPixelFormat;

 

+    uint32_t mNativeWindowPixelFormat;

+

 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS

     //Used for calculating standby to first shot

     struct timeval mStandbyToShot;

diff --git a/inc/CameraHal.h b/inc/CameraHal.h
index c6bd54a..781061f 100755
--- a/inc/CameraHal.h
+++ b/inc/CameraHal.h
@@ -42,6 +42,7 @@
 #include "CameraProperties.h"
 #include "DebugUtils.h"
 #include "SensorListener.h"
+#include "util.h"
 
 #include <ui/GraphicBufferAllocator.h>
 #include <ui/GraphicBuffer.h>
@@ -115,6 +116,10 @@
 
 
 //#define AMLOGIC_CAMERA_OVERLAY_SUPPORT
+//#define AMLOGIC_USB_CAMERA_SUPPORT
+#ifndef AMLOGIC_USB_CAMERA_SUPPORT
+#define AML_CAMERA_BY_VM_INTERFACE
+#endif
 
 #define NONNEG_ASSIGN(x,y) \
     if(x > -1) \
diff --git a/inc/CameraProperties.h b/inc/CameraProperties.h
index 70de98d..2fef678 100755
--- a/inc/CameraProperties.h
+++ b/inc/CameraProperties.h
@@ -34,7 +34,7 @@ namespace android {
 

 #if defined(AMLOGIC_FRONT_CAMERA_SUPPORT) && defined(AMLOGIC_BACK_CAMERA_SUPPORT)

 	  #define MAX_CAMERAS_SUPPORTED 2 

-#elif defined(AMLOGIC_FRONT_CAMERA_SUPPORT) || defined(AMLOGIC_BACK_CAMERA_SUPPORT)

+#elif defined(AMLOGIC_FRONT_CAMERA_SUPPORT) || defined(AMLOGIC_BACK_CAMERA_SUPPORT) ||defined(AMLOGIC_USB_CAMERA_SUPPORT)

 	  #define MAX_CAMERAS_SUPPORTED 1 

 #else

     //if didn't define AMLOGIC_FRONT_CAMERA_SUPPORT nor AMLOGIC_BACK_CAMERA_SUPPORT, 

diff --git a/inc/V4LCameraAdapter/V4LCameraAdapter.h b/inc/V4LCameraAdapter/V4LCameraAdapter.h
index e3cf3c5..04ffd22 100755
--- a/inc/V4LCameraAdapter/V4LCameraAdapter.h
+++ b/inc/V4LCameraAdapter/V4LCameraAdapter.h
@@ -26,8 +26,14 @@
 
 namespace android {
 
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+#define DEFAULT_PREVIEW_PIXEL_FORMAT        V4L2_PIX_FMT_NV21
+//#define DEFAULT_PREVIEW_PIXEL_FORMAT        V4L2_PIX_FMT_YUYV
+#define DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT  V4L2_PIX_FMT_YUYV
+#else
 #define DEFAULT_PREVIEW_PIXEL_FORMAT        V4L2_PIX_FMT_NV21
 #define DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT  V4L2_PIX_FMT_RGB24
+#endif
 #define NB_BUFFER 6
 
 struct VideoInfo {
@@ -294,7 +300,7 @@ private:
     int nQueued;
     int nDequeued;
 	
-    int maxQueueable;//the max queued buffers in v4l
+    //int maxQueueable;//the max queued buffers in v4l
 
 };
 }; //// namespace
diff --git a/utils/Android.mk b/utils/Android.mk
index 4b6a2b3..9dd3f92 100755
--- a/utils/Android.mk
+++ b/utils/Android.mk
@@ -9,8 +9,13 @@ LOCAL_PRELINK_MODULE := false
 LOCAL_SRC_FILES:= \
     MessageQueue.cpp \
     Semaphore.cpp \
-    ErrorUtils.cpp
+    ErrorUtils.cpp 
+
     
+ifeq ($(BOARD_USE_USB_CAMERA),true)
+    LOCAL_SRC_FILES += util.cpp
+endif
+
 LOCAL_SHARED_LIBRARIES:= \
     libdl \
     libui \
diff --git a/utils/util.cpp b/utils/util.cpp
new file mode 100755
index 0000000..2dfbd50
--- a/dev/null
+++ b/utils/util.cpp
@@ -0,0 +1,285 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#define swap_cbcr
+static void convert_rgb16_to_nv21(uint8_t *rgb, uint8_t *yuv, int width, int height)
+{
+	int iy =0, iuv = 0;
+    uint8_t* buf_y = yuv;
+    uint8_t* buf_uv = buf_y + width * height;
+    uint16_t* buf_rgb = (uint16_t *)rgb;
+	int h,w,val_rgb,val_r,val_g,val_b;
+	int y,u,v;
+    for (h = 0; h < height; h++) {
+        for (w = 0; w < width; w++) {
+            val_rgb = buf_rgb[h * width + w];
+            val_r = ((val_rgb & (0x1f << 11)) >> 11)<<3;
+            val_g = ((val_rgb & (0x3f << 5)) >> 5)<<2;
+            val_b = ((val_rgb & (0x1f << 0)) >> 0)<<3;
+            y = 0.30078 * val_r + 0.5859 * val_g + 0.11328 * val_b;
+            if (y > 255) {
+                y = 255;
+            } else if (y < 0) {
+                y = 0;
+            }
+            buf_y[iy++] = y;
+            if (0 == h % 2 && 0 == w % 2) {
+                u = -0.11328 * val_r - 0.33984 * val_g + 0.51179 * val_b + 128;
+                if (u > 255) {
+                    u = 255;
+                } else if (u < 0) {
+                    u = 0;
+                }
+                v = 0.51179 * val_r - 0.429688 * val_g - 0.08203 * val_b  + 128;
+                if (v > 255) {
+                    v = 255;
+                } else if (v < 0) {
+                    v = 0;
+                }
+#ifdef swap_cbcr
+                buf_uv[iuv++] = v;
+                buf_uv[iuv++] = u;
+#else
+                buf_uv[iuv++] = u;
+                buf_uv[iuv++] = v;
+#endif
+            }
+        }
+}
+}
+
+static inline void yuv_to_rgb16(unsigned char y,unsigned char u,unsigned char v,unsigned char *rgb)
+{
+    register int r,g,b;
+    int rgb16;
+
+    r = (1192 * (y - 16) + 1634 * (v - 128) ) >> 10;
+    g = (1192 * (y - 16) - 833 * (v - 128) - 400 * (u -128) ) >> 10;
+    b = (1192 * (y - 16) + 2066 * (u - 128) ) >> 10;
+
+    r = r > 255 ? 255 : r < 0 ? 0 : r;
+    g = g > 255 ? 255 : g < 0 ? 0 : g;
+    b = b > 255 ? 255 : b < 0 ? 0 : b;
+
+    rgb16 = (int)(((r >> 3)<<11) | ((g >> 2) << 5)| ((b >> 3) << 0));
+
+    *rgb = (unsigned char)(rgb16 & 0xFF);
+    rgb++;
+    *rgb = (unsigned char)((rgb16 & 0xFF00) >> 8);
+
+}
+
+void yuyv422_to_rgb16(unsigned char *from, unsigned char *to, int size)
+{
+    int x,y,z=0;
+
+    for (y = 0; y < size; y+=4) {
+        unsigned char Y1, Y2, U, V;
+
+        Y1 = from[y + 0];
+        U = from[y + 1];
+        Y2 = from[y + 2];
+        V = from[y + 3];
+
+        yuv_to_rgb16(Y1, U, V, &to[y]);
+        yuv_to_rgb16(Y2, U, V, &to[y + 2]);
+    }
+}
+
+void yuyv422_to_rgb16(unsigned char *from, unsigned char *to, int width, int height)
+{
+    yuyv422_to_rgb16(from,to,(width * height) * 2);
+}
+
+void yuyv422_to_nv21(unsigned char *bufsrc, unsigned char *bufdest, int width, int height)
+{
+    unsigned char *ptrsrcy1, *ptrsrcy2;
+    unsigned char *ptrsrcy3, *ptrsrcy4;
+    unsigned char *ptrsrccb1, *ptrsrccb2;
+    unsigned char *ptrsrccb3, *ptrsrccb4;
+    unsigned char *ptrsrccr1, *ptrsrccr2;
+    unsigned char *ptrsrccr3, *ptrsrccr4;
+    int srcystride, srcccstride;
+
+    ptrsrcy1  = bufsrc ;
+    ptrsrcy2  = bufsrc + (width<<1) ;
+    ptrsrcy3  = bufsrc + (width<<1)*2 ;
+    ptrsrcy4  = bufsrc + (width<<1)*3 ;
+
+    ptrsrccb1 = bufsrc + 1;
+    ptrsrccb2 = bufsrc + (width<<1) + 1;
+    ptrsrccb3 = bufsrc + (width<<1)*2 + 1;
+    ptrsrccb4 = bufsrc + (width<<1)*3 + 1;
+
+    ptrsrccr1 = bufsrc + 3;
+    ptrsrccr2 = bufsrc + (width<<1) + 3;
+    ptrsrccr3 = bufsrc + (width<<1)*2 + 3;
+    ptrsrccr4 = bufsrc + (width<<1)*3 + 3;
+
+    srcystride  = (width<<1)*3;
+    srcccstride = (width<<1)*3;
+
+    unsigned char *ptrdesty1, *ptrdesty2;
+    unsigned char *ptrdesty3, *ptrdesty4;
+    unsigned char *ptrdestcb1, *ptrdestcb2;
+    unsigned char *ptrdestcr1, *ptrdestcr2;
+    int destystride, destccstride;
+
+    ptrdesty1 = bufdest;
+    ptrdesty2 = bufdest + width;
+    ptrdesty3 = bufdest + width*2;
+    ptrdesty4 = bufdest + width*3;
+
+    ptrdestcb1 = bufdest + width*height;
+    ptrdestcb2 = bufdest + width*height + width;
+
+    ptrdestcr1 = bufdest + width*height + 1;
+    ptrdestcr2 = bufdest + width*height + width + 1;
+
+    destystride  = (width)*3;
+    destccstride = width;
+
+    int i, j;
+
+    for(j=0; j<(height/4); j++)
+    {
+        for(i=0;i<(width/2);i++)
+        {
+            (*ptrdesty1++) = (*ptrsrcy1);
+            (*ptrdesty2++) = (*ptrsrcy2);
+            (*ptrdesty3++) = (*ptrsrcy3);
+            (*ptrdesty4++) = (*ptrsrcy4);
+
+            ptrsrcy1 += 2;
+            ptrsrcy2 += 2;
+            ptrsrcy3 += 2;
+            ptrsrcy4 += 2;
+
+            (*ptrdesty1++) = (*ptrsrcy1);
+            (*ptrdesty2++) = (*ptrsrcy2);
+            (*ptrdesty3++) = (*ptrsrcy3);
+            (*ptrdesty4++) = (*ptrsrcy4);
+
+            ptrsrcy1 += 2;
+            ptrsrcy2 += 2;
+            ptrsrcy3 += 2;
+            ptrsrcy4 += 2;
+
+#if 0
+            (*ptrdestcb1) = (*ptrsrccb1);
+            (*ptrdestcb2) = (*ptrsrccb3);
+#else 
+            (*ptrdestcb1) = (*ptrsrccr1);
+            (*ptrdestcb2) = (*ptrsrccr3);
+#endif
+
+#if 0
+            (*ptrdestcr1) = (*ptrsrccr1);
+            (*ptrdestcr2) = (*ptrsrccr3);
+#else 
+            (*ptrdestcr1) = (*ptrsrccb1);
+            (*ptrdestcr2) = (*ptrsrccb3);
+#endif
+            
+            ptrdestcb1 += 2;
+            ptrdestcb2 += 2;
+            ptrdestcr1 += 2;
+            ptrdestcr2 += 2;
+
+            ptrsrccb1 += 4;
+            ptrsrccb3 += 4;
+            ptrsrccr1 += 4;
+            ptrsrccr3 += 4;
+
+        }
+
+
+        /* Update src pointers */
+        ptrsrcy1  += srcystride;
+        ptrsrcy2  += srcystride;
+        ptrsrcy3  += srcystride;
+        ptrsrcy4  += srcystride;
+
+        ptrsrccb1 += srcccstride;
+        ptrsrccb3 += srcccstride;
+
+        ptrsrccr1 += srcccstride;
+        ptrsrccr3 += srcccstride;
+
+
+        /* Update dest pointers */
+        ptrdesty1 += destystride;
+        ptrdesty2 += destystride;
+        ptrdesty3 += destystride;
+        ptrdesty4 += destystride;
+
+        ptrdestcb1 += destccstride;
+        ptrdestcb2 += destccstride;
+
+        ptrdestcr1 += destccstride;
+        ptrdestcr2 += destccstride;
+
+    }
+}
+
+static inline void yuv_to_rgb24(unsigned char y,unsigned char u,unsigned char v,unsigned char *rgb)
+{
+    register int r,g,b;
+    int rgb24;
+
+    r = (1192 * (y - 16) + 1634 * (v - 128) ) >> 10;
+    g = (1192 * (y - 16) - 833 * (v - 128) - 400 * (u -128) ) >> 10;
+    b = (1192 * (y - 16) + 2066 * (u - 128) ) >> 10;
+
+    r = r > 255 ? 255 : r < 0 ? 0 : r;
+    g = g > 255 ? 255 : g < 0 ? 0 : g;
+    b = b > 255 ? 255 : b < 0 ? 0 : b;
+
+    rgb24 = (int)((r <<16) | (g  << 8)| b);
+
+    *rgb = (unsigned char)r;
+    rgb++;
+    *rgb = (unsigned char)g;
+    rgb++;
+    *rgb = (unsigned char)b;
+}
+
+void yuyv422_to_rgb24(unsigned char *buf, unsigned char *rgb, int width, int height)
+{
+    int x,y,z=0;
+    int blocks;
+
+    blocks = (width * height) * 2;
+
+    for (y = 0,z=0; y < blocks; y+=4,z+=6) {
+        unsigned char Y1, Y2, U, V;
+
+        Y1 = buf[y + 0];
+        U = buf[y + 1];
+        Y2 = buf[y + 2];
+        V = buf[y + 3];
+
+        yuv_to_rgb24(Y1, U, V, &rgb[z]);
+        yuv_to_rgb24(Y2, U, V, &rgb[z + 3]);
+
+    }
+}
+
+void convert_rgb24_to_rgb16(uint8_t *src, uint8_t *dst, int width, int height)
+{
+	int src_len = width*height*3;
+    int i = 0;
+	int j = 0;
+    
+    for (i = 0; i < src_len; i += 3)
+    {
+		dst[j] = (src[i]&0x1f) | (src[i+1]>>5);
+		dst[j+1] = ((src[i+1]>>2)<<5) | (src[i+2]>>3);
+        j += 2;
+    }
+}
+
diff --git a/utils/util.h b/utils/util.h
new file mode 100755
index 0000000..b60aeee
--- a/dev/null
+++ b/utils/util.h
@@ -0,0 +1,10 @@
+#ifndef AML_CAMERA_HARDWARE_INCLUDE_
+#define AML_CAMERA_HARDWARE_INCLUDE_
+
+void convert_rgb16_to_nv21(uint8_t *rgb, uint8_t *yuv, int width, int height);
+void convert_rgb24_to_rgb16(uint8_t *rgb888, uint8_t *rgb565, int width, int height);
+void yuyv422_to_rgb16(unsigned char *from, unsigned char *to, int width,int height);
+void yuyv422_to_rgb16(unsigned char *from, unsigned char *to, int size);
+void yuyv422_to_rgb24(unsigned char *buf, unsigned char *rgb, int width, int height);
+void yuyv422_to_nv21(unsigned char *bufsrc, unsigned char *bufdest, int width, int height);
+#endif /* AML_CAMERA_HARDWARE_INCLUDE_*/