SnapdragonCamera: Implement circular buffer for CS

Implement a buffer cache system for Clearsight registration.
Pre-allocate required number of buffers and re-use.
Remove loading bitmaps to CameraDataAdapter after capture as
we no longer are using FilmStripView.

CRs-Fixed: 1054487
Change-Id: I6af94b701efa85e8f3848b8c8e508bb688bc2f13

2 files changed, 113 insertions, 96 deletions

diff --git a/src/org/codeaurora/snapcam/filter/ClearSightImageProcessor.java b/src/org/codeaurora/snapcam/filter/ClearSightImageProcessor.java
index 1debb2007..ea37d379d 100644
--- a/src/org/codeaurora/snapcam/filter/ClearSightImageProcessor.java
+++ b/src/org/codeaurora/snapcam/filter/ClearSightImageProcessor.java
@@ -37,6 +37,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 import org.codeaurora.snapcam.filter.ClearSightNativeEngine.CamSystemCalibrationData;
+import org.codeaurora.snapcam.filter.ClearSightNativeEngine.ClearsightImage;
 
 import android.content.Context;
 import android.graphics.ImageFormat;
@@ -187,7 +188,8 @@ public class ClearSightImageProcessor {
         try {
             CameraCharacteristics cc = cm.getCameraCharacteristics("0");
             byte[] blob = cc.get(OTP_CALIB_BLOB);
-            ClearSightNativeEngine.setOtpCalibData(CamSystemCalibrationData.createFromBytes(blob));
+            ClearSightNativeEngine.getInstance().init(mNumFrameCount*2,
+                    width, height, CamSystemCalibrationData.createFromBytes(blob));
         } catch (CameraAccessException e) {
             e.printStackTrace();
         }
@@ -261,6 +263,7 @@ public class ClearSightImageProcessor {
         mCaptureSessions[CAM_TYPE_BAYER] = null;
         mMediaSaveService = null;
         mMediaSavedListener = null;
+        ClearSightNativeEngine.getInstance().close();
     }
 
     public void setCallback(Callback callback) {
@@ -466,9 +469,10 @@ public class ClearSightImageProcessor {
         private void processNewCaptureEvent(Message msg) {
              // Toss extra frames
             if(mCaptureDone) {
-                Log.d(TAG, "processNewCaptureEvent - captureDone - we already have required frame pairs");
+                Log.d(TAG, "processNewCaptureEvent - captureDone - we already have required frame pairs " + msg.arg1);
                 if(msg.what == MSG_NEW_IMG) {
                     Image image = (Image) msg.obj;
+                    Log.d(TAG, "processNewCaptureEvent - captureDone - tossed frame ts: " + image.getTimestamp());
                     image.close();
                 }
                 return;
@@ -684,15 +688,8 @@ public class ClearSightImageProcessor {
                 saveDebugImageAsNV21(image, isBayer, mNamedEntity, frameCount, ts/1000000);
             }
 
-            if (!ClearSightNativeEngine.getInstance()
-                    .hasReferenceImage(isBayer)) {
-                // reference not yet set
-                ClearSightNativeEngine.getInstance().setReferenceImage(isBayer,
-                        image);
-            } else {
-                mClearsightRegisterHandler.obtainMessage(MSG_NEW_IMG,
-                        msg.arg1, 0, msg.obj).sendToTarget();
-            }
+            mClearsightRegisterHandler.obtainMessage(MSG_NEW_IMG,
+                    msg.arg1, 0, msg.obj).sendToTarget();
 
             mReprocessingFrames.removeAt(mReprocessingFrames.indexOfValue(ts));
             checkReprocessDone();
@@ -761,10 +758,16 @@ public class ClearSightImageProcessor {
             boolean isBayer = (msg.arg1 == CAM_TYPE_BAYER);
             Image image = (Image)msg.obj;
 
-            // if ref images set, register this image
-            if(ClearSightNativeEngine.getInstance().registerImage(
-                    isBayer, image) == false) {
-                Log.w(TAG, "registerImage : terminal error with input image");
+            if (!ClearSightNativeEngine.getInstance()
+                    .hasReferenceImage(isBayer)) {
+                // reference not yet set
+                ClearSightNativeEngine.getInstance().setReferenceImage(isBayer, image);
+            } else {
+                // if ref images set, register this image
+                if(ClearSightNativeEngine.getInstance().registerImage(
+                        isBayer, image) == false) {
+                    Log.w(TAG, "registerImage : terminal error with input image");
+                }
             }
         }
     }
@@ -797,20 +800,16 @@ public class ClearSightImageProcessor {
                 if(mCallback != null)
                     mCallback.onClearSightSuccess();
 
-                ClearSightNativeEngine.ClearsightImage csImage = ClearSightNativeEngine.getInstance().processImage();
-                if(csImage != null) {
-                    Log.d(TAG, "reprocess - processClearSight, roiRect: "
-                            + csImage.getRoiRect().toString());
+                Image encodeImage = mImageWriter[CAM_TYPE_BAYER].dequeueInputImage();
+                ClearSightNativeEngine.ClearsightImage csImage = new ClearsightImage(encodeImage);
+                encodeImage.setTimestamp(csTs);
 
+                if(ClearSightNativeEngine.getInstance().processImage(csImage)) {
                     clearSightEncode = true;
-                    Image encodeImage = mImageWriter[CAM_TYPE_BAYER].dequeueInputImage();
-                    encodeImage.setCropRect(csImage.getRoiRect());
-                    encodeImage.setTimestamp(csTs);
-                    Plane[] planes = encodeImage.getPlanes();
-                    planes[0].getBuffer().put(csImage.mYplane);
-                    planes[2].getBuffer().put(csImage.mVUplane);
-
                     sendReprocessRequest(csRequest, encodeImage, CAM_TYPE_BAYER);
+                } else {
+                    csImage = null;
+                    encodeImage.close();
                 }
             } else {
                 if(mCallback != null)
diff --git a/src/org/codeaurora/snapcam/filter/ClearSightNativeEngine.java b/src/org/codeaurora/snapcam/filter/ClearSightNativeEngine.java
index 0380c3487..d6527d55a 100644
--- a/src/org/codeaurora/snapcam/filter/ClearSightNativeEngine.java
+++ b/src/org/codeaurora/snapcam/filter/ClearSightNativeEngine.java
@@ -61,17 +61,18 @@ public class ClearSightNativeEngine {
     private static final int VU_PLANE = 2;
 
     private static boolean mLibLoaded;
-    private static byte[] mOtpCalibData;
     private static ClearSightNativeEngine mInstance;
 
-    private int mYSize;
-    private int mVUSize;
+    private byte[] mOtpCalibData;
+    private int mImageWidth;
+    private int mImageHeight;
     private int mYStride;
     private int mVUStride;
     private Image mRefColorImage;
     private Image mRefMonoImage;
     private TotalCaptureResult mRefColorResult;
     private TotalCaptureResult mRefMonoResult;
+    private ArrayList<SourceImage> mCache = new ArrayList<SourceImage>();
     private ArrayList<SourceImage> mSrcColor = new ArrayList<SourceImage>();
     private ArrayList<SourceImage> mSrcMono = new ArrayList<SourceImage>();
 
@@ -89,18 +90,27 @@ public class ClearSightNativeEngine {
         return mInstance;
     }
 
-    public static void setOtpCalibData(CamSystemCalibrationData calibData) {
+    public void init(int frameCount, int width, int height, CamSystemCalibrationData calibData) {
         String calibStr = calibData.toString();
         Log.d(TAG, "OTP calibration data: \n" + calibStr);
         mOtpCalibData = calibStr.getBytes();
+        mImageWidth = width;
+        mImageHeight = height;
+        mYStride = width;
+        mVUStride = width;
+        while(frameCount > 0) {
+            cacheSourceImage(new SourceImage(width*height, width*height/2));
+            frameCount --;
+        }
     }
 
-    public void setImageSizeStride(Image image) {
-        Plane[] planes = image.getPlanes();
-        mYSize = planes[Y_PLANE].getBuffer().capacity();
-        mVUSize = planes[VU_PLANE].getBuffer().capacity();
-        mYStride = planes[Y_PLANE].getRowStride();
-        mVUStride = planes[VU_PLANE].getRowStride();
+    public void close() {
+        reset();
+        mCache.clear();
+        mImageWidth = 0;
+        mImageHeight = 0;
+        mYStride = 0;
+        mVUStride = 0;
     }
 
     public boolean isLibLoaded() {
@@ -108,14 +118,28 @@ public class ClearSightNativeEngine {
     }
 
     public void reset() {
-        mSrcColor.clear();
-        mSrcMono.clear();
+        while(!mSrcColor.isEmpty()) {
+            cacheSourceImage(mSrcColor.remove(0));
+        }
+        while(!mSrcMono.isEmpty()) {
+            cacheSourceImage(mSrcMono.remove(0));
+        }
         setReferenceColorImage(null);
         setReferenceMonoImage(null);
         setReferenceColorResult(null);
         setReferenceMonoResult(null);
     }
 
+    private SourceImage getNewSourceImage() {
+        Log.d(TAG, "getNewSourceImage: " + mCache.size());
+        return mCache.remove(0);
+    }
+
+    private void cacheSourceImage(SourceImage image) {
+        mCache.add(image);
+        Log.d(TAG, "cacheSourceImage: " + mCache.size());
+    }
+
     public void setReferenceResult(boolean color, TotalCaptureResult result) {
         if (color)
             setReferenceColorResult(result);
@@ -148,10 +172,13 @@ public class ClearSightNativeEngine {
 
         if (mRefColorImage != null) {
             Log.d(TAG, "setRefColorImage");
-            setImageSizeStride(mRefColorImage);
-            mSrcColor.add(new SourceImage(mRefColorImage.getPlanes()[Y_PLANE]
-                    .getBuffer(), mRefColorImage.getPlanes()[VU_PLANE]
-                            .getBuffer(), new float[] { 0, 0, 0, 0, 0, 0 }));
+            Plane[] planes = mRefColorImage.getPlanes();
+            SourceImage newSrc = getNewSourceImage();
+            newSrc.mY.rewind();
+            newSrc.mY.put(planes[Y_PLANE].getBuffer());
+            newSrc.mVU.rewind();
+            newSrc.mVU.put(planes[VU_PLANE].getBuffer());
+            mSrcColor.add(newSrc);
         }
     }
 
@@ -165,8 +192,11 @@ public class ClearSightNativeEngine {
 
         if (mRefMonoImage != null) {
             Log.d(TAG, "setRefMonoImage");
-            mSrcMono.add(new SourceImage(mRefMonoImage.getPlanes()[Y_PLANE]
-                    .getBuffer(), null, new float[] { 0, 0, 0, 0, 0, 0 }));
+            Plane[] planes = mRefMonoImage.getPlanes();
+            SourceImage newSrc = getNewSourceImage();
+            newSrc.mY.rewind();
+            newSrc.mY.put(planes[Y_PLANE].getBuffer());
+            mSrcMono.add(newSrc);
         }
     }
 
@@ -193,32 +223,31 @@ public class ClearSightNativeEngine {
             return false;
         }
 
-        Image referenceImage = color?mRefColorImage:mRefMonoImage;
+        SourceImage newSrc = getNewSourceImage();
+        SourceImage referenceImage = sourceImages.get(0);
         Plane[] planes = image.getPlanes();
         ByteBuffer yBuf = planes[Y_PLANE].getBuffer();
-        ByteBuffer refY = referenceImage.getPlanes()[Y_PLANE].getBuffer();
-        ByteBuffer regY = ByteBuffer.allocateDirect(refY.capacity());
+        ByteBuffer refY = referenceImage.mY;
+        ByteBuffer regY = newSrc.mY;
         int yRowStride = planes[Y_PLANE].getRowStride();
 
         ByteBuffer vuBuf = null;
-        ByteBuffer refVU = null;
         ByteBuffer regVU = null;
         int vuRowStride = 0;
         if(color) {
             vuBuf = planes[VU_PLANE].getBuffer();
-            refVU = referenceImage.getPlanes()[VU_PLANE].getBuffer();
-            regVU = ByteBuffer.allocateDirect(refVU.capacity());
+            regVU = newSrc.mVU;
             vuRowStride = planes[VU_PLANE].getRowStride();
         }
 
-        float[] metadata = new float[METADATA_SIZE];
+        float[] metadata = newSrc.mMetadata;
 
         boolean result = nativeClearSightRegisterImage(refY,
-                yBuf, vuBuf, image.getWidth(), image.getHeight(),
+                yBuf, vuBuf, mImageWidth, mImageHeight,
                 yRowStride, vuRowStride, regY, regVU, metadata);
 
         if (result) {
-            sourceImages.add(new SourceImage(regY, regVU, metadata));
+            sourceImages.add(newSrc);
         }
 
         image.close();
@@ -241,7 +270,7 @@ public class ClearSightNativeEngine {
         ByteBuffer[] srcMonoY = new ByteBuffer[numImages];
         float[][] metadataMono = new float[numImages][];
 
-        Log.d(TAG, "processImage - numImages: " + numImages);
+        Log.d(TAG, "processImage - num Images: " + numImages);
 
         for (int i = 0; i < numImages; i++) {
             SourceImage color = mSrcColor.get(i);
@@ -255,33 +284,22 @@ public class ClearSightNativeEngine {
             metadataMono[i] = mono.mMetadata;
         }
 
-        Plane[] colorPlanes = mRefColorImage.getPlanes();
-        Plane[] monoPlanes = mRefMonoImage.getPlanes();
-
-        Log.d(TAG, "processImage - refImage size - y: "
-                + colorPlanes[Y_PLANE].getBuffer().capacity()
-                + " vu: " + colorPlanes[VU_PLANE].getBuffer().capacity());
-
         int iso = mRefMonoResult.get(CaptureResult.SENSOR_SENSITIVITY);
         long exposure = mRefMonoResult.get(CaptureResult.SENSOR_EXPOSURE_TIME);
         // capture result stores exposure time in NS and we need MS.
         exposure /= 100000;
 
         Log.d(TAG, "processImage - iso: " + iso + " exposure ms: " + exposure);
-        return nativeClearSightProcessInit(numImages, srcColorY, srcColorVU,
-                metadataColor, mRefColorImage.getWidth(),
-                mRefColorImage.getHeight(),
-                colorPlanes[Y_PLANE].getRowStride(),
-                colorPlanes[VU_PLANE].getRowStride(), srcMonoY, metadataMono,
-                mRefMonoImage.getWidth(), mRefMonoImage.getHeight(),
-                monoPlanes[Y_PLANE].getRowStride(), mOtpCalibData,
-                (int)exposure, iso);
+        return nativeClearSightProcessInit(numImages,
+                srcColorY, srcColorVU, metadataColor, mImageWidth, mImageHeight,
+                mYStride, mVUStride, srcMonoY, metadataMono, mImageWidth, mImageHeight,
+                mYStride, mOtpCalibData, (int)exposure, iso);
     }
 
-    public ClearsightImage processImage() {
+    public boolean processImage(ClearsightImage csImage) {
         // check data validity
-        ByteBuffer dstY = ByteBuffer.allocateDirect(mYSize);
-        ByteBuffer dstVU = ByteBuffer.allocateDirect(mVUSize);
+        ByteBuffer dstY = csImage.getYBuffer();
+        ByteBuffer dstVU = csImage.getVUBuffer();
         int[] roiRect = new int[4];
 
         Log.d(TAG, "processImage - dst size - y: "
@@ -289,14 +307,12 @@ public class ClearSightNativeEngine {
 
         boolean result = nativeClearSightProcess(dstY, dstVU,
                 mYStride, mVUStride, roiRect);
+        csImage.setRoiRect(roiRect);
 
-        if (result) {
-            dstY.rewind();
-            dstVU.rewind();
-            return new ClearsightImage(dstY, dstVU, roiRect);
-        } else {
-            return null;
-        }
+        Log.d(TAG, "processImage - roiRect: "
+                + csImage.getRoiRect().toString());
+
+        return result;
     }
 
     private native final boolean nativeClearSightRegisterImage(ByteBuffer refY,
@@ -319,35 +335,37 @@ public class ClearSightNativeEngine {
         ByteBuffer mVU;
         float[] mMetadata;
 
-        SourceImage(ByteBuffer y, ByteBuffer vu, float[] metadata) {
-            mY = y;
-            mVU = vu;
-            mMetadata = metadata;
+        SourceImage(int ySize, int vuSize) {
+            mY = ByteBuffer.allocateDirect(ySize);
+            mVU = ByteBuffer.allocateDirect(vuSize);
+            mMetadata = new float[METADATA_SIZE];
         }
     }
 
     public static class ClearsightImage {
-        public final ByteBuffer mYplane;
-        public final ByteBuffer mVUplane;
+        private Image mImage;
         private Rect mRoiRect;
 
-        ClearsightImage(ByteBuffer yPlane, ByteBuffer vuPlane, int[] rect) {
-            mYplane = yPlane;
-            mVUplane = vuPlane;
-            mRoiRect = new Rect(rect[0], rect[1], rect[0] + rect[2], rect[1]
-                    + rect[3]);
+        ClearsightImage(Image image) {
+            mImage = image;
         }
 
-        public Rect getRoiRect() {
-            return mRoiRect;
+        public ByteBuffer getYBuffer() {
+            return mImage.getPlanes()[Y_PLANE].getBuffer();
         }
 
-        public int getWidth() {
-            return (mRoiRect.right - mRoiRect.left);
+        public ByteBuffer getVUBuffer() {
+            return mImage.getPlanes()[VU_PLANE].getBuffer();
         }
 
-        public int getHeight() {
-            return (mRoiRect.bottom - mRoiRect.top);
+        public void setRoiRect(int[] rect) {
+            mRoiRect = new Rect(rect[0], rect[1], rect[0] + rect[2], rect[1]
+                    + rect[3]);
+            mImage.setCropRect(mRoiRect);
+        }
+
+        public Rect getRoiRect() {
+            return mRoiRect;
         }
     }