Fix filters only + geometry only rendering

Change-Id: Id8f0637ae53864488cb931def196ee50ae807f5c

6 files changed, 204 insertions, 138 deletions

diff --git a/src/com/android/gallery3d/filtershow/cache/FilteringPipeline.java b/src/com/android/gallery3d/filtershow/cache/FilteringPipeline.java
index e59b6c3eb..08a9a718e 100644
--- a/src/com/android/gallery3d/filtershow/cache/FilteringPipeline.java
+++ b/src/com/android/gallery3d/filtershow/cache/FilteringPipeline.java
@@ -43,11 +43,9 @@ public class FilteringPipeline implements Handler.Callback {
 
     private HandlerThread mHandlerThread = null;
     private final static int NEW_PRESET = 0;
-    private final static int NEW_GEOMETRY_PRESET = 1;
-    private final static int NEW_FILTERS_PRESET = 2;
-    private final static int COMPUTE_PRESET = 3;
-    private final static int COMPUTE_GEOMETRY_PRESET = 4;
-    private final static int COMPUTE_FILTERS_PRESET = 5;
+    private final static int NEW_RENDERING_REQUEST = 1;
+    private final static int COMPUTE_PRESET = 2;
+    private final static int COMPUTE_RENDERING_REQUEST = 3;
 
     private Handler mProcessingHandler = null;
     private final Handler mUIHandler = new Handler() {
@@ -60,16 +58,9 @@ public class FilteringPipeline implements Handler.Callback {
                     MasterImage.getImage().notifyObservers();
                     break;
                 }
-                case NEW_GEOMETRY_PRESET: {
-                    TripleBufferBitmap buffer = MasterImage.getImage().getGeometryOnlyBuffer();
-                    buffer.swapConsumer();
-                    MasterImage.getImage().notifyObservers();
-                    break;
-                }
-                case NEW_FILTERS_PRESET: {
-                    TripleBufferBitmap buffer = MasterImage.getImage().getFiltersOnlyBuffer();
-                    buffer.swapConsumer();
-                    MasterImage.getImage().notifyObservers();
+                case NEW_RENDERING_REQUEST: {
+                    RenderingRequest request = (RenderingRequest) msg.obj;
+                    request.markAvailable();
                     break;
                 }
             }
@@ -88,21 +79,11 @@ public class FilteringPipeline implements Handler.Callback {
                 mUIHandler.sendMessage(uimsg);
                 break;
             }
-            case COMPUTE_GEOMETRY_PRESET: {
-                ImagePreset preset = (ImagePreset) msg.obj;
-                TripleBufferBitmap buffer = MasterImage.getImage().getGeometryOnlyBuffer();
-                compute(buffer, preset, COMPUTE_GEOMETRY_PRESET);
-                buffer.swapProducer();
-                Message uimsg = mUIHandler.obtainMessage(NEW_GEOMETRY_PRESET);
-                mUIHandler.sendMessage(uimsg);
-                break;
-            }
-            case COMPUTE_FILTERS_PRESET: {
-                ImagePreset preset = (ImagePreset) msg.obj;
-                TripleBufferBitmap buffer = MasterImage.getImage().getFiltersOnlyBuffer();
-                compute(buffer, preset, COMPUTE_FILTERS_PRESET);
-                buffer.swapProducer();
-                Message uimsg = mUIHandler.obtainMessage(NEW_FILTERS_PRESET);
+            case COMPUTE_RENDERING_REQUEST: {
+                RenderingRequest request = (RenderingRequest) msg.obj;
+                render(request);
+                Message uimsg = mUIHandler.obtainMessage(NEW_RENDERING_REQUEST);
+                uimsg.obj = request;
                 mUIHandler.sendMessage(uimsg);
                 break;
             }
@@ -115,7 +96,6 @@ public class FilteringPipeline implements Handler.Callback {
     private float mResizeFactor = 1.0f;
     private long mResizeTime = 0;
 
-    private Allocation mOriginalBitmapAllocation = null;
     private Allocation mOriginalAllocation = null;
     private Allocation mFiltersOnlyOriginalAllocation =  null;
 
@@ -135,10 +115,6 @@ public class FilteringPipeline implements Handler.Callback {
         Log.v(LOGTAG,"setOriginal, size " + bitmap.getWidth() + " x " + bitmap.getHeight());
         updateOriginalAllocation(MasterImage.getImage().getPreset());
         updatePreviewBuffer();
-        /*
-        updateFiltersOnlyPreviewBuffer();
-        updateGeometryOnlyPreviewBuffer();
-        */
     }
 
     public synchronized boolean updateOriginalAllocation(ImagePreset preset) {
@@ -174,56 +150,30 @@ public class FilteringPipeline implements Handler.Callback {
         return true;
     }
 
-    public synchronized void updatePreviewBuffer() {
+    public void postRenderingRequest(RenderingRequest request) {
         if (mOriginalAllocation == null) {
             return;
         }
-        if (mProcessingHandler.hasMessages(COMPUTE_PRESET)) {
-            return;
-        }
-        if (!needsRepaint()) {
-            return;
-        }
-        if (MasterImage.getImage().getPreset() == null) {
-            return;
-        }
-        Message msg = mProcessingHandler.obtainMessage(COMPUTE_PRESET);
-        msg.obj = MasterImage.getImage().getPreset();
+        Message msg = mProcessingHandler.obtainMessage(COMPUTE_RENDERING_REQUEST);
+        msg.obj = request;
         mProcessingHandler.sendMessage(msg);
     }
 
-    public void updateGeometryOnlyPreviewBuffer() {
+    public synchronized void updatePreviewBuffer() {
         if (mOriginalAllocation == null) {
             return;
         }
-        if (!needsGeometryRepaint()) {
+        if (mProcessingHandler.hasMessages(COMPUTE_PRESET)) {
             return;
         }
-        if (mProcessingHandler.hasMessages(COMPUTE_GEOMETRY_PRESET)) {
-            mProcessingHandler.removeMessages(COMPUTE_GEOMETRY_PRESET);
-        }
-        Message msg = mProcessingHandler.obtainMessage(COMPUTE_GEOMETRY_PRESET);
-        ImagePreset preset = new ImagePreset(MasterImage.getImage().getGeometryPreset());
-        setPresetParameters(preset);
-        msg.obj = preset;
-        mProcessingHandler.sendMessage(msg);
-    }
-
-    public void updateFiltersOnlyPreviewBuffer() {
-        if (mOriginalAllocation == null) {
+        if (!needsRepaint()) {
             return;
         }
-        if (!needsFiltersRepaint()) {
+        if (MasterImage.getImage().getPreset() == null) {
             return;
         }
-        if (mProcessingHandler.hasMessages(COMPUTE_FILTERS_PRESET)) {
-            mProcessingHandler.removeMessages(COMPUTE_FILTERS_PRESET);
-        }
-        Message msg = mProcessingHandler.obtainMessage(COMPUTE_FILTERS_PRESET);
-        ImagePreset preset = new ImagePreset(MasterImage.getImage().getFiltersOnlyPreset());
-        setPresetParameters(preset);
-
-        msg.obj = preset;
+        Message msg = mProcessingHandler.obtainMessage(COMPUTE_PRESET);
+        msg.obj = MasterImage.getImage().getPreset();
         mProcessingHandler.sendMessage(msg);
     }
 
@@ -236,6 +186,27 @@ public class FilteringPipeline implements Handler.Callback {
         }
     }
 
+    private void render(RenderingRequest request) {
+        if (request.getBitmap() == null
+                || request.getImagePreset() == null) {
+            return;
+        }
+        Bitmap bitmap = request.getBitmap();
+        ImagePreset preset = request.getImagePreset();
+        updateOriginalAllocation(preset);
+        if (request.getType() == RenderingRequest.FULL_RENDERING
+                || request.getType() == RenderingRequest.GEOMETRY_RENDERING) {
+            mOriginalAllocation.copyTo(bitmap);
+        } else {
+            mFiltersOnlyOriginalAllocation.copyTo(bitmap);
+        }
+        if (request.getType() == RenderingRequest.FULL_RENDERING
+                || request.getType() == RenderingRequest.FILTERS_RENDERING) {
+            Bitmap bmp = preset.apply(bitmap);
+            request.setBitmap(bmp);
+        }
+    }
+
     private void compute(TripleBufferBitmap buffer, ImagePreset preset, int type) {
         if (DEBUG) {
             Log.v(LOGTAG, "compute preset " + preset);
@@ -250,30 +221,14 @@ public class FilteringPipeline implements Handler.Callback {
         Bitmap bitmap = buffer.getProducer();
         long time2 = System.currentTimeMillis();
 
-        if (type != COMPUTE_FILTERS_PRESET) {
-            if (bitmap == null || (bitmap.getWidth() != mResizedOriginalBitmap.getWidth())
-                    || (bitmap.getHeight() != mResizedOriginalBitmap.getHeight())) {
-                buffer.updateBitmaps(mResizedOriginalBitmap);
-                bitmap = buffer.getProducer();
-            }
-            mOriginalAllocation.copyTo(bitmap);
-        } else {
-            if (bitmap == null || (bitmap.getWidth() != mOriginalBitmap.getWidth())
-                    || (bitmap.getHeight() != mOriginalBitmap.getHeight())) {
-                buffer.updateBitmaps(mOriginalBitmap);
-                bitmap = buffer.getProducer();
-            }
-            mFiltersOnlyOriginalAllocation.copyTo(bitmap);
-        }
-
-        if (mOriginalAllocation == null || bitmap == null) {
-            Log.v(LOGTAG, "exiting compute because mOriginalAllocation: " + mOriginalAllocation + " or bitmap: " + bitmap);
-            return;
+        if (bitmap == null || (bitmap.getWidth() != mResizedOriginalBitmap.getWidth())
+                || (bitmap.getHeight() != mResizedOriginalBitmap.getHeight())) {
+            buffer.updateBitmaps(mResizedOriginalBitmap);
+            bitmap = buffer.getProducer();
         }
+        mOriginalAllocation.copyTo(bitmap);
 
-        if (type != COMPUTE_GEOMETRY_PRESET) {
-            bitmap = preset.apply(bitmap);
-        }
+        bitmap = preset.apply(bitmap);
 
         time = System.currentTimeMillis() - time;
         time2 = System.currentTimeMillis() - time2;
@@ -287,10 +242,6 @@ public class FilteringPipeline implements Handler.Callback {
                 mResizeTime = System.currentTimeMillis();
                 mResizeFactor *= RESIZE_FACTOR;
             }
-        } else if (type == COMPUTE_GEOMETRY_PRESET) {
-            mPreviousGeometryPreset = preset;
-        } else if (type == COMPUTE_FILTERS_PRESET) {
-            mPreviousFiltersPreset = preset;
         }
     }
 
@@ -299,29 +250,6 @@ public class FilteringPipeline implements Handler.Callback {
         return buffer.checkRepaintNeeded();
     }
 
-    private synchronized boolean needsGeometryRepaint() {
-        ImagePreset preset = MasterImage.getImage().getPreset();
-        if (preset == null || mPreviousGeometry == null || mPreviousGeometryPreset == null) {
-            return true;
-        }
-        GeometryMetadata geometry = preset.getGeometry();
-        if (geometry.equals(mPreviousGeometryPreset.getGeometry())) {
-            return false;
-        }
-        return true;
-    }
-
-    private synchronized boolean needsFiltersRepaint() {
-        ImagePreset preset = MasterImage.getImage().getPreset();
-        if (preset == null || mPreviousFiltersPreset == null) {
-            return true;
-        }
-        if (preset.equals(mPreviousFiltersPreset)) {
-            return false;
-        }
-        return true;
-    }
-
     public void setPreviewScaleFactor(float previewScaleFactor) {
         mPreviewScaleFactor = previewScaleFactor;
     }
diff --git a/src/com/android/gallery3d/filtershow/cache/RenderingRequest.java b/src/com/android/gallery3d/filtershow/cache/RenderingRequest.java
new file mode 100644
index 000000000..c995a9ff3
--- /dev/null
+++ b/src/com/android/gallery3d/filtershow/cache/RenderingRequest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.gallery3d.filtershow.cache;
+
+import android.graphics.Bitmap;
+import com.android.gallery3d.app.Log;
+import com.android.gallery3d.filtershow.presets.ImagePreset;
+
+public class RenderingRequest {
+    private static final String LOGTAG = "RenderingRequest";
+    private boolean mIsDirect = false;
+    private Bitmap mBitmap = null;
+    private ImagePreset mImagePreset = null;
+    private RenderingRequestCaller mCaller = null;
+    private int mType = FULL_RENDERING;
+    public static int FULL_RENDERING = 0;
+    public static int FILTERS_RENDERING = 1;
+    public static int GEOMETRY_RENDERING = 2;
+    private static final Bitmap.Config mConfig = Bitmap.Config.ARGB_8888;
+
+    public static void post(Bitmap source, ImagePreset preset, int type,
+                            RenderingRequestCaller caller) {
+        if (source == null || preset == null || caller == null) {
+            Log.v(LOGTAG, "something null: source: " + source + " or preset: " + preset + " or caller: " + caller);
+            return;
+        }
+        RenderingRequest request = new RenderingRequest();
+        Bitmap bitmap = null;
+        if (type == FULL_RENDERING || type == GEOMETRY_RENDERING) {
+            bitmap = preset.applyGeometry(source);
+        } else {
+            bitmap = Bitmap.createBitmap(source.getWidth(), source.getHeight(), mConfig);
+        }
+        request.setBitmap(bitmap);
+        request.setImagePreset(new ImagePreset(preset));
+        request.setType(type);
+        request.setCaller(caller);
+        request.post();
+    }
+
+    public void post() {
+        FilteringPipeline.getPipeline().postRenderingRequest(this);
+    }
+
+    public void markAvailable() {
+        if (mBitmap == null || mImagePreset == null
+                || mCaller == null) {
+            return;
+        }
+        mCaller.available(this);
+    }
+
+    public boolean isDirect() {
+        return mIsDirect;
+    }
+
+    public void setDirect(boolean isDirect) {
+        mIsDirect = isDirect;
+    }
+
+    public Bitmap getBitmap() {
+        return mBitmap;
+    }
+
+    public void setBitmap(Bitmap bitmap) {
+        mBitmap = bitmap;
+    }
+
+    public ImagePreset getImagePreset() {
+        return mImagePreset;
+    }
+
+    public void setImagePreset(ImagePreset imagePreset) {
+        mImagePreset = imagePreset;
+    }
+
+    public int getType() {
+        return mType;
+    }
+
+    public void setType(int type) {
+        mType = type;
+    }
+
+    public void setCaller(RenderingRequestCaller caller) {
+        mCaller = caller;
+    }
+}
diff --git a/src/com/android/gallery3d/filtershow/cache/RenderingRequestCaller.java b/src/com/android/gallery3d/filtershow/cache/RenderingRequestCaller.java
new file mode 100644
index 000000000..240eb8f44
--- /dev/null
+++ b/src/com/android/gallery3d/filtershow/cache/RenderingRequestCaller.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.gallery3d.filtershow.cache;
+
+public interface RenderingRequestCaller {
+    public void available(RenderingRequest request);
+}
diff --git a/src/com/android/gallery3d/filtershow/filters/ImageFilterRS.java b/src/com/android/gallery3d/filtershow/filters/ImageFilterRS.java
index ca32fee46..368e29a78 100644
--- a/src/com/android/gallery3d/filtershow/filters/ImageFilterRS.java
+++ b/src/com/android/gallery3d/filtershow/filters/ImageFilterRS.java
@@ -45,7 +45,8 @@ public class ImageFilterRS extends ImageFilter {
                 mOutPixelsAllocation.destroy();
             }
             Bitmap bitmapBuffer = bitmap.copy(mBitmapConfig, true);
-            mOutPixelsAllocation = Allocation.createFromBitmap(mRS, bitmapBuffer);
+            mOutPixelsAllocation = Allocation.createFromBitmap(mRS, bitmapBuffer,
+                    Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
             mInPixelsAllocation = Allocation.createTyped(mRS,
                     mOutPixelsAllocation.getType());
             sOldBitmap = bitmap;
diff --git a/src/com/android/gallery3d/filtershow/imageshow/ImageGeometry.java b/src/com/android/gallery3d/filtershow/imageshow/ImageGeometry.java
index 3d73ef686..3578b1d5c 100644
--- a/src/com/android/gallery3d/filtershow/imageshow/ImageGeometry.java
+++ b/src/com/android/gallery3d/filtershow/imageshow/ImageGeometry.java
@@ -29,6 +29,7 @@ import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.view.View;
 
+import com.android.gallery3d.app.Log;
 import com.android.gallery3d.filtershow.imageshow.GeometryMetadata.FLIP;
 import com.android.gallery3d.filtershow.presets.ImagePreset;
 
@@ -241,6 +242,7 @@ public abstract class ImageGeometry extends ImageShow {
         super.onVisibilityChanged(changedView, visibility);
         if (visibility == View.VISIBLE) {
             mVisibilityGained = true;
+            MasterImage.getImage().invalidateFiltersOnly();
             syncLocalToMasterGeometry();
             updateScale();
             gainedVisibility();
diff --git a/src/com/android/gallery3d/filtershow/imageshow/MasterImage.java b/src/com/android/gallery3d/filtershow/imageshow/MasterImage.java
index 5ce03a63a..cd7763e8b 100644
--- a/src/com/android/gallery3d/filtershow/imageshow/MasterImage.java
+++ b/src/com/android/gallery3d/filtershow/imageshow/MasterImage.java
@@ -23,16 +23,14 @@ import com.android.gallery3d.app.Log;
 import com.android.gallery3d.filtershow.FilterShowActivity;
 import com.android.gallery3d.filtershow.HistoryAdapter;
 import com.android.gallery3d.filtershow.ImageStateAdapter;
-import com.android.gallery3d.filtershow.cache.TripleBufferBitmap;
-import com.android.gallery3d.filtershow.cache.FilteringPipeline;
-import com.android.gallery3d.filtershow.cache.ImageLoader;
+import com.android.gallery3d.filtershow.cache.*;
 import com.android.gallery3d.filtershow.filters.FilterRepresentation;
 import com.android.gallery3d.filtershow.filters.ImageFilter;
 import com.android.gallery3d.filtershow.presets.ImagePreset;
 
 import java.util.Vector;
 
-public class MasterImage {
+public class MasterImage implements RenderingRequestCaller {
 
     private static final String LOGTAG = "MasterImage";
 
@@ -44,8 +42,9 @@ public class MasterImage {
     private ImagePreset mFiltersOnlyPreset = null;
 
     private TripleBufferBitmap mFilteredPreview = new TripleBufferBitmap();
-    private TripleBufferBitmap mGeometryOnlyPreview = new TripleBufferBitmap();
-    private TripleBufferBitmap mFiltersOnlyPreview = new TripleBufferBitmap();
+
+    private Bitmap mGeometryOnlyBitmap = null;
+    private Bitmap mFiltersOnlyBitmap = null;
 
     private ImageLoader mLoader = null;
     private HistoryAdapter mHistory = null;
@@ -154,24 +153,16 @@ public class MasterImage {
         return mFilteredPreview;
     }
 
-    public TripleBufferBitmap getGeometryOnlyBuffer() {
-        return mGeometryOnlyPreview;
-    }
-
-    public TripleBufferBitmap getFiltersOnlyBuffer() {
-        return mFiltersOnlyPreview;
-    }
-
     public Bitmap getFilteredImage() {
         return mFilteredPreview.getConsumer();
     }
 
     public Bitmap getFiltersOnlyImage() {
-        return mFiltersOnlyPreview.getConsumer();
+        return mFiltersOnlyBitmap;
     }
 
     public Bitmap getGeometryOnlyImage() {
-        return mGeometryOnlyPreview.getConsumer();
+        return mGeometryOnlyBitmap;
     }
 
     public void notifyObservers() {
@@ -187,7 +178,8 @@ public class MasterImage {
             if (mGeometryOnlyPreset == null
                     || !newPreset.same(mGeometryOnlyPreset)) {
                 mGeometryOnlyPreset = newPreset;
-                mGeometryOnlyPreview.invalidate();
+                RenderingRequest.post(mLoader.getOriginalBitmapLarge(),
+                        mGeometryOnlyPreset, RenderingRequest.GEOMETRY_RENDERING, this);
             }
         }
         if (force || mFiltersOnlyPreset == null) {
@@ -196,9 +188,11 @@ public class MasterImage {
             if (mFiltersOnlyPreset == null
                     || !newPreset.same(mFiltersOnlyPreset)) {
                 mFiltersOnlyPreset = newPreset;
-                mFilteredPreview.invalidate();
+                RenderingRequest.post(mLoader.getOriginalBitmapLarge(),
+                        mFiltersOnlyPreset, RenderingRequest.FILTERS_RENDERING, this);
             }
         }
+        invalidatePreview();
         mActivity.enableSave(hasModifications());
     }
 
@@ -210,8 +204,26 @@ public class MasterImage {
         mCurrentFilterRepresentation = currentFilterRepresentation;
     }
 
+    public void invalidateFiltersOnly() {
+        mFiltersOnlyPreset = null;
+        updatePresets(false);
+    }
+
     public void invalidatePreview() {
         mFilteredPreview.invalidate();
         FilteringPipeline.getPipeline().updatePreviewBuffer();
     }
+
+    @Override
+    public void available(RenderingRequest request) {
+        if (request.getBitmap() == null) {
+            return;
+        }
+        if (request.getType() == RenderingRequest.GEOMETRY_RENDERING) {
+            mGeometryOnlyBitmap = request.getBitmap();
+        }
+        if (request.getType() == RenderingRequest.FILTERS_RENDERING) {
+            mFiltersOnlyBitmap = request.getBitmap();
+        }
+    }
 }