Merge "SnapdragonCamera:Add Raw capture to developer option" into camera.lnx.1.0-dev.1.0

6 files changed, 257 insertions, 54 deletions

diff --git a/src/com/android/camera/CaptureModule.java b/src/com/android/camera/CaptureModule.java
index 26613786f..c74da6a7a 100644..100755
--- a/src/com/android/camera/CaptureModule.java
+++ b/src/com/android/camera/CaptureModule.java
@@ -294,6 +294,7 @@ public class CaptureModule implements CameraModule, PhotoController,
     private Uri mSaveUri;
     private boolean mQuickCapture;
     private byte[] mJpegImageData;
+    private boolean mSaveRaw = false;
 
     /**
      * A {@link CameraCaptureSession } for camera preview.
@@ -325,6 +326,7 @@ public class CaptureModule implements CameraModule, PhotoController,
      * An {@link ImageReader} that handles still image capture.
      */
     private ImageReader[] mImageReader = new ImageReader[MAX_NUM_CAM];
+    private ImageReader[] mRawImageReader = new ImageReader[MAX_NUM_CAM];
     private NamedImages mNamedImages;
     private ContentResolver mContentResolver;
     private byte[] mLastJpegData;
@@ -372,6 +374,7 @@ public class CaptureModule implements CameraModule, PhotoController,
 
     private MediaActionSound mSound;
     private Size mSupportedMaxPictureSize;
+    private Size mSupportedRawPictureSize;
 
 
     private class SelfieThread extends Thread {
@@ -791,6 +794,12 @@ public class CaptureModule implements CameraModule, PhotoController,
         return isBackCamera() && getCameraMode() == DUAL_MODE && value.equals("on");
     }
 
+    private boolean isRawCaptureOn() {
+        String value = mSettingsManager.getValue(SettingsManager.KEY_SAVERAW);
+        if (value == null) return  false;
+        return value.equals("enable");
+    }
+
     private boolean isMpoOn() {
         String value = mSettingsManager.getValue(SettingsManager.KEY_MPO);
         if (value == null) return false;
@@ -1066,10 +1075,16 @@ public class CaptureModule implements CameraModule, PhotoController,
                     list.add(surs);
                 }
                 list.add(mImageReader[id].getSurface());
+                if (mSaveRaw) {
+                    list.add(mRawImageReader[id].getSurface());
+                }
                 if(mChosenImageFormat == ImageFormat.YUV_420_888 || mChosenImageFormat == ImageFormat.PRIVATE) {
                     if (mPostProcessor.isZSLEnabled()) {
                         mPreviewRequestBuilder[id].addTarget(mImageReader[id].getSurface());
                         list.add(mPostProcessor.getZSLReprocessImageReader().getSurface());
+                        if (mSaveRaw) {
+                            mPreviewRequestBuilder[id].addTarget(mRawImageReader[id].getSurface());
+                        }
                         mCameraDevice[id].createReprocessableCaptureSession(new InputConfiguration(mImageReader[id].getWidth(),
                                 mImageReader[id].getHeight(), mImageReader[id].getImageFormat()), list, captureSessionCallback, null);
                     } else {
@@ -1458,6 +1473,9 @@ public class CaptureModule implements CameraModule, PhotoController,
                 checkAndPlayShutterSound(id);
                 mCaptureSession[id].stopRepeating();
                 captureBuilder.addTarget(mImageReader[id].getSurface());
+                if (mSaveRaw) {
+                    captureBuilder.addTarget(mRawImageReader[id].getSurface());
+                }
                 mPostProcessor.onStartCapturing();
                 if(mPostProcessor.isManualMode()) {
                     mPostProcessor.manualCapture(captureBuilder, mCaptureSession[id], mCaptureCallbackHandler);
@@ -1467,6 +1485,9 @@ public class CaptureModule implements CameraModule, PhotoController,
                 }
             } else {
                 captureBuilder.addTarget(mImageReader[id].getSurface());
+                if (mSaveRaw) {
+                    captureBuilder.addTarget(mRawImageReader[id].getSurface());
+                }
                 mCaptureSession[id].stopRepeating();
 
                 if (mLongshotActive) {
@@ -1665,19 +1686,24 @@ public class CaptureModule implements CameraModule, PhotoController,
                             mImageReader[i] = ImageReader.newInstance(mPictureSize.getWidth(),
                                     mPictureSize.getHeight(), imageFormat, mPostProcessor.getMaxRequiredImageNum());
                         }
+                        if (mSaveRaw) {
+                            mRawImageReader[i] = ImageReader.newInstance(mSupportedRawPictureSize.getWidth(),
+                                    mSupportedRawPictureSize.getHeight(), ImageFormat.RAW10, mPostProcessor.getMaxRequiredImageNum());
+                            mPostProcessor.setRawImageReader(mRawImageReader[i]);
+                        }
                         mImageReader[i].setOnImageAvailableListener(mPostProcessor.getImageHandler(), mImageAvailableHandler);
                         mPostProcessor.onImageReaderReady(mImageReader[i], mSupportedMaxPictureSize, mPictureSize);
                     } else {
                         mImageReader[i] = ImageReader.newInstance(mPictureSize.getWidth(),
                                 mPictureSize.getHeight(), imageFormat, PersistUtil.getLongshotShotLimit());
 
-                        mImageReader[i].setOnImageAvailableListener(new ImageAvailableListener(i) {
+                        ImageAvailableListener listener = new ImageAvailableListener(i) {
                             @Override
                             public void onImageAvailable(ImageReader reader) {
                                 Log.d(TAG, "image available for cam: " + mCamId);
                                 Image image = reader.acquireNextImage();
 
-                                if(isMpoOn()) {
+                                if (isMpoOn()) {
                                     mMpoSaveHandler.obtainMessage(
                                             MpoSaveHandler.MSG_NEW_IMG, mCamId, 0, image).sendToTarget();
                                 } else {
@@ -1689,32 +1715,44 @@ public class CaptureModule implements CameraModule, PhotoController,
 
                                     byte[] bytes = getJpegData(image);
 
-                                    ExifInterface exif = Exif.getExif(bytes);
-                                    int orientation = Exif.getOrientation(exif);
-
-                                    if (getCameraMode() != CaptureModule.INTENT_MODE_NORMAL) {
-                                        mJpegImageData = bytes;
-                                        if (!mQuickCapture) {
-                                            showCapturedReview(bytes, orientation,
-                                                    mPostProcessor.isSelfieMirrorOn());
-                                        } else {
-                                            onCaptureDone();
-                                        }
+                                    if (image.getFormat() == ImageFormat.RAW10) {
+                                        mActivity.getMediaSaveService().addRawImage(bytes, title,
+                                                "raw");
                                     } else {
-                                        mActivity.getMediaSaveService().addImage(bytes, title, date,
-                                                null, image.getWidth(), image.getHeight(), orientation, null,
-                                                mOnMediaSavedListener, mContentResolver, "jpeg");
-
-                                        if(mLongshotActive) {
-                                            mLastJpegData = bytes;
+                                        ExifInterface exif = Exif.getExif(bytes);
+                                        int orientation = Exif.getOrientation(exif);
+
+                                        if (getCameraMode() != CaptureModule.INTENT_MODE_NORMAL) {
+                                            mJpegImageData = bytes;
+                                            if (!mQuickCapture) {
+                                                showCapturedReview(bytes, orientation,
+                                                        mPostProcessor.isSelfieMirrorOn());
+                                            } else {
+                                                onCaptureDone();
+                                            }
                                         } else {
-                                            mActivity.updateThumbnail(bytes);
+                                            mActivity.getMediaSaveService().addImage(bytes, title, date,
+                                                    null, image.getWidth(), image.getHeight(), orientation, null,
+                                                    mOnMediaSavedListener, mContentResolver, "jpeg");
+
+                                            if (mLongshotActive) {
+                                                mLastJpegData = bytes;
+                                            } else {
+                                                mActivity.updateThumbnail(bytes);
+                                            }
                                         }
+                                        image.close();
                                     }
-                                    image.close();
                                 }
                             }
-                        }, mImageAvailableHandler);
+                        };
+                        mImageReader[i].setOnImageAvailableListener(listener, mImageAvailableHandler);
+
+                        if (mSaveRaw) {
+                            mRawImageReader[i] = ImageReader.newInstance(mSupportedRawPictureSize.getWidth(),
+                                    mSupportedRawPictureSize.getHeight(), ImageFormat.RAW10, PersistUtil.getLongshotShotLimit());
+                            mRawImageReader[i].setOnImageAvailableListener(listener, mImageAvailableHandler);
+                        }
                     }
                 }
             }
@@ -2257,12 +2295,14 @@ public class CaptureModule implements CameraModule, PhotoController,
             if(flashMode != null && flashMode.equalsIgnoreCase("on")) {
                 isFlashOn = true;
             }
+
+            mSaveRaw = isRawCaptureOn();
             if (scene != null) {
                 int mode = Integer.parseInt(scene);
                 Log.d(TAG, "Chosen postproc filter id : " + getPostProcFilterId(mode));
-                mPostProcessor.onOpen(getPostProcFilterId(mode), isFlashOn, isTrackingFocusSettingOn(), isMakeupOn, isSelfieMirrorOn);
+                mPostProcessor.onOpen(getPostProcFilterId(mode), isFlashOn, isTrackingFocusSettingOn(), isMakeupOn, isSelfieMirrorOn, mSaveRaw);
             } else {
-                mPostProcessor.onOpen(PostProcessor.FILTER_NONE, isFlashOn, isTrackingFocusSettingOn(), isMakeupOn, isSelfieMirrorOn);
+                mPostProcessor.onOpen(PostProcessor.FILTER_NONE, isFlashOn, isTrackingFocusSettingOn(), isMakeupOn, isSelfieMirrorOn, mSaveRaw);
             }
         }
         if(mFrameProcessor != null) {
@@ -2881,6 +2921,9 @@ public class CaptureModule implements CameraModule, PhotoController,
         Size[] prevSizes = mSettingsManager.getSupportedOutputSize(getMainCameraId(),
                 SurfaceHolder.class);
         mSupportedMaxPictureSize = prevSizes[0];
+        Size[] rawSize = mSettingsManager.getSupportedOutputSize(getMainCameraId(),
+                    ImageFormat.RAW10);
+        mSupportedRawPictureSize = rawSize[0];
         mPreviewSize = getOptimalPreviewSize(mPictureSize, prevSizes, screenSize.x, screenSize.y);
         Size[] thumbSizes = mSettingsManager.getSupportedThumbnailSizes(getMainCameraId());
         mPictureThumbSize = getOptimalPreviewSize(mPictureSize, thumbSizes, 0, 0); // get largest thumb size
@@ -4224,6 +4267,7 @@ public class CaptureModule implements CameraModule, PhotoController,
                     updateVideoFlash();
                     return;
                 case SettingsManager.KEY_FLASH_MODE:
+                case SettingsManager.KEY_SAVERAW:
                     if (count == 0) restartSession(false);
                     return;
                 case SettingsManager.KEY_SCENE_MODE:
diff --git a/src/com/android/camera/MediaSaveService.java b/src/com/android/camera/MediaSaveService.java
index 0daad1bab..2d7247d83 100644..100755
--- a/src/com/android/camera/MediaSaveService.java
+++ b/src/com/android/camera/MediaSaveService.java
@@ -134,6 +134,20 @@ public class MediaSaveService extends Service {
         t.execute();
     }
 
+    public void addRawImage(final byte[] data, String title, String pictureFormat) {
+        if (isQueueFull()) {
+            Log.e(TAG, "Cannot add image when the queue is full");
+            return;
+        }
+        RawImageSaveTask t = new RawImageSaveTask(data, title, pictureFormat);
+
+        mMemoryUse += data.length;
+        if (isQueueFull()) {
+            onQueueFull();
+        }
+        t.execute();
+    }
+
     public void addImage(final byte[] data, String title, long date, Location loc,
                          int orientation, ExifInterface exif,
                          OnMediaSavedListener l, ContentResolver resolver) {
@@ -250,6 +264,36 @@ public class MediaSaveService extends Service {
         }
     }
 
+    private class RawImageSaveTask extends AsyncTask<Void, Void, Long> {
+        private byte[] data;
+        private String title;
+        private String pictureFormat;
+
+        public RawImageSaveTask(byte[] data, String title, String pictureFormat) {
+            this.data = data;
+            this.title = title;
+            this.pictureFormat = pictureFormat;
+        }
+
+        @Override
+        protected void onPreExecute() {
+            super.onPreExecute();
+        }
+
+        @Override
+        protected Long doInBackground(Void... params) {
+            long length = Storage.addRawImage(title, data, pictureFormat);
+            return new Long(length);
+        }
+
+        @Override
+        protected void onPostExecute(Long l) {
+            boolean previouslyFull = isQueueFull();
+            mMemoryUse -= data.length;
+            if (isQueueFull() != previouslyFull) onQueueAvailable();
+        }
+    }
+
     private class ImageSaveTask extends AsyncTask <Void, Void, Uri> {
         private byte[] data;
         private String title;
diff --git a/src/com/android/camera/SettingsManager.java b/src/com/android/camera/SettingsManager.java
index 3ce646049..f553c6051 100644
--- a/src/com/android/camera/SettingsManager.java
+++ b/src/com/android/camera/SettingsManager.java
@@ -143,6 +143,8 @@ public class SettingsManager implements ListMenu.SettingsListener {
     public static final String KEY_ANTI_BANDING_LEVEL = "pref_camera2_anti_banding_level_key";
     public static final String KEY_HISTOGRAM = "pref_camera2_histogram_key";
     public static final String KEY_HDR = "pref_camera2_hdr_key";
+    public static final String KEY_SAVERAW = "pref_camera2_saveraw_key";
+
     private static final String TAG = "SnapCam_SettingsManager";
 
     private static SettingsManager sInstance;
diff --git a/src/com/android/camera/Storage.java b/src/com/android/camera/Storage.java
index 6239494dc..13f65e14c 100644..100755
--- a/src/com/android/camera/Storage.java
+++ b/src/com/android/camera/Storage.java
@@ -168,6 +168,18 @@ public class Storage {
          return insertImage(resolver, values);
     }
 
+    public static long addRawImage(String title, byte[] data,
+                                  String mimeType) {
+        String path = generateFilepath(title, mimeType);
+        int size = writeFile(path, data, null, mimeType);
+        // Try to get the real image size after add exif.
+        File f = new File(path);
+        if (f.exists() && f.isFile()) {
+            size = (int) f.length();
+        }
+        return size;
+    }
+
     // Overwrites the file and updates the MediaStore, or inserts the image if
     // one does not already exist.
     public static void updateImage(Uri imageUri, ContentResolver resolver, String title, long date,
diff --git a/src/com/android/camera/imageprocessor/PostProcessor.java b/src/com/android/camera/imageprocessor/PostProcessor.java
index 73a0049d4..546485675 100755
--- a/src/com/android/camera/imageprocessor/PostProcessor.java
+++ b/src/com/android/camera/imageprocessor/PostProcessor.java
@@ -130,6 +130,7 @@ public class PostProcessor{
     private ImageReader mImageReader;
     private ImageReader mZSLReprocessImageReader;
     private boolean mUseZSL = true;
+    private boolean mSaveRaw = false;
     private Handler mZSLHandler;
     private HandlerThread mZSLHandlerThread;
     private Handler mSavingHander;
@@ -139,7 +140,7 @@ public class PostProcessor{
     private TotalCaptureResult mZSLFallOffResult = null;
     private boolean mIsZSLFallOff = false;
     private TotalCaptureResult mLatestResultForLongShot = null;
-    private LinkedList<Image> mFallOffImages = new LinkedList<Image>();
+    private LinkedList<ZSLQueue.ImageItem> mFallOffImages = new LinkedList<ZSLQueue.ImageItem>();
     private int mPendingContinuousRequestCount = 0;
     public int mMaxRequiredImageNum;
 
@@ -165,10 +166,18 @@ public class PostProcessor{
 
     private class ImageWrapper {
         Image mImage;
+        Image mRawImage;
         boolean mIsTaken;
 
         public ImageWrapper(Image image) {
             mImage = image;
+            mRawImage = null;
+            mIsTaken = false;
+        }
+
+        public ImageWrapper(Image image, Image rawImage) {
+            mImage = image;
+            mRawImage = rawImage;
             mIsTaken = false;
         }
 
@@ -180,23 +189,31 @@ public class PostProcessor{
             mIsTaken = true;
             return mImage;
         }
+
+        public Image getRawImage() {
+            return mRawImage;
+        }
     }
 
     private void clearFallOffImage() {
-        for(Image im: mFallOffImages ) {
+        for(ZSLQueue.ImageItem item: mFallOffImages ) {
             try {
-                im.close();
+                item.getImage().close();
+                Image raw = item.getRawImage();
+                if (raw != null) {
+                    raw.close();
+                }
             } catch(Exception e) {
             }
         }
         mFallOffImages.clear();
     }
 
-    private Image findFallOffImage(long timestamp) {
-        Image foundImage = null;
-        for(Image im: mFallOffImages ) {
-            if(im.getTimestamp() == timestamp) {
-                foundImage = im;
+    private ZSLQueue.ImageItem findFallOffImage(long timestamp) {
+        ZSLQueue.ImageItem foundImage = null;
+        for(ZSLQueue.ImageItem item: mFallOffImages ) {
+            if(item.getImage().getTimestamp() == timestamp) {
+                foundImage = item;
                 break;
             }
         }
@@ -206,12 +223,16 @@ public class PostProcessor{
         return foundImage;
     }
 
-    private void addFallOffImage(Image image) {
-        mFallOffImages.add(image);
+    private void addFallOffImage(ZSLQueue.ImageItem item) {
+        mFallOffImages.add(item);
         if(mFallOffImages.size() >= MAX_REQUIRED_IMAGE_NUM - 1) {
-            Image im = mFallOffImages.getFirst();
+            ZSLQueue.ImageItem it = mFallOffImages.getFirst();
             try {
-                im.close();
+                it.getImage().close();
+                Image raw = item.getRawImage();
+                if (raw != null) {
+                    raw.close();
+                }
             } catch(Exception e) {
             }
             mFallOffImages.removeFirst();
@@ -220,6 +241,7 @@ public class PostProcessor{
 
     class ImageHandlerTask implements Runnable, ImageReader.OnImageAvailableListener {
         private ImageWrapper mImageWrapper = null;
+        private ImageReader mRawImageReader = null;
         Semaphore mMutureLock = new Semaphore(1);
 
         @Override
@@ -228,24 +250,42 @@ public class PostProcessor{
                 if(mUseZSL) {
                     if(mController.isLongShotActive() && mPendingContinuousRequestCount > 0) {
                         Image image = reader.acquireNextImage();
+                        Image rawImage = null;
+                        if (mSaveRaw && mRawImageReader != null) {
+                            rawImage = mRawImageReader.acquireNextImage();
+                        }
                         ZSLQueue.ImageItem item = new ZSLQueue.ImageItem();
-                        item.setImage(image);
+                        item.setImage(image, rawImage);
                         if(onContinuousZSLImage(item, true)) {
                             image.close();
+                            if (rawImage != null) {
+                                rawImage.close();
+                            }
                         }
                         return;
                     }
                     if(mIsZSLFallOff) {
                         Image image = reader.acquireNextImage();
+                        Image rawImage = null;
+                        if (mSaveRaw && mRawImageReader != null) {
+                            rawImage = mRawImageReader.acquireNextImage();
+                        }
+                        ZSLQueue.ImageItem imageItem = new ZSLQueue.ImageItem();
+                        imageItem.setImage(image,rawImage);
                         if(mZSLFallOffResult == null) {
-                            addFallOffImage(image);
+                            addFallOffImage(imageItem);
                             return;
                         }
-                        addFallOffImage(image);
-                        Image foundImage = findFallOffImage(mZSLFallOffResult.get(CaptureResult.SENSOR_TIMESTAMP).longValue());
-                        if(foundImage != null) {
+                        addFallOffImage(imageItem);
+                        ZSLQueue.ImageItem foundImage = findFallOffImage(
+                                mZSLFallOffResult.get(CaptureResult.SENSOR_TIMESTAMP).longValue());
+                        if(foundImage != null && foundImage.getImage() != null) {
                             Log.d(TAG,"ZSL fall off image is found");
-                            reprocessImage(foundImage, mZSLFallOffResult);
+                            reprocessImage(foundImage.getImage(), mZSLFallOffResult);
+                            Image raw = foundImage.getRawImage();
+                            if (raw != null) {
+                                onRawImageToProcess(raw);
+                            }
                             mIsZSLFallOff = false;
                             clearFallOffImage();
                             mZSLFallOffResult = null;
@@ -256,18 +296,33 @@ public class PostProcessor{
                     }
 
                     Image image = reader.acquireLatestImage();
+                    Image rawImage = null;
+                    if (mSaveRaw && mRawImageReader != null) {
+                        rawImage = mRawImageReader.acquireLatestImage();
+                    }
+
                     if (image == null) {
                         return;
                     }
                     if (!mMutureLock.tryAcquire()) {
                         image.close();
+                        if (rawImage != null) {
+                            rawImage.close();
+                        }
                         return;
                     }
                     if (mImageWrapper == null || mImageWrapper.isTaken()) {
-                        mImageWrapper = new ImageWrapper(image);
+                        if (mSaveRaw && rawImage != null) {
+                            mImageWrapper = new ImageWrapper(image, rawImage);
+                        } else {
+                            mImageWrapper = new ImageWrapper(image);
+                        }
                         mMutureLock.release();
                     } else {
                         image.close();
+                        if (rawImage != null) {
+                            rawImage.close();
+                        }
                         mMutureLock.release();
                         return;
                     }
@@ -276,8 +331,15 @@ public class PostProcessor{
                     }
                 } else { //Non ZSL case
                     Image image = reader.acquireNextImage();
+                    Image rawImage = null;
                     if(image != null) {
                         onImageToProcess(image);
+                        if (mSaveRaw && mRawImageReader != null) {
+                            rawImage = mRawImageReader.acquireNextImage();
+                        }
+                        if (rawImage != null) {
+                            onRawImageToProcess(rawImage);
+                        }
                     }
                 }
             } catch (IllegalStateException e) {
@@ -290,18 +352,27 @@ public class PostProcessor{
 
         @Override
         public void run() {   //Only ZSL case
-           Image image = mImageWrapper.getImage();
+            Image image = mImageWrapper.getImage();
+            Image rawImage = mImageWrapper.getRawImage();
             try {
                 mMutureLock.acquire();
                 if (mUseZSL) {
                     if (mZSLQueue != null) {
-                        mZSLQueue.add(image);
+                        mZSLQueue.add(image, rawImage);
                     }
                 }
                 mMutureLock.release();
             } catch (InterruptedException e) {
             }
         }
+
+        public void setRawImageReader(ImageReader rawImageReader) {
+            mRawImageReader = rawImageReader;
+        }
+    }
+
+    public void setRawImageReader(ImageReader rawImageReader) {
+        mImageHandlerTask.setRawImageReader(rawImageReader);
     }
 
     public void onMetaAvailable(TotalCaptureResult metadata) {
@@ -379,6 +450,9 @@ public class PostProcessor{
         if (imageItem != null) {
             if(DEBUG_ZSL) Log.d(TAG,"Got the item from the queue");
             reprocessImage(imageItem.getImage(), imageItem.getMetadata());
+            if (mSaveRaw && imageItem.getRawImage() != null) {
+                onRawImageToProcess(imageItem.getRawImage());
+            }
             return true;
         } else {
             if(DEBUG_ZSL) Log.d(TAG, "No good item in queue, register the request for the future");
@@ -397,11 +471,17 @@ public class PostProcessor{
         if(isLongShotRequest) {
             if(mLatestResultForLongShot != null) {
                 reprocessImage(imageItem.getImage(), mLatestResultForLongShot);
+                if (imageItem.getRawImage() != null) {
+                    onRawImageToProcess(imageItem.getRawImage());
+                }
                 mPendingContinuousRequestCount--;
                 return true;
             }
         } else {
             reprocessImage(imageItem.getImage(), imageItem.getMetadata());
+            if (imageItem.getRawImage() != null) {
+                onRawImageToProcess(imageItem.getRawImage());
+            }
             return true;
         }
 
@@ -509,6 +589,17 @@ public class PostProcessor{
         }
     }
 
+    private void onRawImageToProcess(Image image) {
+        ByteBuffer buffer = image.getPlanes()[0].getBuffer();
+        byte[] data = new byte[buffer.remaining()];
+        buffer.get(data);
+        long captureStartTime = System.currentTimeMillis();
+        mNamedImages.nameNewImage(captureStartTime);
+        PhotoModule.NamedImages.NamedEntity name = mNamedImages.getNextNameEntity();
+        String title = (name == null) ? null : name.title;
+        mActivity.getMediaSaveService().addRawImage(data, title, "raw");
+    }
+
     enum STATUS {
         DEINIT,
         INIT,
@@ -574,9 +665,9 @@ public class PostProcessor{
         return false;
     }
 
-    public void onOpen(int postFilterId, boolean isFlashModeOn, boolean isTrackingFocusOn, boolean isMakeupOn, boolean isSelfieMirrorOn) {
+    public void onOpen(int postFilterId, boolean isFlashModeOn, boolean isTrackingFocusOn, boolean isMakeupOn, boolean isSelfieMirrorOn, boolean isSaveRaw) {
         mImageHandlerTask = new ImageHandlerTask();
-
+        mSaveRaw = isSaveRaw;
         if(setFilter(postFilterId) || isFlashModeOn || isTrackingFocusOn || isMakeupOn || isSelfieMirrorOn
                 || PersistUtil.getCameraZSLDisabled()
                 || SettingsManager.getInstance().isCamera2HDRSupport()) {
diff --git a/src/com/android/camera/imageprocessor/ZSLQueue.java b/src/com/android/camera/imageprocessor/ZSLQueue.java
index f50858a35..b9dea4e51 100644..100755
--- a/src/com/android/camera/imageprocessor/ZSLQueue.java
+++ b/src/com/android/camera/imageprocessor/ZSLQueue.java
@@ -87,7 +87,7 @@ public class ZSLQueue {
         return -1;
     }
 
-    public void add(Image image) {
+    public void add(Image image, Image rawImage) {
         int lastIndex = -1;
         synchronized (mLock) {
             if(mBuffer == null)
@@ -99,7 +99,7 @@ public class ZSLQueue {
             }
             if(mBuffer[mImageHead].getMetadata() != null) {
                 if((mBuffer[mImageHead].getMetadata().get(CaptureResult.SENSOR_TIMESTAMP)).longValue() == image.getTimestamp()) {
-                    mBuffer[mImageHead].setImage(image);
+                    mBuffer[mImageHead].setImage(image,rawImage);
                     lastIndex = mImageHead;
                     mImageHead = (mImageHead + 1) % mBuffer.length;
                 } else if((mBuffer[mImageHead].getMetadata().get(CaptureResult.SENSOR_TIMESTAMP)).longValue() > image.getTimestamp()) {
@@ -107,17 +107,17 @@ public class ZSLQueue {
                 } else {
                     int i = findMeta(image.getTimestamp(), mImageHead);
                     if(i == -1) {
-                        mBuffer[mImageHead].setImage(image);
+                        mBuffer[mImageHead].setImage(image, rawImage);
                         mBuffer[mImageHead].setMetadata(null);
                         mImageHead = (mImageHead + 1) % mBuffer.length;
                     } else {
                         lastIndex = mImageHead = i;
-                        mBuffer[mImageHead].setImage(image);
+                        mBuffer[mImageHead].setImage(image, rawImage);
                         mImageHead = (mImageHead + 1) % mBuffer.length;
                     }
                 }
             } else {
-                mBuffer[mImageHead].setImage(image);
+                mBuffer[mImageHead].setImage(image, rawImage);
                 lastIndex = mImageHead;
                 mImageHead = (mImageHead + 1) % mBuffer.length;
             }
@@ -156,7 +156,7 @@ public class ZSLQueue {
                 } else {
                     int i = findImage(timestamp, mMetaHead);
                     if(i == -1) {
-                        mBuffer[mMetaHead].setImage(null);
+                        mBuffer[mMetaHead].setImage(null, null);
                         mBuffer[mMetaHead].setMetadata(metadata);
                         mMetaHead = (mMetaHead + 1) % mBuffer.length;
                     } else {
@@ -238,17 +238,24 @@ public class ZSLQueue {
 
     static class ImageItem {
         private Image mImage = null;
+        private Image mRawImage = null;
         private TotalCaptureResult mMetadata = null;
 
         public Image getImage() {
             return mImage;
         }
 
-        public void setImage(Image image) {
+        public Image getRawImage() {return mRawImage;}
+
+        public void setImage(Image image, Image rawImage) {
             if(mImage != null) {
                 mImage.close();
             }
+            if(mRawImage != null) {
+                mRawImage.close();
+            }
             mImage = image;
+            mRawImage =rawImage;
         }
 
         public TotalCaptureResult getMetadata() {
@@ -263,6 +270,9 @@ public class ZSLQueue {
             if(mImage != null) {
                 mImage.close();
             }
+            if(mRawImage != null) {
+                mRawImage.close();
+            }
             mImage = null;
         }