frameworks/base/graphics/java/android/renderscript/Allocation.java

   1 /*
   2  * Copyright (C) 2008 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 android.renderscript;
  18
  19 import java.io.IOException;
  20 import java.io.InputStream;
  21
  22 import android.content.res.Resources;
  23 import android.content.res.AssetManager;
  24 import android.graphics.Bitmap;
  25 import android.graphics.BitmapFactory;
  26 import android.util.Log;
  27 import android.util.TypedValue;
  28
  29 /**
  30  * @hide
  31  *
  32  **/
  33 public class Allocation extends BaseObj {
  34     Type mType;
  35     Bitmap mBitmap;
  36
  37     Allocation(int id, RenderScript rs, Type t) {
  38         super(rs);
  39         mID = id;
  40         mType = t;
  41     }
  42
  43     public Type getType() {
  44         return mType;
  45     }
  46
  47     public void uploadToTexture(int baseMipLevel) {
  48         mRS.validate();
  49         mRS.nAllocationUploadToTexture(mID, false, baseMipLevel);
  50     }
  51
  52     public void uploadToTexture(boolean genMips, int baseMipLevel) {
  53         mRS.validate();
  54         mRS.nAllocationUploadToTexture(mID, genMips, baseMipLevel);
  55     }
  56
  57     public void uploadToBufferObject() {
  58         mRS.validate();
  59         mRS.nAllocationUploadToBufferObject(mID);
  60     }
  61
  62     public void data(int[] d) {
  63         mRS.validate();
  64         subData1D(0, mType.getElementCount(), d);
  65     }
  66     public void data(short[] d) {
  67         mRS.validate();
  68         subData1D(0, mType.getElementCount(), d);
  69     }
  70     public void data(byte[] d) {
  71         mRS.validate();
  72         subData1D(0, mType.getElementCount(), d);
  73     }
  74     public void data(float[] d) {
  75         mRS.validate();
  76         subData1D(0, mType.getElementCount(), d);
  77     }
  78
  79     private void data1DChecks(int off, int count, int len, int dataSize) {
  80         mRS.validate();
  81         if((off < 0) || (count < 1) || ((off + count) > mType.getElementCount())) {
  82             throw new IllegalArgumentException("Offset or Count out of bounds.");
  83         }
  84         if((len) < dataSize) {
  85             throw new IllegalArgumentException("Array too small for allocation type.");
  86         }
  87     }
  88
  89     public void subData1D(int off, int count, int[] d) {
  90         int dataSize = mType.mElement.getSizeBytes() * count;
  91         data1DChecks(off, count, d.length * 4, dataSize);
  92         mRS.nAllocationSubData1D(mID, off, count, d, dataSize);
  93     }
  94     public void subData1D(int off, int count, short[] d) {
  95         int dataSize = mType.mElement.getSizeBytes() * count;
  96         data1DChecks(off, count, d.length * 2, dataSize);
  97         mRS.nAllocationSubData1D(mID, off, count, d, dataSize);
  98     }
  99     public void subData1D(int off, int count, byte[] d) {
 100         int dataSize = mType.mElement.getSizeBytes() * count;
 101         data1DChecks(off, count, d.length, dataSize);
 102         mRS.nAllocationSubData1D(mID, off, count, d, dataSize);
 103     }
 104     public void subData1D(int off, int count, float[] d) {
 105         int dataSize = mType.mElement.getSizeBytes() * count;
 106         data1DChecks(off, count, d.length * 4, dataSize);
 107         mRS.nAllocationSubData1D(mID, off, count, d, dataSize);
 108     }
 109
 110
 111
 112     public void subData2D(int xoff, int yoff, int w, int h, int[] d) {
 113         mRS.validate();
 114         mRS.nAllocationSubData2D(mID, xoff, yoff, w, h, d, d.length * 4);
 115     }
 116
 117     public void subData2D(int xoff, int yoff, int w, int h, float[] d) {
 118         mRS.validate();
 119         mRS.nAllocationSubData2D(mID, xoff, yoff, w, h, d, d.length * 4);
 120     }
 121
 122     public void readData(int[] d) {
 123         mRS.validate();
 124         mRS.nAllocationRead(mID, d);
 125     }
 126
 127     public void readData(float[] d) {
 128         mRS.validate();
 129         mRS.nAllocationRead(mID, d);
 130     }
 131
 132     public void data(Object o) {
 133         mRS.validate();
 134         mRS.nAllocationSubDataFromObject(mID, mType, 0, o);
 135     }
 136
 137     public void read(Object o) {
 138         mRS.validate();
 139         mRS.nAllocationSubReadFromObject(mID, mType, 0, o);
 140     }
 141
 142     public void subData(int offset, Object o) {
 143         mRS.validate();
 144         mRS.nAllocationSubDataFromObject(mID, mType, offset, o);
 145     }
 146
 147     public class Adapter1D extends BaseObj {
 148         Adapter1D(int id, RenderScript rs) {
 149             super(rs);
 150             mID = id;
 151         }
 152
 153         public void setConstraint(Dimension dim, int value) {
 154             mRS.validate();
 155             mRS.nAdapter1DSetConstraint(mID, dim.mID, value);
 156         }
 157
 158         public void data(int[] d) {
 159             mRS.validate();
 160             mRS.nAdapter1DData(mID, d);
 161         }
 162
 163         public void data(float[] d) {
 164             mRS.validate();
 165             mRS.nAdapter1DData(mID, d);
 166         }
 167
 168         public void subData(int off, int count, int[] d) {
 169             mRS.validate();
 170             mRS.nAdapter1DSubData(mID, off, count, d);
 171         }
 172
 173         public void subData(int off, int count, float[] d) {
 174             mRS.validate();
 175             mRS.nAdapter1DSubData(mID, off, count, d);
 176         }
 177     }
 178
 179     public Adapter1D createAdapter1D() {
 180         mRS.validate();
 181         int id = mRS.nAdapter1DCreate();
 182         if(id == 0) {
 183             throw new IllegalStateException("allocation failed.");
 184         }
 185         mRS.nAdapter1DBindAllocation(id, mID);
 186         return new Adapter1D(id, mRS);
 187     }
 188
 189
 190     public class Adapter2D extends BaseObj {
 191         Adapter2D(int id, RenderScript rs) {
 192             super(rs);
 193             mID = id;
 194         }
 195
 196         public void setConstraint(Dimension dim, int value) {
 197             mRS.validate();
 198             mRS.nAdapter2DSetConstraint(mID, dim.mID, value);
 199         }
 200
 201         public void data(int[] d) {
 202             mRS.validate();
 203             mRS.nAdapter2DData(mID, d);
 204         }
 205
 206         public void data(float[] d) {
 207             mRS.validate();
 208             mRS.nAdapter2DData(mID, d);
 209         }
 210
 211         public void subData(int xoff, int yoff, int w, int h, int[] d) {
 212             mRS.validate();
 213             mRS.nAdapter2DSubData(mID, xoff, yoff, w, h, d);
 214         }
 215
 216         public void subData(int xoff, int yoff, int w, int h, float[] d) {
 217             mRS.validate();
 218             mRS.nAdapter2DSubData(mID, xoff, yoff, w, h, d);
 219         }
 220     }
 221
 222     public Adapter2D createAdapter2D() {
 223         mRS.validate();
 224         int id = mRS.nAdapter2DCreate();
 225         if(id == 0) {
 226             throw new IllegalStateException("allocation failed.");
 227         }
 228         mRS.nAdapter2DBindAllocation(id, mID);
 229         return new Adapter2D(id, mRS);
 230     }
 231
 232
 233     // creation
 234
 235     private static BitmapFactory.Options mBitmapOptions = new BitmapFactory.Options();
 236     static {
 237         mBitmapOptions.inScaled = false;
 238     }
 239
 240     static public Allocation createTyped(RenderScript rs, Type type)
 241         throws IllegalArgumentException {
 242
 243         rs.validate();
 244         if(type.mID == 0) {
 245             throw new IllegalStateException("Bad Type");
 246         }
 247         int id = rs.nAllocationCreateTyped(type.mID);
 248         return new Allocation(id, rs, type);
 249     }
 250
 251     static public Allocation createSized(RenderScript rs, Element e, int count)
 252         throws IllegalArgumentException {
 253
 254         rs.validate();
 255         Type.Builder b = new Type.Builder(rs, e);
 256         b.add(Dimension.X, count);
 257         Type t = b.create();
 258
 259         int id = rs.nAllocationCreateTyped(t.mID);
 260         if(id == 0) {
 261             throw new IllegalStateException("Bad element.");
 262         }
 263         return new Allocation(id, rs, t);
 264     }
 265
 266     static private Element elementFromBitmap(RenderScript rs, Bitmap b) {
 267         final Bitmap.Config bc = b.getConfig();
 268         if (bc == Bitmap.Config.ALPHA_8) {
 269             return Element.A_8(rs);
 270         }
 271         if (bc == Bitmap.Config.ARGB_4444) {
 272             return Element.RGBA_4444(rs);
 273         }
 274         if (bc == Bitmap.Config.ARGB_8888) {
 275             return Element.RGBA_8888(rs);
 276         }
 277         if (bc == Bitmap.Config.RGB_565) {
 278             return Element.RGB_565(rs);
 279         }
 280         throw new IllegalStateException("Bad bitmap type.");
 281     }
 282
 283     static private Type typeFromBitmap(RenderScript rs, Bitmap b) {
 284         Element e = elementFromBitmap(rs, b);
 285         Type.Builder tb = new Type.Builder(rs, e);
 286         tb.add(Dimension.X, b.getWidth());
 287         tb.add(Dimension.Y, b.getHeight());
 288         return tb.create();
 289     }
 290
 291     static public Allocation createFromBitmap(RenderScript rs, Bitmap b, Element dstFmt, boolean genMips)
 292         throws IllegalArgumentException {
 293
 294         rs.validate();
 295         Type t = typeFromBitmap(rs, b);
 296
 297         int id = rs.nAllocationCreateFromBitmap(dstFmt.mID, genMips, b);
 298         if(id == 0) {
 299             throw new IllegalStateException("Load failed.");
 300         }
 301         return new Allocation(id, rs, t);
 302     }
 303
 304     static public Allocation createBitmapRef(RenderScript rs, Bitmap b)
 305         throws IllegalArgumentException {
 306
 307         rs.validate();
 308         Type t = typeFromBitmap(rs, b);
 309
 310         int id = rs.nAllocationCreateBitmapRef(t.getID(), b);
 311         if(id == 0) {
 312             throw new IllegalStateException("Load failed.");
 313         }
 314
 315         Allocation a = new Allocation(id, rs, t);
 316         a.mBitmap = b;
 317         return a;
 318     }
 319
 320     static Allocation createFromBitmapBoxed(RenderScript rs, Bitmap b, Element dstFmt, boolean genMips)
 321         throws IllegalArgumentException {
 322
 323         rs.validate();
 324         int id = rs.nAllocationCreateFromBitmapBoxed(dstFmt.mID, genMips, b);
 325         if(id == 0) {
 326             throw new IllegalStateException("Load failed.");
 327         }
 328         return new Allocation(id, rs, null);
 329     }
 330
 331     static public Allocation createFromBitmapResource(RenderScript rs, Resources res, int id, Element dstFmt, boolean genMips)
 332         throws IllegalArgumentException {
 333
 334         rs.validate();
 335         InputStream is = null;
 336         try {
 337             final TypedValue value = new TypedValue();
 338             is = res.openRawResource(id, value);
 339
 340             int asset = ((AssetManager.AssetInputStream) is).getAssetInt();
 341             int allocationId = rs.nAllocationCreateFromAssetStream(dstFmt.mID, genMips,
 342                     asset);
 343
 344             if(allocationId == 0) {
 345                 throw new IllegalStateException("Load failed.");
 346             }
 347             return new Allocation(allocationId, rs, null);
 348         } catch (Exception e) {
 349             // Ignore
 350         } finally {
 351             if (is != null) {
 352                 try {
 353                     is.close();
 354                 } catch (IOException e) {
 355                     // Ignore
 356                 }
 357             }
 358         }
 359
 360         return null;
 361     }
 362
 363     static public Allocation createFromBitmapResourceBoxed(RenderScript rs, Resources res, int id, Element dstFmt, boolean genMips)
 364         throws IllegalArgumentException {
 365
 366         mBitmapOptions.inPreferredConfig = null;
 367         if (dstFmt == rs.mElement_RGBA_8888) {
 368             mBitmapOptions.inPreferredConfig = Bitmap.Config.ARGB_8888;
 369         } else if (dstFmt == rs.mElement_RGB_888) {
 370             mBitmapOptions.inPreferredConfig = Bitmap.Config.ARGB_8888;
 371         } else if (dstFmt == rs.mElement_RGBA_4444) {
 372             mBitmapOptions.inPreferredConfig = Bitmap.Config.ARGB_4444;
 373         } else if (dstFmt == rs.mElement_RGB_565) {
 374             mBitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;
 375         }
 376
 377         Bitmap b = BitmapFactory.decodeResource(res, id, mBitmapOptions);
 378         return createFromBitmapBoxed(rs, b, dstFmt, genMips);
 379     }
 380 }
 381
 382