src/com/android/gallery3d/filtershow/filters/ImageFilterRS.java

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.gallery3d.filtershow.filters;
  18
  19 import android.graphics.Bitmap;
  20 import android.graphics.BitmapFactory;
  21 import android.support.v8.renderscript.*;
  22 import android.util.Log;
  23 import android.content.res.Resources;
  24 import com.android.gallery3d.R;
  25 import com.android.gallery3d.filtershow.cache.CachingPipeline;
  26
  27 public abstract class ImageFilterRS extends ImageFilter {
  28     private static final String LOGTAG = "ImageFilterRS";
  29     private boolean DEBUG = false;
  30     private int mLastInputWidth = 0;
  31     private int mLastInputHeight = 0;
  32
  33     public static boolean PERF_LOGGING = false;
  34
  35     private static ScriptC_grey mGreyConvert = null;
  36     private static RenderScript mRScache = null;
  37
  38     private volatile boolean mResourcesLoaded = false;
  39
  40     protected abstract void createFilter(android.content.res.Resources res,
  41             float scaleFactor, int quality);
  42
  43     protected void createFilter(android.content.res.Resources res,
  44     float scaleFactor, int quality, Allocation in) {}
  45     protected void bindScriptValues(Allocation in) {}
  46
  47     protected abstract void runFilter();
  48
  49     protected void update(Bitmap bitmap) {
  50         getOutPixelsAllocation().copyTo(bitmap);
  51     }
  52
  53     protected RenderScript getRenderScriptContext() {
  54         return CachingPipeline.getRenderScriptContext();
  55     }
  56
  57     protected Allocation getInPixelsAllocation() {
  58         CachingPipeline pipeline = getEnvironment().getCachingPipeline();
  59         return pipeline.getInPixelsAllocation();
  60     }
  61
  62     protected Allocation getOutPixelsAllocation() {
  63         CachingPipeline pipeline = getEnvironment().getCachingPipeline();
  64         return pipeline.getOutPixelsAllocation();
  65     }
  66
  67     @Override
  68     public void apply(Allocation in, Allocation out) {
  69         long startOverAll = System.nanoTime();
  70         long startFilter = 0;
  71         long endFilter = 0;
  72         if (!mResourcesLoaded) {
  73             CachingPipeline pipeline = getEnvironment().getCachingPipeline();
  74             createFilter(pipeline.getResources(), getEnvironment().getScaleFactor(),
  75                     getEnvironment().getQuality(), in);
  76             mResourcesLoaded = true;
  77         }
  78         startFilter = System.nanoTime();
  79         bindScriptValues(in);
  80         run(in, out);
  81         if (PERF_LOGGING) {
  82             getRenderScriptContext().finish();
  83             endFilter = System.nanoTime();
  84             long endOverAll = System.nanoTime();
  85             String msg = String.format("%s; image size %dx%d; ", getName(),
  86                     in.getType().getX(), in.getType().getY());
  87             long timeOverAll = (endOverAll - startOverAll) / 1000;
  88             long timeFilter = (endFilter - startFilter) / 1000;
  89             msg += String.format("over all %.2f ms (%.2f FPS); ",
  90                     timeOverAll / 1000.f, 1000000.f / timeOverAll);
  91             msg += String.format("run filter %.2f ms (%.2f FPS)",
  92                     timeFilter / 1000.f, 1000000.f / timeFilter);
  93             Log.i(LOGTAG, msg);
  94         }
  95     }
  96
  97     protected void run(Allocation in, Allocation out) {}
  98
  99     @Override
 100     public Bitmap apply(Bitmap bitmap, float scaleFactor, int quality) {
 101         if (bitmap == null || bitmap.getWidth() == 0 || bitmap.getHeight() == 0) {
 102             return bitmap;
 103         }
 104         try {
 105             CachingPipeline pipeline = getEnvironment().getCachingPipeline();
 106             if (DEBUG) {
 107                 Log.v(LOGTAG, "apply filter " + getName() + " in pipeline " + pipeline.getName());
 108             }
 109             Resources rsc = pipeline.getResources();
 110             boolean sizeChanged = false;
 111             if (getInPixelsAllocation() != null
 112                     && ((getInPixelsAllocation().getType().getX() != mLastInputWidth)
 113                     || (getInPixelsAllocation().getType().getY() != mLastInputHeight))) {
 114                 sizeChanged = true;
 115             }
 116             if (pipeline.prepareRenderscriptAllocations(bitmap)
 117                     || !isResourcesLoaded() || sizeChanged) {
 118                 freeResources();
 119                 createFilter(rsc, scaleFactor, quality);
 120                 setResourcesLoaded(true);
 121                 mLastInputWidth = getInPixelsAllocation().getType().getX();
 122                 mLastInputHeight = getInPixelsAllocation().getType().getY();
 123             }
 124             bindScriptValues();
 125             runFilter();
 126             update(bitmap);
 127             if (DEBUG) {
 128                 Log.v(LOGTAG, "DONE apply filter " + getName() + " in pipeline " + pipeline.getName());
 129             }
 130         } catch (android.renderscript.RSIllegalArgumentException e) {
 131             Log.e(LOGTAG, "Illegal argument? " + e);
 132         } catch (android.renderscript.RSRuntimeException e) {
 133             Log.e(LOGTAG, "RS runtime exception ? " + e);
 134         } catch (java.lang.OutOfMemoryError e) {
 135             // Many of the renderscript filters allocated large (>16Mb resources) in order to apply.
 136             System.gc();
 137             displayLowMemoryToast();
 138             Log.e(LOGTAG, "not enough memory for filter " + getName(), e);
 139         }
 140
 141         return bitmap;
 142     }
 143
 144     protected static Allocation convertBitmap(Bitmap bitmap) {
 145         return Allocation.createFromBitmap(CachingPipeline.getRenderScriptContext(), bitmap,
 146                 Allocation.MipmapControl.MIPMAP_NONE,
 147                 Allocation.USAGE_SCRIPT | Allocation.USAGE_GRAPHICS_TEXTURE);
 148     }
 149
 150     private static Allocation convertRGBAtoA(Bitmap bitmap) {
 151         RenderScript RS = CachingPipeline.getRenderScriptContext();
 152         if (RS != mRScache || mGreyConvert == null) {
 153             mGreyConvert = new ScriptC_grey(RS, RS.getApplicationContext().getResources(),
 154                                             R.raw.grey);
 155             mRScache = RS;
 156         }
 157
 158         Type.Builder tb_a8 = new Type.Builder(RS, Element.A_8(RS));
 159
 160         Allocation bitmapTemp = convertBitmap(bitmap);
 161         if (bitmapTemp.getType().getElement().isCompatible(Element.A_8(RS))) {
 162             return bitmapTemp;
 163         }
 164
 165         tb_a8.setX(bitmapTemp.getType().getX());
 166         tb_a8.setY(bitmapTemp.getType().getY());
 167         Allocation bitmapAlloc = Allocation.createTyped(RS, tb_a8.create(),
 168                                                         Allocation.MipmapControl.MIPMAP_NONE,
 169                                                         Allocation.USAGE_SCRIPT | Allocation.USAGE_GRAPHICS_TEXTURE);
 170         mGreyConvert.forEach_RGBAtoA(bitmapTemp, bitmapAlloc);
 171         bitmapTemp.destroy();
 172         return bitmapAlloc;
 173     }
 174
 175     public Allocation loadScaledResourceAlpha(int resource, int inSampleSize) {
 176         Resources res = CachingPipeline.getResources();
 177         final BitmapFactory.Options options = new BitmapFactory.Options();
 178         options.inPreferredConfig = Bitmap.Config.ALPHA_8;
 179         options.inSampleSize      = inSampleSize;
 180         Bitmap bitmap = BitmapFactory.decodeResource(
 181                 res,
 182                 resource, options);
 183         Allocation ret = convertRGBAtoA(bitmap);
 184         bitmap.recycle();
 185         return ret;
 186     }
 187
 188     public Allocation loadScaledResourceAlpha(int resource, int w, int h, int inSampleSize) {
 189         Resources res = CachingPipeline.getResources();
 190         final BitmapFactory.Options options = new BitmapFactory.Options();
 191         options.inPreferredConfig = Bitmap.Config.ALPHA_8;
 192         options.inSampleSize      = inSampleSize;
 193         Bitmap bitmap = BitmapFactory.decodeResource(
 194                 res,
 195                 resource, options);
 196         Bitmap resizeBitmap = Bitmap.createScaledBitmap(bitmap, w, h, true);
 197         Allocation ret = convertRGBAtoA(resizeBitmap);
 198         resizeBitmap.recycle();
 199         bitmap.recycle();
 200         return ret;
 201     }
 202
 203     public Allocation loadResourceAlpha(int resource) {
 204         return loadScaledResourceAlpha(resource, 1);
 205     }
 206
 207     public Allocation loadResource(int resource) {
 208         Resources res = CachingPipeline.getResources();
 209         final BitmapFactory.Options options = new BitmapFactory.Options();
 210         options.inPreferredConfig = Bitmap.Config.ARGB_8888;
 211         Bitmap bitmap = BitmapFactory.decodeResource(
 212                 res,
 213                 resource, options);
 214         Allocation ret = convertBitmap(bitmap);
 215         bitmap.recycle();
 216         return ret;
 217     }
 218
 219     private boolean isResourcesLoaded() {
 220         return mResourcesLoaded;
 221     }
 222
 223     private void setResourcesLoaded(boolean resourcesLoaded) {
 224         mResourcesLoaded = resourcesLoaded;
 225     }
 226
 227     /**
 228      *  Bitmaps and RS Allocations should be cleared here
 229      */
 230     abstract protected void resetAllocations();
 231
 232     /**
 233      * RS Script objects (and all other RS objects) should be cleared here
 234      */
 235     abstract protected void resetScripts();
 236
 237     /**
 238      * Scripts values should be bound here
 239      */
 240     abstract protected void bindScriptValues();
 241
 242     public void freeResources() {
 243         if (!isResourcesLoaded()) {
 244             return;
 245         }
 246         resetAllocations();
 247         setResourcesLoaded(false);
 248     }
 249 }