Home | History | Annotate | Download | only in renderscript 
      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 
    383