remove NV12 convert to NV21 process because the data from V4L2 is already NV21

5 files changed, 254 insertions, 189 deletions

diff --git a/ANativeWindowDisplayAdapter.cpp b/ANativeWindowDisplayAdapter.cpp
index 1610fa2..65765bf 100644..100755
--- a/ANativeWindowDisplayAdapter.cpp
+++ b/ANativeWindowDisplayAdapter.cpp
@@ -1037,19 +1037,19 @@ status_t ANativeWindowDisplayAdapter::PostFrame(ANativeWindowDisplayAdapter::Dis
             uint8_t bytesPerPixel;
             ///Calculate bytes per pixel based on the pixel format
             if(strcmp(mPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
-                {
+            {
                 bytesPerPixel = 2;
-                }
+            }
             else if(strcmp(mPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
-                {
+            {
                 bytesPerPixel = 2;
-                }
+            }
             else if(strcmp(mPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0)
-                {
+            {
                 bytesPerPixel = 1;
-                }
+            }
             else
-                {
+            {
                 bytesPerPixel = 1;
             }
 
diff --git a/AppCallbackNotifier.cpp b/AppCallbackNotifier.cpp
index 4f21590..276ae25 100755
--- a/AppCallbackNotifier.cpp
+++ b/AppCallbackNotifier.cpp
@@ -194,7 +194,8 @@ status_t AppCallbackNotifier::initialize()
         return ret;
         }
 
-    mUseMetaDataBufferMode = true;
+    mUseMetaDataBufferMode = false;
+    mUseVideoBuffers = false;
     mRawAvailable = false;
 
     LOG_FUNCTION_NAME_EXIT;
@@ -482,14 +483,14 @@ static void copy2Dto1D(void *dst,
                 }
             }
 
-           // bufferSrc_UV = ( uint16_t * ) ((uint8_t*)y_uv[1] + (stride/2)*yOff + xOff);
-			bufferSrc_UV =( uint16_t * ) ( y_uv[0]+stride*height+ (stride/2)*yOff + xOff) ;
+            //bufferSrc_UV = ( uint16_t * ) ((uint8_t*)y_uv[1] + (stride/2)*yOff + xOff);
+            bufferSrc_UV =( uint16_t * ) ( y_uv[0]+stride*height+ (stride/2)*yOff + xOff) ;
             if (strcmp(pixelFormat, CameraParameters::PIXEL_FORMAT_YUV420SP) == 0) {
-                 uint16_t *bufferDst_UV;
-
-                // Step 2: UV plane: convert NV12 to NV21 by swapping U & V
+                uint16_t *bufferDst_UV;
                 bufferDst_UV = (uint16_t *) (((uint8_t*)dst)+row*height);
-
+                memcpy(bufferDst_UV, bufferSrc_UV, stride*height/2);
+#if 0
+                // Step 2: UV plane: convert NV12 to NV21 by swapping U & V
                 for (int i = 0 ; i < height/2 ; i++, bufferSrc_UV += alignedRow/2) {
                     int n = width;
                     asm volatile (
@@ -532,6 +533,7 @@ static void copy2Dto1D(void *dst,
                     : "cc", "memory", "q0", "q1"
                     );
                 }
+#endif
             } else if (strcmp(pixelFormat, CameraParameters::PIXEL_FORMAT_YUV420P) == 0) {
                  uint16_t *bufferDst_U;
                  uint16_t *bufferDst_V;
@@ -646,6 +648,7 @@ void AppCallbackNotifier::copyAndSendPreviewFrame(CameraFrame* frame, int32_t ms
 {
     camera_memory_t* picture = NULL;
     void* dest = NULL;
+    uint8_t* src = NULL;
 
     // scope for lock
     {
@@ -660,6 +663,17 @@ void AppCallbackNotifier::copyAndSendPreviewFrame(CameraFrame* frame, int32_t ms
             goto exit;
         }
 
+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT
+        camera_memory_t* VideoCameraBufferMemoryBase = (camera_memory_t*)frame->mBuffer;
+        src = (uint8_t*)VideoCameraBufferMemoryBase->data;
+#else
+        private_handle_t* gralloc_hnd = (private_handle_t*)frame->mBuffer;
+        src = (uint8_t*)gralloc_hnd->base;
+#endif
+        if (!src) {
+            CAMHAL_LOGDA("Error! Src Data buffer is NULL");
+            goto exit;
+        }
 
         dest = (void*) mPreviewBufs[mPreviewBufCount];
 
@@ -678,7 +692,7 @@ void AppCallbackNotifier::copyAndSendPreviewFrame(CameraFrame* frame, int32_t ms
             // data sync frames don't need conversion
             if (CameraFrame::FRAME_DATA_SYNC == frame->mFrameType) {
                 if ( (mPreviewMemory->size / MAX_BUFFERS) >= frame->mLength ) {
-                    memcpy(dest, (void*) frame->mBuffer, frame->mLength);
+                    memcpy(dest, (void*) src, frame->mLength);
                 } else {
                     memset(dest, 0, (mPreviewMemory->size / MAX_BUFFERS));
                 }
@@ -779,35 +793,34 @@ void AppCallbackNotifier::notifyFrame()
 
                 frame = (CameraFrame *) msg.arg1;
                 if(!frame)
-                    {
+                {
                     break;
-                    }
+                }
 
                 if ( (CameraFrame::RAW_FRAME == frame->mFrameType )&&
                     ( NULL != mCameraHal ) &&
                     ( NULL != mDataCb) &&
                     ( NULL != mNotifyCb ) )
-                    {
-
+                {
+                     
                     if ( mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE) )
-                        {
+                    {
 #ifdef COPY_IMAGE_BUFFER
                         copyAndSendPictureFrame(frame, CAMERA_MSG_RAW_IMAGE);
 #else
                         //TODO: Find a way to map a Tiler buffer to a MemoryHeapBase
 #endif
-                        }
-                    else {
+                    }
+                    else 
+                    {
                         if ( mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE_NOTIFY) ) {
                             mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
                         }
                         mFrameProvider->returnFrame(frame->mBuffer,
                                                     (CameraFrame::FrameType) frame->mFrameType);
                     }
-
                     mRawAvailable = true;
-
-                    }
+                }
                 else if ( (CameraFrame::IMAGE_FRAME == frame->mFrameType) &&
                           (NULL != mCameraHal) &&
                           (NULL != mDataCb) &&
@@ -949,24 +962,24 @@ void AppCallbackNotifier::notifyFrame()
                              ( NULL != mCameraHal ) &&
                              ( NULL != mDataCb) &&
                              ( mCameraHal->msgTypeEnabled(CAMERA_MSG_VIDEO_FRAME)  ) )
-                    {
+                {
                     mRecordingLock.lock();
                     if(mRecording)
-                        {
+                    {
                         if(mUseMetaDataBufferMode)
-                            {
+                        {
                             camera_memory_t *videoMedatadaBufferMemory =
                                              (camera_memory_t *) mVideoMetadataBufferMemoryMap.valueFor((uint32_t) frame->mBuffer);
                             video_metadata_t *videoMetadataBuffer = (video_metadata_t *) videoMedatadaBufferMemory->data;
 
                             if( (NULL == videoMedatadaBufferMemory) || (NULL == videoMetadataBuffer) || (NULL == frame->mBuffer) )
-                                {
+                            {
                                 CAMHAL_LOGEA("Error! One of the video buffers is NULL");
                                 break;
-                                }
+                            }
 
                             if ( mUseVideoBuffers )
-                              {
+                            {
                                 int vBuf = mVideoMap.valueFor((uint32_t) frame->mBuffer);
                                 GraphicBufferMapper &mapper = GraphicBufferMapper::get();
                                 Rect bounds;
@@ -999,28 +1012,37 @@ void AppCallbackNotifier::notifyFrame()
                                 videoMetadataBuffer->metadataBufferType = (int) kMetadataBufferTypeCameraSource;
                                 videoMetadataBuffer->handle = (void *)vBuf;
                                 videoMetadataBuffer->offset = 0;
-                              }
+                            }
                             else
-                              {
+                            {
                                 videoMetadataBuffer->metadataBufferType = (int) kMetadataBufferTypeCameraSource;
                                 videoMetadataBuffer->handle = frame->mBuffer;
                                 videoMetadataBuffer->offset = frame->mOffset;
-                              }
+                            }
 
                             CAMHAL_LOGVB("mDataCbTimestamp : frame->mBuffer=0x%x, videoMetadataBuffer=0x%x, videoMedatadaBufferMemory=0x%x",
                                             frame->mBuffer, videoMetadataBuffer, videoMedatadaBufferMemory);
 
                             mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME,
                                                 videoMedatadaBufferMemory, 0, mCallbackCookie);
-                            }
+                        }
                         else
-                            {
+                        {
                             //TODO: Need to revisit this, should ideally be mapping the TILER buffer using mRequestMemory
                             if( NULL == frame->mBuffer)
                             {
                                 CAMHAL_LOGEA("Error! frame->mBuffer is NULL");
                                 break;
                             }
+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT
+                            camera_memory_t* VideoCameraBufferMemoryBase = (camera_memory_t*)frame->mBuffer;
+                            if((NULL == VideoCameraBufferMemoryBase)||(NULL == VideoCameraBufferMemoryBase->data))
+                            {
+                                CAMHAL_LOGEA("Error! one of video buffer is NULL");
+                                break;
+                            }
+                            mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME, VideoCameraBufferMemoryBase, 0, mCallbackCookie);
+#else
                             camera_memory_t* VideoCameraBufferMemoryBase = (camera_memory_t*)mVideoHeaps.valueFor((uint32_t)frame->mBuffer);
                             private_handle_t* gralloc_hnd = (private_handle_t*)frame->mBuffer;
                             if((NULL == VideoCameraBufferMemoryBase) ||(NULL == gralloc_hnd->base))
@@ -1032,11 +1054,11 @@ void AppCallbackNotifier::notifyFrame()
                             uint8_t* dest = (uint8_t*)VideoCameraBufferMemoryBase->data;
                             memcpy(dest,src,frame->mWidth*frame->mHeight*3/2);
                             mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME, VideoCameraBufferMemoryBase, 0, mCallbackCookie);
-                            }
+#endif					
                         }
-                    mRecordingLock.unlock();
-
                     }
+                    mRecordingLock.unlock();
+                }
                 else if(( CameraFrame::SNAPSHOT_FRAME == frame->mFrameType ) &&
                              ( NULL != mCameraHal ) &&
                              ( NULL != mDataCb) &&
@@ -1057,7 +1079,7 @@ void AppCallbackNotifier::notifyFrame()
                     if ( !mMeasurementEnabled ) {
                         copyAndSendPreviewFrame(frame, CAMERA_MSG_PREVIEW_FRAME);
                     } else {
-                         mFrameProvider->returnFrame(frame->mBuffer,
+                        mFrameProvider->returnFrame(frame->mBuffer,
                                                      (CameraFrame::FrameType) frame->mFrameType);
                     }
                 }
@@ -1107,21 +1129,19 @@ void AppCallbackNotifier::frameCallback(CameraFrame* caFrame)
     LOG_FUNCTION_NAME;
 
     if ( NULL != caFrame )
-        {
-
+    {
         frame = new CameraFrame(*caFrame);
         if ( NULL != frame )
-            {
-              msg.command = AppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME;
-              msg.arg1 = frame;
-              mFrameQ.put(&msg);
-            }
+        {
+            msg.command = AppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME;
+            msg.arg1 = frame;
+            mFrameQ.put(&msg);
+        }
         else
-            {
+        {
             CAMHAL_LOGEA("Not enough resources to allocate CameraFrame");
-            }
-
         }
+    }
 
     LOG_FUNCTION_NAME_EXIT;
 }
@@ -1313,6 +1333,7 @@ void AppCallbackNotifier::releaseSharedVideoBuffers()
     }
     else
     {
+#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT
         camera_memory_t* VideoCameraBufferMemoryBase = NULL;
         for (unsigned int i = 0; i < mVideoHeaps.size();  i++)
         {
@@ -1323,7 +1344,7 @@ void AppCallbackNotifier::releaseSharedVideoBuffers()
                 CAMHAL_LOGDB("Released  VideoCameraBufferMemoryBase=0x%x", VideoCameraBufferMemoryBase);
             }
         }
-
+#endif
         mVideoMap.clear();
         mVideoHeaps.clear();
     }
@@ -1359,16 +1380,16 @@ void AppCallbackNotifier::setFrameProvider(FrameNotifier *frameNotifier)
     ///for NULL when we get the start command from CameraAdapter
     mFrameProvider = new FrameProvider(frameNotifier, this, frameCallbackRelay);
     if ( NULL == mFrameProvider )
-        {
+    {
         CAMHAL_LOGEA("Error in creating FrameProvider");
-        }
+    }
     else
-        {
+    {
         //Register only for captured images and RAW for now
         //TODO: Register for and handle all types of frames
         mFrameProvider->enableFrameNotification(CameraFrame::IMAGE_FRAME);
         mFrameProvider->enableFrameNotification(CameraFrame::RAW_FRAME);
-        }
+    }
 
     LOG_FUNCTION_NAME_EXIT;
 }
@@ -1455,14 +1476,15 @@ void AppCallbackNotifier::setBurst(bool burst)
 
 void AppCallbackNotifier::useVideoBuffers(bool useVideoBuffers)
 {
-  LOG_FUNCTION_NAME;
-
-  mUseVideoBuffers = useVideoBuffers;
-
-  LOG_FUNCTION_NAME_EXIT;
+    LOG_FUNCTION_NAME;
+#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT
+    mUseVideoBuffers = useVideoBuffers;
+    CAMHAL_LOGDB("Set mUseVideoBuffers as %d",(uint32_t)useVideoBuffers);
+#endif
+    LOG_FUNCTION_NAME_EXIT;
 }
 
-bool AppCallbackNotifier::getUesVideoBuffers()
+bool AppCallbackNotifier::getUseVideoBuffers()
 {
     return mUseVideoBuffers;
 }
@@ -1513,7 +1535,7 @@ status_t AppCallbackNotifier::stopPreviewCallbacks()
 status_t AppCallbackNotifier::useMetaDataBufferMode(bool enable)
 {
     mUseMetaDataBufferMode = enable;
-
+    CAMHAL_LOGDB("Set mUseMetaDataBufferMode as %d",(uint32_t)enable);
     return NO_ERROR;
 }
 
@@ -1603,7 +1625,11 @@ status_t AppCallbackNotifier::initSharedVideoBuffers(void *buffers, uint32_t *of
 
         for (uint32_t i = 0; i < count; i++)
         {
+ #ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT
+            VideoCameraBufferMemoryBase = (camera_memory_t*)bufArr[i];
+ #else
             VideoCameraBufferMemoryBase = mRequestMemory(-1, length, 1, NULL);
+ #endif
             if((NULL == VideoCameraBufferMemoryBase) || (NULL == VideoCameraBufferMemoryBase->data))
             {
                 CAMHAL_LOGEA("Error! Could not allocate memory for Video Metadata Buffers");
@@ -1615,7 +1641,6 @@ status_t AppCallbackNotifier::initSharedVideoBuffers(void *buffers, uint32_t *of
                     i, bufArr[i], VideoCameraBufferMemoryBase, VideoCameraBufferMemoryBase->data);
         }
     }
-
 exit:
     LOG_FUNCTION_NAME_EXIT;
 
@@ -1689,6 +1714,7 @@ status_t AppCallbackNotifier::releaseRecordingFrame(const void* mem)
     else
     {
         frame = (void *)mVideoMap.valueFor((uint32_t)mem);
+        //CAMHAL_LOGDB("release recording mem.0x%x, frame:0x%x",(uint32_t)mem,(uint32_t)frame);
     }
 
     if ( NO_ERROR == ret )
diff --git a/CameraHal.cpp b/CameraHal.cpp
index bf28ef1..71856e7 100755
--- a/CameraHal.cpp
+++ b/CameraHal.cpp
@@ -33,8 +33,6 @@
 #include <poll.h>
 #include <math.h>
 
-//#define AMLOGIC_CAMERA_OVERLAY_SUPPORT
-
 namespace android {
 
 #if 1//def AMLOGIC_CAMERA_OVERLAY_SUPPORT
@@ -1220,22 +1218,24 @@ status_t CameraHal::allocPreviewBufs(int width, int height, const char* previewF
     {
         ///@todo Pluralise the name of this method to allocateBuffers
         mPreviewLength = 0;
+#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT
         mPreviewBufs = (int32_t *) mDisplayAdapter->allocateBuffer(width, height,
                                                                     previewFormat,
                                                                     mPreviewLength,
                                                                     buffercount);
+        
         LOGD("allocPreviewBufs buffercount=%d", buffercount);
 
         if (NULL == mPreviewBufs ) {
             CAMHAL_LOGEA("Couldn't allocate preview buffers");
             return NO_MEMORY;
-         }
+        }
 
         mPreviewOffsets = (uint32_t *) mDisplayAdapter->getOffsets();
         if ( NULL == mPreviewOffsets ) {
             CAMHAL_LOGEA("Buffer mapping failed");
             return BAD_VALUE;
-         }
+        }
 
         mPreviewFd = mDisplayAdapter->getFd();
         /* mPreviewFd and desc.mFd seem to be unused.
@@ -1249,8 +1249,58 @@ status_t CameraHal::allocPreviewBufs(int width, int height, const char* previewF
         ret = mDisplayAdapter->maxQueueableBuffers(max_queueable);
         if (ret != NO_ERROR) {
             return ret;
-         }
+        }
+#else
+        int buf_size = 0;
+        if ( previewFormat != NULL ) {
+            if(strcmp(previewFormat,(const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0) {
+                buf_size = width * height * 2;
+            }else if((strcmp(previewFormat, CameraParameters::PIXEL_FORMAT_YUV420SP) == 0) ||
+              (strcmp(previewFormat, CameraParameters::PIXEL_FORMAT_YUV420P) == 0)) {
+                buf_size = width * height * 3 / 2;
+            }else if(strcmp(previewFormat,(const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0) {
+                buf_size = width * height * 2;
+            } else {
+                CAMHAL_LOGEA("Invalid format");
+                buf_size = 0;
+            }
+        } else {
+            CAMHAL_LOGEA("Preview format is NULL");
+            buf_size = 0;
+        }
+		
+        //buf_size = ((buf_size+4095)/4096)*4096;
+        mPreviewBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, NULL, buf_size, buffercount);
+		        
+        LOGD("allocPreviewBufs buffercount=%d", buffercount);
+
+        if (NULL == mPreviewBufs ) {
+            CAMHAL_LOGEA("Couldn't allocate preview buffers");
+            return NO_MEMORY;
+        }
+
+        mPreviewLength = buf_size;
 
+        mPreviewOffsets = (uint32_t *) mMemoryManager->getOffsets();
+        //if ( NULL == mPreviewOffsets ) {
+        //    CAMHAL_LOGEA("Buffer mapping failed");
+        //    return BAD_VALUE;
+        //}
+
+        mPreviewFd = mMemoryManager->getFd();
+        /* mPreviewFd and desc.mFd seem to be unused.
+              if ( -1 == mPreviewFd ) {
+                  CAMHAL_LOGEA("Invalid handle");
+                  return BAD_VALUE;
+              }*/
+
+        mBufProvider = (BufferProvider*) mMemoryManager.get();
+        max_queueable = buffercount;
+        //ret = mDisplayAdapter->maxQueueableBuffers(max_queueable);
+        //if (ret != NO_ERROR) {
+        //    return ret;
+        //}
+#endif
     }
 
     LOG_FUNCTION_NAME_EXIT;
@@ -1266,13 +1316,13 @@ status_t CameraHal::freePreviewBufs()
 
     CAMHAL_LOGDB("mPreviewBufs = 0x%x", (unsigned int)mPreviewBufs);
     if(mPreviewBufs)
-        {
+    {
         ///@todo Pluralise the name of this method to freeBuffers
         ret = mBufProvider->freeBuffer(mPreviewBufs);
         mPreviewBufs = NULL;
         LOG_FUNCTION_NAME_EXIT;
         return ret;
-        }
+    }
     LOG_FUNCTION_NAME_EXIT;
     return ret;
 }
@@ -1563,7 +1613,6 @@ status_t CameraHal::freeVideoBufs(void *bufs)
  */
 status_t CameraHal::startPreview()
 {
-
     status_t ret = NO_ERROR;
     CameraAdapter::BuffersDescriptor desc;
     CameraFrame frame;
@@ -1572,116 +1621,110 @@ status_t CameraHal::startPreview()
     unsigned int max_queueble_buffers;
 
 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
-        gettimeofday(&mStartPreview, NULL);
+    gettimeofday(&mStartPreview, NULL);
 #endif
 
     LOG_FUNCTION_NAME;
 
     if ( mPreviewEnabled ){
-      CAMHAL_LOGDA("Preview already running");
-      LOG_FUNCTION_NAME_EXIT;
-      return ALREADY_EXISTS;
+        CAMHAL_LOGDA("Preview already running");
+        LOG_FUNCTION_NAME_EXIT;
+        return ALREADY_EXISTS;
     }
 
     if ( NULL != mCameraAdapter ) {
-      ret = mCameraAdapter->setParameters(mParameters);
+        ret = mCameraAdapter->setParameters(mParameters);
     }
 
     if ((mPreviewStartInProgress == false) && (mDisplayPaused == false)){
-      ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,( int ) &frame);
-      if ( NO_ERROR != ret ){
-        CAMHAL_LOGEB("Error: CAMERA_QUERY_RESOLUTION_PREVIEW %d", ret);
-        return ret;
-      }
+        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,( int ) &frame);
+        if ( NO_ERROR != ret ){
+            CAMHAL_LOGEB("Error: CAMERA_QUERY_RESOLUTION_PREVIEW %d", ret);
+            return ret;
+        }
 
-      ///Update the current preview width and height
-      mPreviewWidth = frame.mWidth;
-      mPreviewHeight = frame.mHeight;
-      //Update the padded width and height - required for VNF and VSTAB
-      mParameters.set(TICameraParameters::KEY_PADDED_WIDTH, mPreviewWidth);
-      mParameters.set(TICameraParameters::KEY_PADDED_HEIGHT, mPreviewHeight);
+        ///Update the current preview width and height
+        mPreviewWidth = frame.mWidth;
+        mPreviewHeight = frame.mHeight;
+        //Update the padded width and height - required for VNF and VSTAB
+        mParameters.set(TICameraParameters::KEY_PADDED_WIDTH, mPreviewWidth);
+        mParameters.set(TICameraParameters::KEY_PADDED_HEIGHT, mPreviewHeight);
 
     }
 
     ///If we don't have the preview callback enabled and display adapter,
     if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL)){
-      CAMHAL_LOGEA("Preview not started. Preview in progress flag set");
-      mPreviewStartInProgress = true;
-      ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING);
-      if ( NO_ERROR != ret ){
-        CAMHAL_LOGEB("Error: CAMERA_SWITCH_TO_EXECUTING %d", ret);
-        return ret;
-      }
-      return NO_ERROR;
+        CAMHAL_LOGEA("Preview not started. Preview in progress flag set");
+        mPreviewStartInProgress = true;
+        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING);
+        if ( NO_ERROR != ret ){
+            CAMHAL_LOGEB("Error: CAMERA_SWITCH_TO_EXECUTING %d", ret);
+            return ret;
+        }
+        return NO_ERROR;
     }
 
     if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) )
-        {
+    {
         CAMHAL_LOGDA("Preview is in paused state");
 
         mDisplayPaused = false;
         mPreviewEnabled = true;
         if ( NO_ERROR == ret )
-            {
+        {
             ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
-
             if ( NO_ERROR != ret )
-                {
+            {
                 CAMHAL_LOGEB("Display adapter resume failed %x", ret);
-                }
             }
+        }
         //restart preview callbacks
         if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
         {
             mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME);
         }
         return ret;
-        }
-
-
+    }
     required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
 
     ///Allocate the preview buffers
     ret = allocPreviewBufs(mPreviewWidth, mPreviewHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers);
 
     if ( NO_ERROR != ret )
-        {
+    {
         CAMHAL_LOGEA("Couldn't allocate buffers for Preview");
         goto error;
-        }
+    }
 
     if ( mMeasurementEnabled )
-        {
-
+    {
         ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA,
                                           ( int ) &frame,
                                           required_buffer_count);
         if ( NO_ERROR != ret )
-            {
+        {
             return ret;
-            }
+        }
 
          ///Allocate the preview data buffers
         ret = allocPreviewDataBufs(frame.mLength, required_buffer_count);
         if ( NO_ERROR != ret ) {
             CAMHAL_LOGEA("Couldn't allocate preview data buffers");
             goto error;
-           }
+        }
 
         if ( NO_ERROR == ret )
-            {
+        {
             desc.mBuffers = mPreviewDataBufs;
             desc.mOffsets = mPreviewDataOffsets;
             desc.mFd = mPreviewDataFd;
             desc.mLength = mPreviewDataLength;
             desc.mCount = ( size_t ) required_buffer_count;
             desc.mMaxQueueable = (size_t) required_buffer_count;
-
             mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA,
                                         ( int ) &desc);
-            }
-
         }
+    }
 
     ///Pass the buffers to Camera Adapter
     desc.mBuffers = mPreviewBufs;
@@ -1695,11 +1738,11 @@ status_t CameraHal::startPreview()
                                       ( int ) &desc);
 
     if ( NO_ERROR != ret )
-        {
+    {
         CAMHAL_LOGEB("Failed to register preview buffers: 0x%x", ret);
         freePreviewBufs();
         return ret;
-        }
+    }
 
     mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count);
 
@@ -1707,24 +1750,24 @@ status_t CameraHal::startPreview()
     ret = mAppCallbackNotifier->start();
 
     if( ALREADY_EXISTS == ret )
-        {
+    {
         //Already running, do nothing
         CAMHAL_LOGDA("AppCallbackNotifier already running");
         ret = NO_ERROR;
-        }
+    }
     else if ( NO_ERROR == ret ) {
         CAMHAL_LOGDA("Started AppCallbackNotifier..");
         mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
-        }
+    }
     else
-        {
+    {
         CAMHAL_LOGDA("Couldn't start AppCallbackNotifier");
         goto error;
-        }
+    }
 
     ///Enable the display adapter if present, actual overlay enable happens when we post the buffer
     if(mDisplayAdapter.get() != NULL)
-        {
+    {
         CAMHAL_LOGDA("Enabling display");
         bool isS3d = false;
         DisplayAdapter::S3DParameters s3dParams;
@@ -1736,7 +1779,7 @@ status_t CameraHal::startPreview()
         }
         if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL) {
             if (strcmp(valstr, "off") == 0)
-                {
+            {
                 CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS OFF");
                 //TODO: obtain the frame packing configuration from camera or user settings
                 //once side by side configuration is supported
@@ -1744,69 +1787,59 @@ status_t CameraHal::startPreview()
                 s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
                 s3dParams.order = OVERLAY_S3D_ORDER_LF;
                 s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
-                }
+            }
             else
-                {
+            {
                 CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS ON");
                 s3dParams.mode = OVERLAY_S3D_MODE_OFF;
                 s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
                 s3dParams.order = OVERLAY_S3D_ORDER_LF;
                 s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
-                }
+            }
         }
 #endif //if 0
 
 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
 
         ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview, isS3d ? &s3dParams : NULL);
-
 #else
-
         ret = mDisplayAdapter->enableDisplay(width, height, NULL, isS3d ? &s3dParams : NULL);
-
 #endif
-
         if ( ret != NO_ERROR )
-            {
+        {
             CAMHAL_LOGEA("Couldn't enable display");
             goto error;
-            }
-
         }
+    }
 
     ///Send START_PREVIEW command to adapter
     CAMHAL_LOGDA("Starting CameraAdapter preview mode");
-
     ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
-
     if(ret!=NO_ERROR)
-        {
+    {
         CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter");
         goto error;
-        }
+    }
     CAMHAL_LOGDA("Started preview");
 
     mPreviewEnabled = true;
     mPreviewStartInProgress = false;
     return ret;
 
-    error:
-
-        CAMHAL_LOGEA("Performing cleanup after error");
-
-        //Do all the cleanup
-        freePreviewBufs();
-        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
-        if(mDisplayAdapter.get() != NULL)
-            {
-            mDisplayAdapter->disableDisplay(false);
-            }
-        mAppCallbackNotifier->stop();
-        mPreviewStartInProgress = false;
-        mPreviewEnabled = false;
-        LOG_FUNCTION_NAME_EXIT;
-
-        return ret;
+error:
+    CAMHAL_LOGEA("Performing cleanup after error");
+    //Do all the cleanup
+    freePreviewBufs();
+    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
+    if(mDisplayAdapter.get() != NULL)
+    {
+        mDisplayAdapter->disableDisplay(false);
+    }
+    mAppCallbackNotifier->stop();
+    mPreviewStartInProgress = false;
+    mPreviewEnabled = false;
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
 }
 
 /**
@@ -1976,17 +2009,14 @@ status_t CameraHal::startRecording( )
 
     LOG_FUNCTION_NAME;
 
-
 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
-
-            gettimeofday(&mStartPreview, NULL);
-
+    gettimeofday(&mStartPreview, NULL);
 #endif
 
     if(!previewEnabled())
-        {
+    {
         return NO_INIT;
-        }
+    }
 
     // set internal recording hint in case camera adapter needs to make some
     // decisions....(will only be sent to camera adapter if camera restart is required)
@@ -2011,48 +2041,48 @@ status_t CameraHal::startRecording( )
     }
 
     if ( NO_ERROR == ret )
-      {
+    {
         int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
         mParameters.getPreviewSize(&w, &h);
         CAMHAL_LOGDB("%s Video Width=%d Height=%d", __FUNCTION__, mVideoWidth, mVideoHeight);
 
         if ((w != mVideoWidth) && (h != mVideoHeight))
-          {
+        {
             ret = allocVideoBufs(mVideoWidth, mVideoHeight, count);
             if ( NO_ERROR != ret )
-              {
+            {
                 CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
                 mParameters.remove(TICameraParameters::KEY_RECORDING_HINT);
                 return ret;
-              }
+            }
 
             mAppCallbackNotifier->useVideoBuffers(true);
             mAppCallbackNotifier->setVideoRes(mVideoWidth, mVideoHeight);
             ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, count, mVideoBufs);
-          }
+        }
         else
-          {
+        {
             mAppCallbackNotifier->useVideoBuffers(false);
             mAppCallbackNotifier->setVideoRes(mPreviewWidth, mPreviewHeight);
             ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, count, NULL);
-          }
-      }
+        }
+    }
 
     if ( NO_ERROR == ret )
-        {
+    {
          ret = mAppCallbackNotifier->startRecording();
-        }
+    }
 
     if ( NO_ERROR == ret )
-        {
+    {
         ///Buffers for video capture (if different from preview) are expected to be allocated within CameraAdapter
          ret =  mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_VIDEO);
-        }
+    }
 
     if ( NO_ERROR == ret )
-        {
+    {
         mRecordingEnabled = true;
-        }
+    }
 
     LOG_FUNCTION_NAME_EXIT;
 
@@ -2252,7 +2282,7 @@ void CameraHal::stopRecording()
 
     mRecordingEnabled = false;
 
-    if ( mAppCallbackNotifier->getUesVideoBuffers() ){
+    if ( mAppCallbackNotifier->getUseVideoBuffers() ){
       freeVideoBufs(mVideoBufs);
       if (mVideoBufs){
         CAMHAL_LOGVB(" FREEING mVideoBufs 0x%x", mVideoBufs);
diff --git a/V4LCameraAdapter/V4LCameraAdapter.cpp b/V4LCameraAdapter/V4LCameraAdapter.cpp
index 3051a5a..c02dcc5 100755
--- a/V4LCameraAdapter/V4LCameraAdapter.cpp
+++ b/V4LCameraAdapter/V4LCameraAdapter.cpp
@@ -727,33 +727,43 @@ int V4LCameraAdapter::previewThread()
     CameraFrame frame;
 
     if (mPreviewing)
-        {
+    {
         int index = 0;
         char *fp = this->GetFrame(index);
         if(!fp)
         {
-	        return BAD_VALUE;
+            int previewFrameRate = mParams.getPreviewFrameRate();
+            int delay = (int)(1000000.0f / float(previewFrameRate)) >> 1;
+            CAMHAL_LOGEB("Preview thread get frame fail, need sleep:%d",delay);
+            usleep(delay);
+            return BAD_VALUE;
         }
-
-		//LOGD("preview idx %d",index);
+        
         uint8_t* ptr = (uint8_t*) mPreviewBufs.keyAt(mPreviewIdxs.valueFor(index));
-        private_handle_t* gralloc_hnd = (private_handle_t*)ptr;
+
         if (!ptr)
         {
-	        return BAD_VALUE;
+            CAMHAL_LOGEA("Preview thread mPreviewBufs error!");
+            return BAD_VALUE;
         }
 
+		uint8_t* dest = NULL;
+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT
+        camera_memory_t* VideoCameraBufferMemoryBase = (camera_memory_t*)ptr;
+        dest = (uint8_t*)VideoCameraBufferMemoryBase->data; //ptr;
+#else
+        private_handle_t* gralloc_hnd = (private_handle_t*)ptr;
+        dest = (uint8_t*)gralloc_hnd->base; //ptr;
+#endif
         int width, height;
-        uint8_t* dest = (uint8_t*)gralloc_hnd->base; //ptr;
         uint8_t* src = (uint8_t*) fp;
         mParams.getPreviewSize(&width, &height);
         memcpy(dest,src,width*height*3/2);
 
-        mParams.getPreviewSize(&width, &height);
         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;
@@ -769,10 +779,8 @@ int V4LCameraAdapter::previewThread()
             LOGE("setInitFrameRefCount err=%d", ret);
         else
             ret = sendFrameToSubscribers(&frame);
-        //LOGD("previewThread /sendFrameToSubscribers ret=%d", ret);
-
-        }
-
+        //LOGD("previewThread /sendFrameToSubscribers ret=%d", ret);           
+    }
     return ret;
 }
 
diff --git a/inc/CameraHal.h b/inc/CameraHal.h
index ddc2506..9379ed8 100644..100755
--- a/inc/CameraHal.h
+++ b/inc/CameraHal.h
@@ -110,6 +110,7 @@
 #endif
 
 
+//#define AMLOGIC_CAMERA_OVERLAY_SUPPORT
 
 #define NONNEG_ASSIGN(x,y) \
     if(x > -1) \
@@ -580,7 +581,7 @@ public:
 
     void useVideoBuffers(bool useVideoBuffers);
 
-    bool getUesVideoBuffers();
+    bool getUseVideoBuffers();
     void setVideoRes(int width, int height);
 
     void flushEventQueue();