Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit db5d060e authored by nicolasroard's avatar nicolasroard
Browse files

Remove FilteringPipeline 

Reorganize things around the filtering service.
- add HighresRenderingTask
- add RenderingRequestTask
- add UpdatePreviewTask

Change-Id: I3da34fee8c624fb55311c3e1639857fc1bcdadad
parent 24d6ec7b

src/com/android/gallery3d/filtershow/FilterShowActivity.java

+5 −7
Original line number Diff line number Diff line
@@ -59,7 +59,6 @@ import com.android.gallery3d.R; 
import com.android.gallery3d.app.PhotoPage;

import com.android.gallery3d.data.LocalAlbum;

import com.android.gallery3d.filtershow.pipeline.CachingPipeline;

import com.android.gallery3d.filtershow.pipeline.FilteringPipeline;

import com.android.gallery3d.filtershow.cache.ImageLoader;

import com.android.gallery3d.filtershow.category.Action;

import com.android.gallery3d.filtershow.category.CategoryAdapter;
@@ -546,6 +545,7 @@ public class FilterShowActivity extends FragmentActivity implements OnItemClickL 
                        master.getOrientation(), bounds);

                master.setOriginalBounds(bounds);

                master.setOriginalBitmapHighres(originalHires);

                mBoundService.setOriginalBitmapHighres(originalHires);

                master.warnListeners();

            }

            return true;
@@ -555,10 +555,9 @@ public class FilterShowActivity extends FragmentActivity implements OnItemClickL 
        protected void onPostExecute(Boolean result) {

            Bitmap highresBitmap = MasterImage.getImage().getOriginalBitmapHighres();

            if (highresBitmap != null) {

                FilteringPipeline pipeline = FilteringPipeline.getPipeline();

                float highResPreviewScale = (float) highresBitmap.getWidth()

                        / (float) MasterImage.getImage().getOriginalBounds().width();

                pipeline.setHighResPreviewScaleFactor(highResPreviewScale);

                mBoundService.setHighresPreviewScaleFactor(highResPreviewScale);

            }

        }

    }
@@ -611,15 +610,14 @@ public class FilterShowActivity extends FragmentActivity implements OnItemClickL 
            imageShow.setVisibility(View.VISIBLE);



            Bitmap largeBitmap = MasterImage.getImage().getOriginalBitmapLarge();

            FilteringPipeline pipeline = FilteringPipeline.getPipeline();

            pipeline.setOriginal(largeBitmap);

            mBoundService.setOriginalBitmap(largeBitmap);



            float previewScale = (float) largeBitmap.getWidth()

                    / (float) MasterImage.getImage().getOriginalBounds().width();

            pipeline.setPreviewScaleFactor(previewScale);

            mBoundService.setPreviewScaleFactor(previewScale);

            if (!mShowingTinyPlanet) {

                mCategoryFiltersAdapter.removeTinyPlanet();

            }

            pipeline.turnOnPipeline(true);

            MasterImage.getImage().setOriginalGeometry(largeBitmap);

            mCategoryLooksAdapter.imageLoaded();

            mCategoryBordersAdapter.imageLoaded();

src/com/android/gallery3d/filtershow/category/Action.java

+1 −1
Original line number Diff line number Diff line
@@ -112,7 +112,7 @@ public class Action implements RenderingRequestCaller { 
        if (bitmap != null && mRepresentation != null) {

            ImagePreset preset = new ImagePreset();

            preset.addFilter(mRepresentation);

            RenderingRequest.post(bitmap,

            RenderingRequest.post(mContext, bitmap,

                    preset, RenderingRequest.ICON_RENDERING, this);

        }

    }

src/com/android/gallery3d/filtershow/imageshow/MasterImage.java

+9 −6
Original line number Diff line number Diff line
@@ -32,7 +32,6 @@ import com.android.gallery3d.filtershow.filters.ImageFilter; 
import com.android.gallery3d.filtershow.history.HistoryItem;

import com.android.gallery3d.filtershow.history.HistoryManager;

import com.android.gallery3d.filtershow.pipeline.Buffer;

import com.android.gallery3d.filtershow.pipeline.FilteringPipeline;

import com.android.gallery3d.filtershow.pipeline.ImagePreset;

import com.android.gallery3d.filtershow.pipeline.RenderingRequest;

import com.android.gallery3d.filtershow.pipeline.RenderingRequestCaller;
@@ -387,7 +386,7 @@ public class MasterImage implements RenderingRequestCaller { 
            if (force || mGeometryOnlyPreset == null

                    || !newPreset.same(mGeometryOnlyPreset)) {

                mGeometryOnlyPreset = newPreset;

                RenderingRequest.post(getOriginalBitmapLarge(),

                RenderingRequest.post(mActivity, getOriginalBitmapLarge(),

                        mGeometryOnlyPreset, RenderingRequest.GEOMETRY_RENDERING, this);

            }

        }
@@ -398,7 +397,7 @@ public class MasterImage implements RenderingRequestCaller { 
            if (force || mFiltersOnlyPreset == null

                    || !newPreset.same(mFiltersOnlyPreset)) {

                mFiltersOnlyPreset = newPreset;

                RenderingRequest.post(MasterImage.getImage().getOriginalBitmapLarge(),

                RenderingRequest.post(mActivity, MasterImage.getImage().getOriginalBitmapLarge(),

                        mFiltersOnlyPreset, RenderingRequest.FILTERS_RENDERING, this);

            }

        }
@@ -439,7 +438,7 @@ public class MasterImage implements RenderingRequestCaller { 
        invalidateHighresPreview();

        needsUpdatePartialPreview();

        needsUpdateHighResPreview();

        FilteringPipeline.getPipeline().updatePreviewBuffer();

        mActivity.getProcessingService().updatePreviewBuffer();

    }



    public void setImageShowSize(int w, int h) {
@@ -477,7 +476,11 @@ public class MasterImage implements RenderingRequestCaller { 
        if (!mSupportsHighRes) {

            return;

        }

        RenderingRequest.post(null, mPreset, RenderingRequest.HIGHRES_RENDERING, this);

        if (mActivity.getProcessingService() == null) {

            return;

        }

        mActivity.getProcessingService().postHighresRenderingRequest(mPreset,

                getScaleFactor(), this);

        invalidateHighresPreview();

    }
@@ -495,7 +498,7 @@ public class MasterImage implements RenderingRequestCaller { 
        m.mapRect(dest, r);

        Rect bounds = new Rect();

        dest.roundOut(bounds);

        RenderingRequest.post(null, mPreset, RenderingRequest.PARTIAL_RENDERING,

        RenderingRequest.post(mActivity, null, mPreset, RenderingRequest.PARTIAL_RENDERING,

                this, bounds, new Rect(0, 0, mImageShowSize.x, mImageShowSize.y));

        invalidatePartialPreview();

    }

src/com/android/gallery3d/filtershow/pipeline/FilteringPipeline.java

deleted100644 → 0
+0 −238
Original line number Diff line number Diff line 
/*

 * 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.pipeline;



import android.graphics.Bitmap;

import android.os.*;

import android.os.Process;

import android.util.Log;



import com.android.gallery3d.filtershow.filters.FiltersManager;

import com.android.gallery3d.filtershow.imageshow.MasterImage;



public class FilteringPipeline implements Handler.Callback {



    private static volatile FilteringPipeline sPipeline = null;

    private static final String LOGTAG = "FilteringPipeline";

    private boolean DEBUG = false;



    private static long HIRES_DELAY = 300; // in ms



    private volatile boolean mPipelineIsOn = false;



    private CachingPipeline mAccessoryPipeline = null;

    private CachingPipeline mPreviewPipeline = null;

    private CachingPipeline mHighresPreviewPipeline = null;



    private HandlerThread mHandlerThread = null;

    private final static int NEW_PRESET = 0;

    private final static int NEW_RENDERING_REQUEST = 1;

    private final static int COMPUTE_PRESET = 2;

    private final static int COMPUTE_RENDERING_REQUEST = 3;

    private final static int COMPUTE_PARTIAL_RENDERING_REQUEST = 4;

    private final static int COMPUTE_HIGHRES_RENDERING_REQUEST = 5;



    private volatile boolean mHasUnhandledPreviewRequest = false;



    private String getType(int value) {

        if (value == COMPUTE_RENDERING_REQUEST) {

            return "COMPUTE_RENDERING_REQUEST";

        }

        if (value == COMPUTE_PARTIAL_RENDERING_REQUEST) {

            return "COMPUTE_PARTIAL_RENDERING_REQUEST";

        }

        if (value == COMPUTE_HIGHRES_RENDERING_REQUEST) {

            return "COMPUTE_HIGHRES_RENDERING_REQUEST";

        }

        return "UNKNOWN TYPE";

    }



    private Handler mProcessingHandler = null;

    private final Handler mUIHandler = new Handler() {

        @Override

        public void handleMessage(Message msg) {

            switch (msg.what) {

                case NEW_PRESET: {

                    MasterImage.getImage().notifyObservers();

                    if (mHasUnhandledPreviewRequest) {

                        updatePreviewBuffer();

                    }

                    break;

                }

                case NEW_RENDERING_REQUEST: {

                    RenderingRequest request = (RenderingRequest) msg.obj;

                    request.markAvailable();

                    break;

                }

            }

        }

    };



    @Override

    public boolean handleMessage(Message msg) {

        if (!mPipelineIsOn) {

            return false;

        }

        switch (msg.what) {

            case COMPUTE_PRESET: {

                SharedBuffer buffer = MasterImage.getImage().getPreviewBuffer();

                SharedPreset preset = MasterImage.getImage().getPreviewPreset();

                ImagePreset renderingPreset = preset.dequeuePreset();

                if (renderingPreset != null) {

                    mPreviewPipeline.compute(buffer, renderingPreset, COMPUTE_PRESET);

                    // set the preset we used in the buffer for later inspection UI-side

                    buffer.getProducer().setPreset(renderingPreset);

                    buffer.getProducer().sync();

                    buffer.swapProducer(); // push back the result

                    Message uimsg = mUIHandler.obtainMessage(NEW_PRESET);

                    mUIHandler.sendMessage(uimsg);

                }

                break;

            }

            case COMPUTE_RENDERING_REQUEST:

            case COMPUTE_PARTIAL_RENDERING_REQUEST:

            case COMPUTE_HIGHRES_RENDERING_REQUEST: {



                if (DEBUG) {

                    Log.v(LOGTAG, "Compute Request: " + getType(msg.what));

                }



                RenderingRequest request = (RenderingRequest) msg.obj;

                if (msg.what == COMPUTE_HIGHRES_RENDERING_REQUEST) {

                    mHighresPreviewPipeline.render(request);

                } else {

                    mAccessoryPipeline.render(request);

                }

                if (request.getBitmap() != null) {

                    Message uimsg = mUIHandler.obtainMessage(NEW_RENDERING_REQUEST);

                    uimsg.obj = request;

                    mUIHandler.sendMessage(uimsg);

                }

                break;

            }

        }

        return false;

    }



    private FilteringPipeline() {

        mHandlerThread = new HandlerThread("FilteringPipeline",

                Process.THREAD_PRIORITY_FOREGROUND);

        mHandlerThread.start();

        mProcessingHandler = new Handler(mHandlerThread.getLooper(), this);

        mAccessoryPipeline = new CachingPipeline(

                FiltersManager.getManager(), "Accessory");

        mPreviewPipeline = new CachingPipeline(

                FiltersManager.getPreviewManager(), "Preview");

        mHighresPreviewPipeline = new CachingPipeline(

                FiltersManager.getHighresManager(), "Highres");

    }



    public synchronized static FilteringPipeline getPipeline() {

        if (sPipeline == null) {

            sPipeline = new FilteringPipeline();

        }

        return sPipeline;

    }



    public void setOriginal(Bitmap bitmap) {

        if (mPipelineIsOn) {

            Log.e(LOGTAG, "setOriginal called after pipeline initialization!");

            return;

        }

        mAccessoryPipeline.setOriginal(bitmap);

        mPreviewPipeline.setOriginal(bitmap);

        mHighresPreviewPipeline.setOriginal(bitmap);

    }



    public void postRenderingRequest(RenderingRequest request) {

        if (!mPipelineIsOn) {

            return;

        }

        int type = COMPUTE_RENDERING_REQUEST;

        if (request.getType() == RenderingRequest.PARTIAL_RENDERING) {

            type = COMPUTE_PARTIAL_RENDERING_REQUEST;

        }

        if (request.getType() == RenderingRequest.HIGHRES_RENDERING) {

            type = COMPUTE_HIGHRES_RENDERING_REQUEST;

            if (MasterImage.getImage().getOriginalBitmapHighres() == null) {

                return;

            }

        }

        Message msg = mProcessingHandler.obtainMessage(type);

        msg.obj = request;

        if (type == COMPUTE_PARTIAL_RENDERING_REQUEST

                || type == COMPUTE_HIGHRES_RENDERING_REQUEST) {

            if (mProcessingHandler.hasMessages(msg.what)) {

                mProcessingHandler.removeMessages(msg.what);

            }

            mProcessingHandler.sendMessageDelayed(msg, HIRES_DELAY);

        } else {

            mProcessingHandler.sendMessage(msg);

        }

    }



    public void updatePreviewBuffer() {

        if (!mPipelineIsOn) {

            return;

        }

        mHasUnhandledPreviewRequest = true;

        mHighresPreviewPipeline.stop();

        if (mProcessingHandler.hasMessages(COMPUTE_PRESET)) {

            return;

        }

        if (!mPreviewPipeline.needsRepaint()) {

            return;

        }

        if (MasterImage.getImage().getPreset() == null) {

            return;

        }

        Message msg = mProcessingHandler.obtainMessage(COMPUTE_PRESET);

        msg.obj = MasterImage.getImage().getPreset();

        mHasUnhandledPreviewRequest = false;

        mProcessingHandler.sendMessageAtFrontOfQueue(msg);

    }



    public void setPreviewScaleFactor(float previewScaleFactor) {

        mAccessoryPipeline.setPreviewScaleFactor(previewScaleFactor);

        mPreviewPipeline.setPreviewScaleFactor(previewScaleFactor);

        mHighresPreviewPipeline.setPreviewScaleFactor(previewScaleFactor);

    }



    public void setHighResPreviewScaleFactor(float highResPreviewScaleFactor) {

        mAccessoryPipeline.setHighResPreviewScaleFactor(highResPreviewScaleFactor);

        mPreviewPipeline.setHighResPreviewScaleFactor(highResPreviewScaleFactor);

        mHighresPreviewPipeline.setHighResPreviewScaleFactor(highResPreviewScaleFactor);

    }



    public static synchronized void reset() {

        sPipeline.mAccessoryPipeline.reset();

        sPipeline.mPreviewPipeline.reset();

        sPipeline.mHighresPreviewPipeline.reset();

        sPipeline.mHandlerThread.quit();

        sPipeline = null;

    }



    public void turnOnPipeline(boolean t) {

        mPipelineIsOn = t;

        if (mPipelineIsOn) {

            assert(mPreviewPipeline.isInitialized());

            assert(mAccessoryPipeline.isInitialized());

            assert(mHighresPreviewPipeline.isInitialized());

            updatePreviewBuffer();

        }

    }

}

src/com/android/gallery3d/filtershow/pipeline/HighresRenderingRequestTask.java

0 → 100644
+90 −0
Original line number Diff line number Diff line 
/*

 * 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.pipeline;



import android.graphics.Bitmap;

import com.android.gallery3d.filtershow.filters.FiltersManager;



public class HighresRenderingRequestTask extends ProcessingTask {



    private CachingPipeline mHighresPreviewPipeline = null;

    private boolean mPipelineIsOn = false;



    public void setHighresPreviewScaleFactor(float highResPreviewScale) {

        mHighresPreviewPipeline.setHighResPreviewScaleFactor(highResPreviewScale);

    }



    public void setPreviewScaleFactor(float previewScale) {

        mHighresPreviewPipeline.setPreviewScaleFactor(previewScale);

    }



    static class Render implements Request {

        RenderingRequest request;

    }



    static class RenderResult implements Result {

        RenderingRequest request;

    }



    public HighresRenderingRequestTask() {

        mHighresPreviewPipeline = new CachingPipeline(

                FiltersManager.getHighresManager(), "Highres");

    }



    public void setOriginal(Bitmap bitmap) {

        mHighresPreviewPipeline.setOriginal(bitmap);

    }



    public void setOriginalBitmapHighres(Bitmap originalHires) {

        mPipelineIsOn = true;

    }



    public void stop() {

        mHighresPreviewPipeline.stop();

    }



    public void postRenderingRequest(RenderingRequest request) {

        if (!mPipelineIsOn) {

            return;

        }

        Render render = new Render();

        render.request = request;

        postRequest(render);

    }



    @Override

    public Result doInBackground(Request message) {

        RenderingRequest request = ((Render) message).request;

        RenderResult result = null;

        mHighresPreviewPipeline.render(request);

        result = new RenderResult();

        result.request = request;

        return result;

    }



    @Override

    public void onResult(Result message) {

        if (message == null) {

            return;

        }

        RenderingRequest request = ((RenderResult) message).request;

        request.markAvailable();

    }



    @Override

    public boolean isDelayedTask() { return true; }

}