Update frame ref counting

1. Make only one sendframe call from OMXCameraAdapter
2. Add frame type mask to frame structure
3. Frame type mask used to indicate type of frame
   e.g video, preview, image or preview and video
4. Set frame ref count before sending frames to
   subscribers.
5. Hold frame subscriber lock for setting the
   refcount and sending the frames to the
   subscribers to allow for the number of
   subscribers not to change until frames
   are sent.

Change-Id: Ic00a195847f2dc962e931ee8a9f36e3933e67c2d
Signed-off-by: Akwasi Boateng <akwasi.boateng@ti.com>

6 files changed, 257 insertions, 111 deletions

diff --git a/camera/BaseCameraAdapter.cpp b/camera/BaseCameraAdapter.cpp
index ec149bf..74f80de 100644
--- a/camera/BaseCameraAdapter.cpp
+++ b/camera/BaseCameraAdapter.cpp
@@ -1087,90 +1087,205 @@ status_t BaseCameraAdapter::sendFrameToSubscribers(CameraFrame *frame)
     uint32_t i = 0;
     KeyedVector<int, frame_callback> *subscribers = NULL;
     size_t refCount = 0;
+    unsigned int mask;
 
     if ( NULL == frame )
         {
         CAMHAL_LOGEA("Invalid CameraFrame");
-        ret = -EINVAL;
+        return -EINVAL;
         }
 
-    if ( NO_ERROR == ret )
-        {
-
-        switch(frame->mFrameType)
-            {
-                case CameraFrame::IMAGE_FRAME:
-                    {
+    for( mask = 1; mask < CameraFrame::ALL_FRAMES; mask <<= 1){
+      if( mask & frame->mFrameMask ){
+        switch( mask ){
 
+        case CameraFrame::IMAGE_FRAME:
+          {
 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+            CameraHal::PPM("Shot to Jpeg: ", &mStartCapture);
+#endif
+            subscribers = &mImageSubscribers;
+            frame->mFrameType = CameraFrame::IMAGE_FRAME;
+            if (NULL != subscribers)
+              {
+                refCount = getFrameRefCount(frame->mBuffer, CameraFrame::IMAGE_FRAME);
+                CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
+                             frame->mFrameType,
+                             ( uint32_t ) frame->mBuffer,
+                             refCount);
+                for ( i = 0 ; i < refCount; i++ )
+                  {
+                    frame->mCookie = ( void * ) subscribers->keyAt(i);
+                    callback = (frame_callback) subscribers->valueAt(i);
+                    callback(frame);
+                  }
+              }
+          }
+          break;
+        case CameraFrame::RAW_FRAME:
+          {
+            subscribers = &mRawSubscribers;
+            frame->mFrameType = CameraFrame::RAW_FRAME;
+            if (NULL != subscribers)
+              {
+                refCount = getFrameRefCount(frame->mBuffer, CameraFrame::RAW_FRAME);
+                CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
+                             frame->mFrameType,
+                             ( uint32_t ) frame->mBuffer,
+                             refCount);
+                for ( i = 0 ; i < refCount; i++ )
+                  {
+                    frame->mCookie = ( void * ) subscribers->keyAt(i);
+                    callback = (frame_callback) subscribers->valueAt(i);
+                    callback(frame);
+                  }
+              }
+          }
+          break;
+        case CameraFrame::PREVIEW_FRAME_SYNC:
+          {
+            subscribers = &mFrameSubscribers;
+            frame->mFrameType = CameraFrame::PREVIEW_FRAME_SYNC;
+            if (NULL != subscribers)
+              {
+                refCount = getFrameRefCount(frame->mBuffer, CameraFrame::PREVIEW_FRAME_SYNC);
+                CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
+                             frame->mFrameType,
+                             ( uint32_t ) frame->mBuffer,
+                             refCount);
+                for ( i = 0 ; i < refCount; i++ )
+                  {
+                    frame->mCookie = ( void * ) subscribers->keyAt(i);
+                    callback = (frame_callback) subscribers->valueAt(i);
+                    callback(frame);
+                  }
+              }
+          }
+          break;
+        case CameraFrame::SNAPSHOT_FRAME:
+          {
+            subscribers = &mFrameSubscribers;
+            frame->mFrameType = CameraFrame::SNAPSHOT_FRAME;
+            if (NULL != subscribers)
+              {
+                refCount = getFrameRefCount(frame->mBuffer, CameraFrame::SNAPSHOT_FRAME);
+                CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
+                             frame->mFrameType,
+                             ( uint32_t ) frame->mBuffer,
+                             refCount);
+                for ( i = 0 ; i < refCount; i++ )
+                  {
+                    frame->mCookie = ( void * ) subscribers->keyAt(i);
+                    callback = (frame_callback) subscribers->valueAt(i);
+                    callback(frame);
+                  }
+              }
+          }
+          break;
+        case CameraFrame::VIDEO_FRAME_SYNC:
+          {
+            subscribers = &mVideoSubscribers;
+            frame->mFrameType = CameraFrame::VIDEO_FRAME_SYNC;
+            if (NULL != subscribers)
+              {
+                refCount = getFrameRefCount(frame->mBuffer, CameraFrame::VIDEO_FRAME_SYNC);
+                CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
+                             frame->mFrameType,
+                             ( uint32_t ) frame->mBuffer,
+                             refCount);
+                for ( i = 0 ; i < refCount; i++ )
+                  {
+                    frame->mCookie = ( void * ) subscribers->keyAt(i);
+                    callback = (frame_callback) subscribers->valueAt(i);
+                    callback(frame);
+                  }
+              }
+          }
+          break;
+        case CameraFrame::FRAME_DATA_SYNC:
+          {
+            subscribers = &mFrameDataSubscribers;
+            frame->mFrameType = CameraFrame::FRAME_DATA_SYNC;
+            if (NULL != subscribers)
+              {
+                refCount = getFrameRefCount(frame->mBuffer, CameraFrame::FRAME_DATA_SYNC);
+                CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
+                             frame->mFrameType,
+                             ( uint32_t ) frame->mBuffer,
+                             refCount);
+                for ( i = 0 ; i < refCount; i++ )
+                  {
+                    frame->mCookie = ( void * ) subscribers->keyAt(i);
+                    callback = (frame_callback) subscribers->valueAt(i);
+                    callback(frame);
+                  }
+              }
+          }
+          break;
+        default:
+          CAMHAL_LOGEB("FRAMETYPE NOT SUPPORTED 0x%x", mask);
+        break;
+        }//SWITCH
+        frame->mFrameMask &= ~mask;
+      }//IF
+    }//FOR
+    return ret;
+}
+int BaseCameraAdapter::setInitFrameRefCount(void* buf, unsigned int mask)
+{
+  int ret = NO_ERROR;
+  unsigned int lmask;
 
-                    CameraHal::PPM("Shot to Jpeg: ", &mStartCapture);
+  LOG_FUNCTION_NAME;
 
-#endif
+  if (buf == NULL)
+    {
+      return -EINVAL;
+    }
 
-                    subscribers = &mImageSubscribers;
-                    break;
-                    }
-                case CameraFrame::RAW_FRAME:
-                    {
-                    subscribers = &mRawSubscribers;
-                    break;
-                    }
-                case CameraFrame::VIDEO_FRAME_SYNC:
-                    {
-                    subscribers = &mVideoSubscribers;
-                    break;
-                    }
-                case CameraFrame::FRAME_DATA_SYNC:
-                    {
-                    subscribers = &mFrameDataSubscribers;
-                    break;
-                    }
-                case CameraFrame::PREVIEW_FRAME_SYNC:
-                case CameraFrame::SNAPSHOT_FRAME:
-                    {
-                    subscribers = &mFrameSubscribers;
-                    break;
-                    }
-                default:
-                    {
-                    ret = -EINVAL;
-                    break;
-                    }
-            };
+  for( lmask = 1; lmask < CameraFrame::ALL_FRAMES; lmask <<= 1){
+    if( lmask & mask ){
+      switch( lmask ){
 
+      case CameraFrame::IMAGE_FRAME:
+        {
+          setFrameRefCount(buf, CameraFrame::IMAGE_FRAME, (int) mRawSubscribers.size());
         }
-
-    if ( ( NO_ERROR == ret ) &&
-         ( NULL != subscribers ) )
+        break;
+      case CameraFrame::RAW_FRAME:
         {
-        Mutex::Autolock lock(mSubscriberLock);
-
-        refCount = subscribers->size();
-        CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
-                                    frame->mFrameType,
-                                    ( uint32_t ) frame->mBuffer,
-                                    refCount);
-
-        setFrameRefCount(frame->mBuffer,
-                         (  CameraFrame::FrameType ) frame->mFrameType,
-                         refCount);
-
-        for ( i = 0 ; i < subscribers->size(); i++ )
-            {
-            frame->mCookie = ( void * ) subscribers->keyAt(i);
-            callback = (frame_callback) subscribers->valueAt(i);
-            callback(frame);
-            }
+          setFrameRefCount(buf, CameraFrame::RAW_FRAME, mRawSubscribers.size());
         }
-
-    if ( 0 == i )
+        break;
+      case CameraFrame::PREVIEW_FRAME_SYNC:
         {
-        //No subscribers for this frame
-        ret = -1;
+          setFrameRefCount(buf, CameraFrame::PREVIEW_FRAME_SYNC, mFrameSubscribers.size());
         }
-
-    return ret;
+        break;
+      case CameraFrame::SNAPSHOT_FRAME:
+        {
+          setFrameRefCount(buf, CameraFrame::SNAPSHOT_FRAME, mFrameSubscribers.size());
+        }
+        break;
+      case CameraFrame::VIDEO_FRAME_SYNC:
+        {
+          setFrameRefCount(buf,CameraFrame::VIDEO_FRAME_SYNC, mVideoSubscribers.size());
+        }
+        break;
+      case CameraFrame::FRAME_DATA_SYNC:
+        {
+          setFrameRefCount(buf, CameraFrame::FRAME_DATA_SYNC, mFrameDataSubscribers.size());
+        }
+        break;
+      default:
+        CAMHAL_LOGEB("FRAMETYPE NOT SUPPORTED 0x%x", lmask);
+        break;
+      }//SWITCH
+      mask &= ~lmask;
+    }//IF
+  }//FOR
+  LOG_FUNCTION_NAME_EXIT;
+  return ret;
 }
 
 int BaseCameraAdapter::getFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType)
diff --git a/camera/OMXCameraAdapter/OMX3A.cpp b/camera/OMXCameraAdapter/OMX3A.cpp
index 2466d68..24842c8 100644
--- a/camera/OMXCameraAdapter/OMX3A.cpp
+++ b/camera/OMXCameraAdapter/OMX3A.cpp
@@ -1312,7 +1312,7 @@ status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
                   {
                     ret |= setMeteringAreas(Gen3A);
                   }
-
+                  break;
                 default:
                     CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ",
                                  currSett);
diff --git a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
index 6fd79db..577d0fd 100644
--- a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
+++ b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
@@ -2806,6 +2806,8 @@ OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLE
     BaseCameraAdapter::getState(state);
     BaseCameraAdapter::getNextState(nextState);
     sp<CameraFDResult> fdResult = NULL;
+    unsigned int mask = 0xFFFF;
+    CameraFrame cameraFrame;
 
     res1 = res2 = NO_ERROR;
     pPortParam = &(mCameraAdapterParameters.mCameraPortParams[pBuffHeader->nOutputPortIndex]);
@@ -2841,67 +2843,46 @@ OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLE
             }
 
         ///Prepare the frames to be sent - initialize CameraFrame object and reference count
-        CameraFrame cameraFrameVideo, cameraFramePreview;
-        if ( mRecording )
-            {
-            res1 = initCameraFrame(cameraFrameVideo,
-                                   pBuffHeader,
-                                   CameraFrame::VIDEO_FRAME_SYNC,
-                                   pPortParam);
-            }
-
         if( mWaitingForSnapshot &&  (mCapturedFrames > 0) )
             {
             typeOfFrame = CameraFrame::SNAPSHOT_FRAME;
+            mask = (unsigned int)CameraFrame::SNAPSHOT_FRAME;
             }
         else
             {
-            typeOfFrame = CameraFrame::PREVIEW_FRAME_SYNC;
+              typeOfFrame = CameraFrame::PREVIEW_FRAME_SYNC;
+              mask = (unsigned int)CameraFrame::PREVIEW_FRAME_SYNC;
+              if (mRecording)
+                {
+                  mask |= (unsigned int)CameraFrame::VIDEO_FRAME_SYNC;
+                }
             }
 
         LOGV("FBD pBuffer = 0x%x", pBuffHeader->pBuffer);
 
-        res2 = initCameraFrame(cameraFramePreview,
-                               pBuffHeader,
-                               typeOfFrame,
-                               pPortParam);
-
-        stat |= res1 | res2;
-
-        if ( mRecording )
-            {
-            res1  = sendFrame(cameraFrameVideo);
-            }
-
         if( mWaitingForSnapshot )
-            {
+          {
             mSnapshotCount++;
 
             if ( (mSnapshotCount == 1) &&
                  ((HIGH_SPEED == mCapMode) || (VIDEO_MODE == mCapMode)) )
-                {
+              {
                 notifyShutterSubscribers();
-                }
-            }
-
-        res2 = sendFrame(cameraFramePreview);
+              }
+          }
 
-        stat |= ( ( NO_ERROR == res1 ) || ( NO_ERROR == res2 ) ) ? ( ( int ) NO_ERROR ) : ( -1 );
+        stat = sendCallBacks(cameraFrame, pBuffHeader, mask, pPortParam);
 
         }
     else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT )
         {
         typeOfFrame = CameraFrame::FRAME_DATA_SYNC;
-        CameraFrame cameraFrame;
-        stat |= initCameraFrame(cameraFrame,
-                                pBuffHeader,
-                                typeOfFrame,
-                                pPortParam);
-        stat |= sendFrame(cameraFrame);
+        mask = (unsigned int)CameraFrame::FRAME_DATA_SYNC;
+
+        stat = sendCallBacks(cameraFrame, pBuffHeader, mask, pPortParam);
        }
     else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_IMAGE_OUT_IMAGE )
         {
-        CameraFrame cameraFrame;
         OMX_COLOR_FORMATTYPE pixFormat;
         const char *valstr = NULL;
 
@@ -2911,6 +2892,7 @@ OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLE
         if ( OMX_COLOR_FormatUnused == pixFormat )
             {
             typeOfFrame = CameraFrame::IMAGE_FRAME;
+            mask = (unsigned int) CameraFrame::IMAGE_FRAME;
             }
         else if ( pixFormat == OMX_COLOR_FormatCbYCrY &&
                   ((valstr && !strcmp(valstr, CameraParameters::PIXEL_FORMAT_JPEG)) ||
@@ -2919,6 +2901,7 @@ OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLE
             // signals to callbacks that this needs to be coverted to jpeg
             // before returning to framework
             typeOfFrame = CameraFrame::IMAGE_FRAME;
+            mask = (unsigned int) CameraFrame::IMAGE_FRAME;
             cameraFrame.mQuirks |= CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG;
 
             // populate exif data and pass to subscribers via quirk
@@ -2929,9 +2912,10 @@ OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLE
             cameraFrame.mCookie2 = (void*) exif;
             }
         else
-            {
+          {
             typeOfFrame = CameraFrame::RAW_FRAME;
-            }
+            mask = (unsigned int) CameraFrame::RAW_FRAME;
+          }
 
             pPortParam->mImageType = typeOfFrame;
 
@@ -2964,11 +2948,8 @@ OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLE
 
         mCapturedFrames--;
 
-        stat |= initCameraFrame(cameraFrame,
-                                pBuffHeader,
-                                typeOfFrame,
-                                pPortParam);
-        stat |= sendFrame(cameraFrame);
+        stat = sendCallBacks(cameraFrame, pBuffHeader, mask, pPortParam);
+
         }
     else
         {
@@ -3047,6 +3028,50 @@ status_t OMXCameraAdapter::sendFrame(CameraFrame &frame)
     return ret;
 }
 
+status_t OMXCameraAdapter::sendCallBacks(CameraFrame frame, OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader, unsigned int mask, OMXCameraPortParameters *port)
+{
+  status_t ret = NO_ERROR;
+
+  LOG_FUNCTION_NAME;
+
+  if ( NULL == port)
+    {
+      CAMHAL_LOGEA("Invalid portParam");
+      return -EINVAL;
+    }
+
+  if ( NULL == pBuffHeader )
+    {
+      CAMHAL_LOGEA("Invalid Buffer header");
+      return -EINVAL;
+    }
+
+  Mutex::Autolock lock(mSubscriberLock);
+
+  //frame.mFrameType = typeOfFrame;
+  frame.mFrameMask = mask;
+  frame.mBuffer = pBuffHeader->pBuffer;
+  frame.mLength = pBuffHeader->nFilledLen;
+  frame.mAlignment = port->mStride;
+  frame.mOffset = pBuffHeader->nOffset;
+  frame.mWidth = port->mWidth;
+  frame.mHeight = port->mHeight;
+
+  if ( onlyOnce && mRecording )
+    {
+      mTimeSourceDelta = (pBuffHeader->nTimeStamp * 1000) - systemTime(SYSTEM_TIME_MONOTONIC);
+      onlyOnce = false;
+    }
+
+  frame.mTimestamp = (pBuffHeader->nTimeStamp * 1000) - mTimeSourceDelta;
+  setInitFrameRefCount(frame.mBuffer, mask);
+  ret = sendFrameToSubscribers(&frame);
+
+  LOG_FUNCTION_NAME_EXIT;
+
+  return ret;
+}
+
 status_t OMXCameraAdapter::initCameraFrame( CameraFrame &frame,
                                             OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader,
                                             int typeOfFrame,
diff --git a/camera/inc/BaseCameraAdapter.h b/camera/inc/BaseCameraAdapter.h
index 15fb73f..c982f94 100644
--- a/camera/inc/BaseCameraAdapter.h
+++ b/camera/inc/BaseCameraAdapter.h
@@ -152,6 +152,7 @@ protected:
     //A couple of helper functions
     void setFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType, int refCount);
     int getFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType);
+    int setInitFrameRefCount(void* buf, unsigned int mask);
 
     enum FrameState {
         STOPPED = 0,
diff --git a/camera/inc/CameraHal.h b/camera/inc/CameraHal.h
index 47bd589..31ce3fd 100644
--- a/camera/inc/CameraHal.h
+++ b/camera/inc/CameraHal.h
@@ -254,6 +254,7 @@ class CameraFrame
     mAlignment(0),
     mFd(0),
     mLength(0),
+    mFrameMask(0),
     mQuirks(0) {}
 
     //copy constructor
@@ -269,6 +270,7 @@ class CameraFrame
     mAlignment(frame.mAlignment),
     mFd(frame.mFd),
     mLength(frame.mLength),
+    mFrameMask(frame.mFrameMask),
     mQuirks(frame.mQuirks) {}
 
     void *mCookie;
@@ -281,6 +283,7 @@ class CameraFrame
     unsigned int mAlignment;
     int mFd;
     size_t mLength;
+    unsigned mFrameMask;
     unsigned int mQuirks;
     ///@todo add other member vars like  stride etc
 };
diff --git a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
index c01ca02..4c85be4 100644
--- a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
+++ b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
@@ -592,6 +592,8 @@ private:
     //Sends the incoming OMX buffer header to subscribers
     status_t sendFrame(CameraFrame &frame);
 
+    status_t sendCallBacks(CameraFrame frame, OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader, unsigned int mask, OMXCameraPortParameters *port);
+
     status_t apply3Asettings( Gen3A_settings& Gen3A );
     status_t apply3ADefaults(Gen3A_settings &Gen3A);