graphics/java/android/renderscript/RenderScript.java

   1 /*
   2  * Copyright (C) 2008-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 android.renderscript;
  18
  19 import java.io.File;
  20 import java.lang.reflect.Field;
  21
  22 import android.content.Context;
  23 import android.content.pm.ApplicationInfo;
  24 import android.content.pm.PackageManager;
  25 import android.content.res.AssetManager;
  26 import android.graphics.Bitmap;
  27 import android.graphics.BitmapFactory;
  28 import android.graphics.SurfaceTexture;
  29 import android.os.Process;
  30 import android.util.Log;
  31 import android.view.Surface;
  32
  33
  34
  35 /**
  36  * Renderscript base master class.  An instance of this class creates native
  37  * worker threads for processing commands from this object.  This base class
  38  * does not provide any extended capabilities beyond simple data processing.
  39  * For extended capabilities use derived classes such as RenderScriptGL.
  40  *
  41  * <div class="special reference">
  42  * <h3>Developer Guides</h3>
  43  * <p>For more information about creating an application that uses Renderscript, read the
  44  * <a href="{@docRoot}guide/topics/renderscript/index.html">Renderscript</a> developer guide.</p>
  45  * </div>
  46  **/
  47 public class RenderScript {
  48     static final String LOG_TAG = "RenderScript_jni";
  49     static final boolean DEBUG  = false;
  50     @SuppressWarnings({"UnusedDeclaration", "deprecation"})
  51     static final boolean LOG_ENABLED = false;
  52
  53     private Context mApplicationContext;
  54
  55     /*
  56      * We use a class initializer to allow the native code to cache some
  57      * field offsets.
  58      */
  59     @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
  60     static boolean sInitialized;
  61     native static void _nInit();
  62
  63
  64     static {
  65         sInitialized = false;
  66         try {
  67             System.loadLibrary("rs_jni");
  68             _nInit();
  69             sInitialized = true;
  70         } catch (UnsatisfiedLinkError e) {
  71             Log.e(LOG_TAG, "Error loading RS jni library: " + e);
  72             throw new RSRuntimeException("Error loading RS jni library: " + e);
  73         }
  74     }
  75
  76     // Non-threadsafe functions.
  77     native int  nDeviceCreate();
  78     native void nDeviceDestroy(int dev);
  79     native void nDeviceSetConfig(int dev, int param, int value);
  80     native int nContextGetUserMessage(int con, int[] data);
  81     native String nContextGetErrorMessage(int con);
  82     native int  nContextPeekMessage(int con, int[] subID);
  83     native void nContextInitToClient(int con);
  84     native void nContextDeinitToClient(int con);
  85
  86     static File mCacheDir;
  87
  88      /**
  89      * Sets the directory to use as a persistent storage for the
  90      * renderscript object file cache.
  91      *
  92      * @hide
  93      * @param cacheDir A directory the current process can write to
  94      */
  95     public static void setupDiskCache(File cacheDir) {
  96         // Defer creation of cache path to nScriptCCreate().
  97         mCacheDir = cacheDir;
  98     }
  99
 100     /**
 101      * ContextType specifies the specific type of context to be created.
 102      *
 103      */
 104     public enum ContextType {
 105         /**
 106          * NORMAL context, this is the default and what shipping apps should
 107          * use.
 108          */
 109         NORMAL (0),
 110
 111         /**
 112          * DEBUG context, perform extra runtime checks to validate the
 113          * kernels and APIs are being used as intended.  Get and SetElementAt
 114          * will be bounds checked in this mode.
 115          */
 116         DEBUG (1),
 117
 118         /**
 119          * PROFILE context, Intended to be used once the first time an
 120          * application is run on a new device.  This mode allows the runtime to
 121          * do additional testing and performance tuning.
 122          */
 123         PROFILE (2);
 124
 125         int mID;
 126         ContextType(int id) {
 127             mID = id;
 128         }
 129     }
 130
 131     ContextType mContextType;
 132
 133     // Methods below are wrapped to protect the non-threadsafe
 134     // lockless fifo.
 135     native int  rsnContextCreateGL(int dev, int ver, int sdkVer,
 136                  int colorMin, int colorPref,
 137                  int alphaMin, int alphaPref,
 138                  int depthMin, int depthPref,
 139                  int stencilMin, int stencilPref,
 140                  int samplesMin, int samplesPref, float samplesQ, int dpi);
 141     synchronized int nContextCreateGL(int dev, int ver, int sdkVer,
 142                  int colorMin, int colorPref,
 143                  int alphaMin, int alphaPref,
 144                  int depthMin, int depthPref,
 145                  int stencilMin, int stencilPref,
 146                  int samplesMin, int samplesPref, float samplesQ, int dpi) {
 147         return rsnContextCreateGL(dev, ver, sdkVer, colorMin, colorPref,
 148                                   alphaMin, alphaPref, depthMin, depthPref,
 149                                   stencilMin, stencilPref,
 150                                   samplesMin, samplesPref, samplesQ, dpi);
 151     }
 152     native int  rsnContextCreate(int dev, int ver, int sdkVer, int contextType);
 153     synchronized int nContextCreate(int dev, int ver, int sdkVer, int contextType) {
 154         return rsnContextCreate(dev, ver, sdkVer, contextType);
 155     }
 156     native void rsnContextDestroy(int con);
 157     synchronized void nContextDestroy() {
 158         validate();
 159         rsnContextDestroy(mContext);
 160     }
 161     native void rsnContextSetSurface(int con, int w, int h, Surface sur);
 162     synchronized void nContextSetSurface(int w, int h, Surface sur) {
 163         validate();
 164         rsnContextSetSurface(mContext, w, h, sur);
 165     }
 166     native void rsnContextSetSurfaceTexture(int con, int w, int h, SurfaceTexture sur);
 167     synchronized void nContextSetSurfaceTexture(int w, int h, SurfaceTexture sur) {
 168         validate();
 169         rsnContextSetSurfaceTexture(mContext, w, h, sur);
 170     }
 171     native void rsnContextSetPriority(int con, int p);
 172     synchronized void nContextSetPriority(int p) {
 173         validate();
 174         rsnContextSetPriority(mContext, p);
 175     }
 176     native void rsnContextDump(int con, int bits);
 177     synchronized void nContextDump(int bits) {
 178         validate();
 179         rsnContextDump(mContext, bits);
 180     }
 181     native void rsnContextFinish(int con);
 182     synchronized void nContextFinish() {
 183         validate();
 184         rsnContextFinish(mContext);
 185     }
 186
 187     native void rsnContextSendMessage(int con, int id, int[] data);
 188     synchronized void nContextSendMessage(int id, int[] data) {
 189         validate();
 190         rsnContextSendMessage(mContext, id, data);
 191     }
 192
 193     native void rsnContextBindRootScript(int con, int script);
 194     synchronized void nContextBindRootScript(int script) {
 195         validate();
 196         rsnContextBindRootScript(mContext, script);
 197     }
 198     native void rsnContextBindSampler(int con, int sampler, int slot);
 199     synchronized void nContextBindSampler(int sampler, int slot) {
 200         validate();
 201         rsnContextBindSampler(mContext, sampler, slot);
 202     }
 203     native void rsnContextBindProgramStore(int con, int pfs);
 204     synchronized void nContextBindProgramStore(int pfs) {
 205         validate();
 206         rsnContextBindProgramStore(mContext, pfs);
 207     }
 208     native void rsnContextBindProgramFragment(int con, int pf);
 209     synchronized void nContextBindProgramFragment(int pf) {
 210         validate();
 211         rsnContextBindProgramFragment(mContext, pf);
 212     }
 213     native void rsnContextBindProgramVertex(int con, int pv);
 214     synchronized void nContextBindProgramVertex(int pv) {
 215         validate();
 216         rsnContextBindProgramVertex(mContext, pv);
 217     }
 218     native void rsnContextBindProgramRaster(int con, int pr);
 219     synchronized void nContextBindProgramRaster(int pr) {
 220         validate();
 221         rsnContextBindProgramRaster(mContext, pr);
 222     }
 223     native void rsnContextPause(int con);
 224     synchronized void nContextPause() {
 225         validate();
 226         rsnContextPause(mContext);
 227     }
 228     native void rsnContextResume(int con);
 229     synchronized void nContextResume() {
 230         validate();
 231         rsnContextResume(mContext);
 232     }
 233
 234     native void rsnAssignName(int con, int obj, byte[] name);
 235     synchronized void nAssignName(int obj, byte[] name) {
 236         validate();
 237         rsnAssignName(mContext, obj, name);
 238     }
 239     native String rsnGetName(int con, int obj);
 240     synchronized String nGetName(int obj) {
 241         validate();
 242         return rsnGetName(mContext, obj);
 243     }
 244     native void rsnObjDestroy(int con, int id);
 245     synchronized void nObjDestroy(int id) {
 246         // There is a race condition here.  The calling code may be run
 247         // by the gc while teardown is occuring.  This protects againts
 248         // deleting dead objects.
 249         if (mContext != 0) {
 250             rsnObjDestroy(mContext, id);
 251         }
 252     }
 253
 254     native int  rsnElementCreate(int con, int type, int kind, boolean norm, int vecSize);
 255     synchronized int nElementCreate(int type, int kind, boolean norm, int vecSize) {
 256         validate();
 257         return rsnElementCreate(mContext, type, kind, norm, vecSize);
 258     }
 259     native int  rsnElementCreate2(int con, int[] elements, String[] names, int[] arraySizes);
 260     synchronized int nElementCreate2(int[] elements, String[] names, int[] arraySizes) {
 261         validate();
 262         return rsnElementCreate2(mContext, elements, names, arraySizes);
 263     }
 264     native void rsnElementGetNativeData(int con, int id, int[] elementData);
 265     synchronized void nElementGetNativeData(int id, int[] elementData) {
 266         validate();
 267         rsnElementGetNativeData(mContext, id, elementData);
 268     }
 269     native void rsnElementGetSubElements(int con, int id,
 270                                          int[] IDs, String[] names, int[] arraySizes);
 271     synchronized void nElementGetSubElements(int id, int[] IDs, String[] names, int[] arraySizes) {
 272         validate();
 273         rsnElementGetSubElements(mContext, id, IDs, names, arraySizes);
 274     }
 275
 276     native int rsnTypeCreate(int con, int eid, int x, int y, int z, boolean mips, boolean faces, int yuv);
 277     synchronized int nTypeCreate(int eid, int x, int y, int z, boolean mips, boolean faces, int yuv) {
 278         validate();
 279         return rsnTypeCreate(mContext, eid, x, y, z, mips, faces, yuv);
 280     }
 281     native void rsnTypeGetNativeData(int con, int id, int[] typeData);
 282     synchronized void nTypeGetNativeData(int id, int[] typeData) {
 283         validate();
 284         rsnTypeGetNativeData(mContext, id, typeData);
 285     }
 286
 287     native int  rsnAllocationCreateTyped(int con, int type, int mip, int usage, int pointer);
 288     synchronized int nAllocationCreateTyped(int type, int mip, int usage, int pointer) {
 289         validate();
 290         return rsnAllocationCreateTyped(mContext, type, mip, usage, pointer);
 291     }
 292     native int  rsnAllocationCreateFromBitmap(int con, int type, int mip, Bitmap bmp, int usage);
 293     synchronized int nAllocationCreateFromBitmap(int type, int mip, Bitmap bmp, int usage) {
 294         validate();
 295         return rsnAllocationCreateFromBitmap(mContext, type, mip, bmp, usage);
 296     }
 297
 298     native int  rsnAllocationCreateBitmapBackedAllocation(int con, int type, int mip, Bitmap bmp, int usage);
 299     synchronized int nAllocationCreateBitmapBackedAllocation(int type, int mip, Bitmap bmp, int usage) {
 300         validate();
 301         return rsnAllocationCreateBitmapBackedAllocation(mContext, type, mip, bmp, usage);
 302     }
 303
 304
 305     native int  rsnAllocationCubeCreateFromBitmap(int con, int type, int mip, Bitmap bmp, int usage);
 306     synchronized int nAllocationCubeCreateFromBitmap(int type, int mip, Bitmap bmp, int usage) {
 307         validate();
 308         return rsnAllocationCubeCreateFromBitmap(mContext, type, mip, bmp, usage);
 309     }
 310     native int  rsnAllocationCreateBitmapRef(int con, int type, Bitmap bmp);
 311     synchronized int nAllocationCreateBitmapRef(int type, Bitmap bmp) {
 312         validate();
 313         return rsnAllocationCreateBitmapRef(mContext, type, bmp);
 314     }
 315     native int  rsnAllocationCreateFromAssetStream(int con, int mips, int assetStream, int usage);
 316     synchronized int nAllocationCreateFromAssetStream(int mips, int assetStream, int usage) {
 317         validate();
 318         return rsnAllocationCreateFromAssetStream(mContext, mips, assetStream, usage);
 319     }
 320
 321     native void  rsnAllocationCopyToBitmap(int con, int alloc, Bitmap bmp);
 322     synchronized void nAllocationCopyToBitmap(int alloc, Bitmap bmp) {
 323         validate();
 324         rsnAllocationCopyToBitmap(mContext, alloc, bmp);
 325     }
 326
 327
 328     native void rsnAllocationSyncAll(int con, int alloc, int src);
 329     synchronized void nAllocationSyncAll(int alloc, int src) {
 330         validate();
 331         rsnAllocationSyncAll(mContext, alloc, src);
 332     }
 333     native Surface rsnAllocationGetSurface(int con, int alloc);
 334     synchronized Surface nAllocationGetSurface(int alloc) {
 335         validate();
 336         return rsnAllocationGetSurface(mContext, alloc);
 337     }
 338     native void rsnAllocationSetSurface(int con, int alloc, Surface sur);
 339     synchronized void nAllocationSetSurface(int alloc, Surface sur) {
 340         validate();
 341         rsnAllocationSetSurface(mContext, alloc, sur);
 342     }
 343     native void rsnAllocationIoSend(int con, int alloc);
 344     synchronized void nAllocationIoSend(int alloc) {
 345         validate();
 346         rsnAllocationIoSend(mContext, alloc);
 347     }
 348     native void rsnAllocationIoReceive(int con, int alloc);
 349     synchronized void nAllocationIoReceive(int alloc) {
 350         validate();
 351         rsnAllocationIoReceive(mContext, alloc);
 352     }
 353
 354
 355     native void rsnAllocationGenerateMipmaps(int con, int alloc);
 356     synchronized void nAllocationGenerateMipmaps(int alloc) {
 357         validate();
 358         rsnAllocationGenerateMipmaps(mContext, alloc);
 359     }
 360     native void  rsnAllocationCopyFromBitmap(int con, int alloc, Bitmap bmp);
 361     synchronized void nAllocationCopyFromBitmap(int alloc, Bitmap bmp) {
 362         validate();
 363         rsnAllocationCopyFromBitmap(mContext, alloc, bmp);
 364     }
 365
 366
 367     native void rsnAllocationData1D(int con, int id, int off, int mip, int count, int[] d, int sizeBytes);
 368     synchronized void nAllocationData1D(int id, int off, int mip, int count, int[] d, int sizeBytes) {
 369         validate();
 370         rsnAllocationData1D(mContext, id, off, mip, count, d, sizeBytes);
 371     }
 372     native void rsnAllocationData1D(int con, int id, int off, int mip, int count, short[] d, int sizeBytes);
 373     synchronized void nAllocationData1D(int id, int off, int mip, int count, short[] d, int sizeBytes) {
 374         validate();
 375         rsnAllocationData1D(mContext, id, off, mip, count, d, sizeBytes);
 376     }
 377     native void rsnAllocationData1D(int con, int id, int off, int mip, int count, byte[] d, int sizeBytes);
 378     synchronized void nAllocationData1D(int id, int off, int mip, int count, byte[] d, int sizeBytes) {
 379         validate();
 380         rsnAllocationData1D(mContext, id, off, mip, count, d, sizeBytes);
 381     }
 382     native void rsnAllocationData1D(int con, int id, int off, int mip, int count, float[] d, int sizeBytes);
 383     synchronized void nAllocationData1D(int id, int off, int mip, int count, float[] d, int sizeBytes) {
 384         validate();
 385         rsnAllocationData1D(mContext, id, off, mip, count, d, sizeBytes);
 386     }
 387
 388     native void rsnAllocationElementData1D(int con, int id, int xoff, int mip, int compIdx, byte[] d, int sizeBytes);
 389     synchronized void nAllocationElementData1D(int id, int xoff, int mip, int compIdx, byte[] d, int sizeBytes) {
 390         validate();
 391         rsnAllocationElementData1D(mContext, id, xoff, mip, compIdx, d, sizeBytes);
 392     }
 393
 394     native void rsnAllocationData2D(int con,
 395                                     int dstAlloc, int dstXoff, int dstYoff,
 396                                     int dstMip, int dstFace,
 397                                     int width, int height,
 398                                     int srcAlloc, int srcXoff, int srcYoff,
 399                                     int srcMip, int srcFace);
 400     synchronized void nAllocationData2D(int dstAlloc, int dstXoff, int dstYoff,
 401                                         int dstMip, int dstFace,
 402                                         int width, int height,
 403                                         int srcAlloc, int srcXoff, int srcYoff,
 404                                         int srcMip, int srcFace) {
 405         validate();
 406         rsnAllocationData2D(mContext,
 407                             dstAlloc, dstXoff, dstYoff,
 408                             dstMip, dstFace,
 409                             width, height,
 410                             srcAlloc, srcXoff, srcYoff,
 411                             srcMip, srcFace);
 412     }
 413
 414     native void rsnAllocationData2D(int con, int id, int xoff, int yoff, int mip, int face, int w, int h, byte[] d, int sizeBytes);
 415     synchronized void nAllocationData2D(int id, int xoff, int yoff, int mip, int face, int w, int h, byte[] d, int sizeBytes) {
 416         validate();
 417         rsnAllocationData2D(mContext, id, xoff, yoff, mip, face, w, h, d, sizeBytes);
 418     }
 419     native void rsnAllocationData2D(int con, int id, int xoff, int yoff, int mip, int face, int w, int h, short[] d, int sizeBytes);
 420     synchronized void nAllocationData2D(int id, int xoff, int yoff, int mip, int face, int w, int h, short[] d, int sizeBytes) {
 421         validate();
 422         rsnAllocationData2D(mContext, id, xoff, yoff, mip, face, w, h, d, sizeBytes);
 423     }
 424     native void rsnAllocationData2D(int con, int id, int xoff, int yoff, int mip, int face, int w, int h, int[] d, int sizeBytes);
 425     synchronized void nAllocationData2D(int id, int xoff, int yoff, int mip, int face, int w, int h, int[] d, int sizeBytes) {
 426         validate();
 427         rsnAllocationData2D(mContext, id, xoff, yoff, mip, face, w, h, d, sizeBytes);
 428     }
 429     native void rsnAllocationData2D(int con, int id, int xoff, int yoff, int mip, int face, int w, int h, float[] d, int sizeBytes);
 430     synchronized void nAllocationData2D(int id, int xoff, int yoff, int mip, int face, int w, int h, float[] d, int sizeBytes) {
 431         validate();
 432         rsnAllocationData2D(mContext, id, xoff, yoff, mip, face, w, h, d, sizeBytes);
 433     }
 434     native void rsnAllocationData2D(int con, int id, int xoff, int yoff, int mip, int face, Bitmap b);
 435     synchronized void nAllocationData2D(int id, int xoff, int yoff, int mip, int face, Bitmap b) {
 436         validate();
 437         rsnAllocationData2D(mContext, id, xoff, yoff, mip, face, b);
 438     }
 439
 440     native void rsnAllocationData3D(int con,
 441                                     int dstAlloc, int dstXoff, int dstYoff, int dstZoff,
 442                                     int dstMip,
 443                                     int width, int height, int depth,
 444                                     int srcAlloc, int srcXoff, int srcYoff, int srcZoff,
 445                                     int srcMip);
 446     synchronized void nAllocationData3D(int dstAlloc, int dstXoff, int dstYoff, int dstZoff,
 447                                         int dstMip,
 448                                         int width, int height, int depth,
 449                                         int srcAlloc, int srcXoff, int srcYoff, int srcZoff,
 450                                         int srcMip) {
 451         validate();
 452         rsnAllocationData3D(mContext,
 453                             dstAlloc, dstXoff, dstYoff, dstZoff,
 454                             dstMip, width, height, depth,
 455                             srcAlloc, srcXoff, srcYoff, srcZoff, srcMip);
 456     }
 457
 458     native void rsnAllocationData3D(int con, int id, int xoff, int yoff, int zoff, int mip, int w, int h, int depth, byte[] d, int sizeBytes);
 459     synchronized void nAllocationData3D(int id, int xoff, int yoff, int zoff, int mip, int w, int h, int depth, byte[] d, int sizeBytes) {
 460         validate();
 461         rsnAllocationData3D(mContext, id, xoff, yoff, zoff, mip, w, h, depth, d, sizeBytes);
 462     }
 463     native void rsnAllocationData3D(int con, int id, int xoff, int yoff, int zoff, int mip, int w, int h, int depth, short[] d, int sizeBytes);
 464     synchronized void nAllocationData3D(int id, int xoff, int yoff, int zoff, int mip, int w, int h, int depth, short[] d, int sizeBytes) {
 465         validate();
 466         rsnAllocationData3D(mContext, id, xoff, yoff, zoff, mip, w, h, depth, d, sizeBytes);
 467     }
 468     native void rsnAllocationData3D(int con, int id, int xoff, int yoff, int zoff, int mip, int w, int h, int depth, int[] d, int sizeBytes);
 469     synchronized void nAllocationData3D(int id, int xoff, int yoff, int zoff, int mip, int w, int h, int depth, int[] d, int sizeBytes) {
 470         validate();
 471         rsnAllocationData3D(mContext, id, xoff, yoff, zoff, mip, w, h, depth, d, sizeBytes);
 472     }
 473     native void rsnAllocationData3D(int con, int id, int xoff, int yoff, int zoff, int mip, int w, int h, int depth, float[] d, int sizeBytes);
 474     synchronized void nAllocationData3D(int id, int xoff, int yoff, int zoff, int mip, int w, int h, int depth, float[] d, int sizeBytes) {
 475         validate();
 476         rsnAllocationData3D(mContext, id, xoff, yoff, zoff, mip, w, h, depth, d, sizeBytes);
 477     }
 478
 479
 480     native void rsnAllocationRead(int con, int id, byte[] d);
 481     synchronized void nAllocationRead(int id, byte[] d) {
 482         validate();
 483         rsnAllocationRead(mContext, id, d);
 484     }
 485     native void rsnAllocationRead(int con, int id, short[] d);
 486     synchronized void nAllocationRead(int id, short[] d) {
 487         validate();
 488         rsnAllocationRead(mContext, id, d);
 489     }
 490     native void rsnAllocationRead(int con, int id, int[] d);
 491     synchronized void nAllocationRead(int id, int[] d) {
 492         validate();
 493         rsnAllocationRead(mContext, id, d);
 494     }
 495     native void rsnAllocationRead(int con, int id, float[] d);
 496     synchronized void nAllocationRead(int id, float[] d) {
 497         validate();
 498         rsnAllocationRead(mContext, id, d);
 499     }
 500     native int  rsnAllocationGetType(int con, int id);
 501     synchronized int nAllocationGetType(int id) {
 502         validate();
 503         return rsnAllocationGetType(mContext, id);
 504     }
 505
 506     native void rsnAllocationResize1D(int con, int id, int dimX);
 507     synchronized void nAllocationResize1D(int id, int dimX) {
 508         validate();
 509         rsnAllocationResize1D(mContext, id, dimX);
 510     }
 511
 512     native int  rsnFileA3DCreateFromAssetStream(int con, int assetStream);
 513     synchronized int nFileA3DCreateFromAssetStream(int assetStream) {
 514         validate();
 515         return rsnFileA3DCreateFromAssetStream(mContext, assetStream);
 516     }
 517     native int  rsnFileA3DCreateFromFile(int con, String path);
 518     synchronized int nFileA3DCreateFromFile(String path) {
 519         validate();
 520         return rsnFileA3DCreateFromFile(mContext, path);
 521     }
 522     native int  rsnFileA3DCreateFromAsset(int con, AssetManager mgr, String path);
 523     synchronized int nFileA3DCreateFromAsset(AssetManager mgr, String path) {
 524         validate();
 525         return rsnFileA3DCreateFromAsset(mContext, mgr, path);
 526     }
 527     native int  rsnFileA3DGetNumIndexEntries(int con, int fileA3D);
 528     synchronized int nFileA3DGetNumIndexEntries(int fileA3D) {
 529         validate();
 530         return rsnFileA3DGetNumIndexEntries(mContext, fileA3D);
 531     }
 532     native void rsnFileA3DGetIndexEntries(int con, int fileA3D, int numEntries, int[] IDs, String[] names);
 533     synchronized void nFileA3DGetIndexEntries(int fileA3D, int numEntries, int[] IDs, String[] names) {
 534         validate();
 535         rsnFileA3DGetIndexEntries(mContext, fileA3D, numEntries, IDs, names);
 536     }
 537     native int  rsnFileA3DGetEntryByIndex(int con, int fileA3D, int index);
 538     synchronized int nFileA3DGetEntryByIndex(int fileA3D, int index) {
 539         validate();
 540         return rsnFileA3DGetEntryByIndex(mContext, fileA3D, index);
 541     }
 542
 543     native int  rsnFontCreateFromFile(int con, String fileName, float size, int dpi);
 544     synchronized int nFontCreateFromFile(String fileName, float size, int dpi) {
 545         validate();
 546         return rsnFontCreateFromFile(mContext, fileName, size, dpi);
 547     }
 548     native int  rsnFontCreateFromAssetStream(int con, String name, float size, int dpi, int assetStream);
 549     synchronized int nFontCreateFromAssetStream(String name, float size, int dpi, int assetStream) {
 550         validate();
 551         return rsnFontCreateFromAssetStream(mContext, name, size, dpi, assetStream);
 552     }
 553     native int  rsnFontCreateFromAsset(int con, AssetManager mgr, String path, float size, int dpi);
 554     synchronized int nFontCreateFromAsset(AssetManager mgr, String path, float size, int dpi) {
 555         validate();
 556         return rsnFontCreateFromAsset(mContext, mgr, path, size, dpi);
 557     }
 558
 559
 560     native void rsnScriptBindAllocation(int con, int script, int alloc, int slot);
 561     synchronized void nScriptBindAllocation(int script, int alloc, int slot) {
 562         validate();
 563         rsnScriptBindAllocation(mContext, script, alloc, slot);
 564     }
 565     native void rsnScriptSetTimeZone(int con, int script, byte[] timeZone);
 566     synchronized void nScriptSetTimeZone(int script, byte[] timeZone) {
 567         validate();
 568         rsnScriptSetTimeZone(mContext, script, timeZone);
 569     }
 570     native void rsnScriptInvoke(int con, int id, int slot);
 571     synchronized void nScriptInvoke(int id, int slot) {
 572         validate();
 573         rsnScriptInvoke(mContext, id, slot);
 574     }
 575     native void rsnScriptForEach(int con, int id, int slot, int ain, int aout, byte[] params);
 576     native void rsnScriptForEach(int con, int id, int slot, int ain, int aout);
 577     native void rsnScriptForEachClipped(int con, int id, int slot, int ain, int aout, byte[] params,
 578                                         int xstart, int xend, int ystart, int yend, int zstart, int zend);
 579     native void rsnScriptForEachClipped(int con, int id, int slot, int ain, int aout,
 580                                         int xstart, int xend, int ystart, int yend, int zstart, int zend);
 581     synchronized void nScriptForEach(int id, int slot, int ain, int aout, byte[] params) {
 582         validate();
 583         if (params == null) {
 584             rsnScriptForEach(mContext, id, slot, ain, aout);
 585         } else {
 586             rsnScriptForEach(mContext, id, slot, ain, aout, params);
 587         }
 588     }
 589
 590     synchronized void nScriptForEachClipped(int id, int slot, int ain, int aout, byte[] params,
 591                                             int xstart, int xend, int ystart, int yend, int zstart, int zend) {
 592         validate();
 593         if (params == null) {
 594             rsnScriptForEachClipped(mContext, id, slot, ain, aout, xstart, xend, ystart, yend, zstart, zend);
 595         } else {
 596             rsnScriptForEachClipped(mContext, id, slot, ain, aout, params, xstart, xend, ystart, yend, zstart, zend);
 597         }
 598     }
 599
 600     native void rsnScriptInvokeV(int con, int id, int slot, byte[] params);
 601     synchronized void nScriptInvokeV(int id, int slot, byte[] params) {
 602         validate();
 603         rsnScriptInvokeV(mContext, id, slot, params);
 604     }
 605
 606     native void rsnScriptSetVarI(int con, int id, int slot, int val);
 607     synchronized void nScriptSetVarI(int id, int slot, int val) {
 608         validate();
 609         rsnScriptSetVarI(mContext, id, slot, val);
 610     }
 611     native int rsnScriptGetVarI(int con, int id, int slot);
 612     synchronized int nScriptGetVarI(int id, int slot) {
 613         validate();
 614         return rsnScriptGetVarI(mContext, id, slot);
 615     }
 616
 617     native void rsnScriptSetVarJ(int con, int id, int slot, long val);
 618     synchronized void nScriptSetVarJ(int id, int slot, long val) {
 619         validate();
 620         rsnScriptSetVarJ(mContext, id, slot, val);
 621     }
 622     native long rsnScriptGetVarJ(int con, int id, int slot);
 623     synchronized long nScriptGetVarJ(int id, int slot) {
 624         validate();
 625         return rsnScriptGetVarJ(mContext, id, slot);
 626     }
 627
 628     native void rsnScriptSetVarF(int con, int id, int slot, float val);
 629     synchronized void nScriptSetVarF(int id, int slot, float val) {
 630         validate();
 631         rsnScriptSetVarF(mContext, id, slot, val);
 632     }
 633     native float rsnScriptGetVarF(int con, int id, int slot);
 634     synchronized float nScriptGetVarF(int id, int slot) {
 635         validate();
 636         return rsnScriptGetVarF(mContext, id, slot);
 637     }
 638     native void rsnScriptSetVarD(int con, int id, int slot, double val);
 639     synchronized void nScriptSetVarD(int id, int slot, double val) {
 640         validate();
 641         rsnScriptSetVarD(mContext, id, slot, val);
 642     }
 643     native double rsnScriptGetVarD(int con, int id, int slot);
 644     synchronized double nScriptGetVarD(int id, int slot) {
 645         validate();
 646         return rsnScriptGetVarD(mContext, id, slot);
 647     }
 648     native void rsnScriptSetVarV(int con, int id, int slot, byte[] val);
 649     synchronized void nScriptSetVarV(int id, int slot, byte[] val) {
 650         validate();
 651         rsnScriptSetVarV(mContext, id, slot, val);
 652     }
 653     native void rsnScriptGetVarV(int con, int id, int slot, byte[] val);
 654     synchronized void nScriptGetVarV(int id, int slot, byte[] val) {
 655         validate();
 656         rsnScriptGetVarV(mContext, id, slot, val);
 657     }
 658     native void rsnScriptSetVarVE(int con, int id, int slot, byte[] val,
 659                                   int e, int[] dims);
 660     synchronized void nScriptSetVarVE(int id, int slot, byte[] val,
 661                                       int e, int[] dims) {
 662         validate();
 663         rsnScriptSetVarVE(mContext, id, slot, val, e, dims);
 664     }
 665     native void rsnScriptSetVarObj(int con, int id, int slot, int val);
 666     synchronized void nScriptSetVarObj(int id, int slot, int val) {
 667         validate();
 668         rsnScriptSetVarObj(mContext, id, slot, val);
 669     }
 670
 671     native int  rsnScriptCCreate(int con, String resName, String cacheDir,
 672                                  byte[] script, int length);
 673     synchronized int nScriptCCreate(String resName, String cacheDir, byte[] script, int length) {
 674         validate();
 675         return rsnScriptCCreate(mContext, resName, cacheDir, script, length);
 676     }
 677
 678     native int  rsnScriptIntrinsicCreate(int con, int id, int eid);
 679     synchronized int nScriptIntrinsicCreate(int id, int eid) {
 680         validate();
 681         return rsnScriptIntrinsicCreate(mContext, id, eid);
 682     }
 683
 684     native int  rsnScriptKernelIDCreate(int con, int sid, int slot, int sig);
 685     synchronized int nScriptKernelIDCreate(int sid, int slot, int sig) {
 686         validate();
 687         return rsnScriptKernelIDCreate(mContext, sid, slot, sig);
 688     }
 689
 690     native int  rsnScriptFieldIDCreate(int con, int sid, int slot);
 691     synchronized int nScriptFieldIDCreate(int sid, int slot) {
 692         validate();
 693         return rsnScriptFieldIDCreate(mContext, sid, slot);
 694     }
 695
 696     native int  rsnScriptGroupCreate(int con, int[] kernels, int[] src, int[] dstk, int[] dstf, int[] types);
 697     synchronized int nScriptGroupCreate(int[] kernels, int[] src, int[] dstk, int[] dstf, int[] types) {
 698         validate();
 699         return rsnScriptGroupCreate(mContext, kernels, src, dstk, dstf, types);
 700     }
 701
 702     native void rsnScriptGroupSetInput(int con, int group, int kernel, int alloc);
 703     synchronized void nScriptGroupSetInput(int group, int kernel, int alloc) {
 704         validate();
 705         rsnScriptGroupSetInput(mContext, group, kernel, alloc);
 706     }
 707
 708     native void rsnScriptGroupSetOutput(int con, int group, int kernel, int alloc);
 709     synchronized void nScriptGroupSetOutput(int group, int kernel, int alloc) {
 710         validate();
 711         rsnScriptGroupSetOutput(mContext, group, kernel, alloc);
 712     }
 713
 714     native void rsnScriptGroupExecute(int con, int group);
 715     synchronized void nScriptGroupExecute(int group) {
 716         validate();
 717         rsnScriptGroupExecute(mContext, group);
 718     }
 719
 720     native int  rsnSamplerCreate(int con, int magFilter, int minFilter,
 721                                  int wrapS, int wrapT, int wrapR, float aniso);
 722     synchronized int nSamplerCreate(int magFilter, int minFilter,
 723                                  int wrapS, int wrapT, int wrapR, float aniso) {
 724         validate();
 725         return rsnSamplerCreate(mContext, magFilter, minFilter, wrapS, wrapT, wrapR, aniso);
 726     }
 727
 728     native int  rsnProgramStoreCreate(int con, boolean r, boolean g, boolean b, boolean a,
 729                                       boolean depthMask, boolean dither,
 730                                       int srcMode, int dstMode, int depthFunc);
 731     synchronized int nProgramStoreCreate(boolean r, boolean g, boolean b, boolean a,
 732                                          boolean depthMask, boolean dither,
 733                                          int srcMode, int dstMode, int depthFunc) {
 734         validate();
 735         return rsnProgramStoreCreate(mContext, r, g, b, a, depthMask, dither, srcMode,
 736                                      dstMode, depthFunc);
 737     }
 738
 739     native int  rsnProgramRasterCreate(int con, boolean pointSprite, int cullMode);
 740     synchronized int nProgramRasterCreate(boolean pointSprite, int cullMode) {
 741         validate();
 742         return rsnProgramRasterCreate(mContext, pointSprite, cullMode);
 743     }
 744
 745     native void rsnProgramBindConstants(int con, int pv, int slot, int mID);
 746     synchronized void nProgramBindConstants(int pv, int slot, int mID) {
 747         validate();
 748         rsnProgramBindConstants(mContext, pv, slot, mID);
 749     }
 750     native void rsnProgramBindTexture(int con, int vpf, int slot, int a);
 751     synchronized void nProgramBindTexture(int vpf, int slot, int a) {
 752         validate();
 753         rsnProgramBindTexture(mContext, vpf, slot, a);
 754     }
 755     native void rsnProgramBindSampler(int con, int vpf, int slot, int s);
 756     synchronized void nProgramBindSampler(int vpf, int slot, int s) {
 757         validate();
 758         rsnProgramBindSampler(mContext, vpf, slot, s);
 759     }
 760     native int  rsnProgramFragmentCreate(int con, String shader, String[] texNames, int[] params);
 761     synchronized int nProgramFragmentCreate(String shader, String[] texNames, int[] params) {
 762         validate();
 763         return rsnProgramFragmentCreate(mContext, shader, texNames, params);
 764     }
 765     native int  rsnProgramVertexCreate(int con, String shader, String[] texNames, int[] params);
 766     synchronized int nProgramVertexCreate(String shader, String[] texNames, int[] params) {
 767         validate();
 768         return rsnProgramVertexCreate(mContext, shader, texNames, params);
 769     }
 770
 771     native int  rsnMeshCreate(int con, int[] vtx, int[] idx, int[] prim);
 772     synchronized int nMeshCreate(int[] vtx, int[] idx, int[] prim) {
 773         validate();
 774         return rsnMeshCreate(mContext, vtx, idx, prim);
 775     }
 776     native int  rsnMeshGetVertexBufferCount(int con, int id);
 777     synchronized int nMeshGetVertexBufferCount(int id) {
 778         validate();
 779         return rsnMeshGetVertexBufferCount(mContext, id);
 780     }
 781     native int  rsnMeshGetIndexCount(int con, int id);
 782     synchronized int nMeshGetIndexCount(int id) {
 783         validate();
 784         return rsnMeshGetIndexCount(mContext, id);
 785     }
 786     native void rsnMeshGetVertices(int con, int id, int[] vtxIds, int vtxIdCount);
 787     synchronized void nMeshGetVertices(int id, int[] vtxIds, int vtxIdCount) {
 788         validate();
 789         rsnMeshGetVertices(mContext, id, vtxIds, vtxIdCount);
 790     }
 791     native void rsnMeshGetIndices(int con, int id, int[] idxIds, int[] primitives, int vtxIdCount);
 792     synchronized void nMeshGetIndices(int id, int[] idxIds, int[] primitives, int vtxIdCount) {
 793         validate();
 794         rsnMeshGetIndices(mContext, id, idxIds, primitives, vtxIdCount);
 795     }
 796
 797     native int  rsnPathCreate(int con, int prim, boolean isStatic, int vtx, int loop, float q);
 798     synchronized int nPathCreate(int prim, boolean isStatic, int vtx, int loop, float q) {
 799         validate();
 800         return rsnPathCreate(mContext, prim, isStatic, vtx, loop, q);
 801     }
 802
 803     int     mDev;
 804     int     mContext;
 805     @SuppressWarnings({"FieldCanBeLocal"})
 806     MessageThread mMessageThread;
 807
 808     Element mElement_U8;
 809     Element mElement_I8;
 810     Element mElement_U16;
 811     Element mElement_I16;
 812     Element mElement_U32;
 813     Element mElement_I32;
 814     Element mElement_U64;
 815     Element mElement_I64;
 816     Element mElement_F32;
 817     Element mElement_F64;
 818     Element mElement_BOOLEAN;
 819
 820     Element mElement_ELEMENT;
 821     Element mElement_TYPE;
 822     Element mElement_ALLOCATION;
 823     Element mElement_SAMPLER;
 824     Element mElement_SCRIPT;
 825     Element mElement_MESH;
 826     Element mElement_PROGRAM_FRAGMENT;
 827     Element mElement_PROGRAM_VERTEX;
 828     Element mElement_PROGRAM_RASTER;
 829     Element mElement_PROGRAM_STORE;
 830     Element mElement_FONT;
 831
 832     Element mElement_A_8;
 833     Element mElement_RGB_565;
 834     Element mElement_RGB_888;
 835     Element mElement_RGBA_5551;
 836     Element mElement_RGBA_4444;
 837     Element mElement_RGBA_8888;
 838
 839     Element mElement_FLOAT_2;
 840     Element mElement_FLOAT_3;
 841     Element mElement_FLOAT_4;
 842
 843     Element mElement_DOUBLE_2;
 844     Element mElement_DOUBLE_3;
 845     Element mElement_DOUBLE_4;
 846
 847     Element mElement_UCHAR_2;
 848     Element mElement_UCHAR_3;
 849     Element mElement_UCHAR_4;
 850
 851     Element mElement_CHAR_2;
 852     Element mElement_CHAR_3;
 853     Element mElement_CHAR_4;
 854
 855     Element mElement_USHORT_2;
 856     Element mElement_USHORT_3;
 857     Element mElement_USHORT_4;
 858
 859     Element mElement_SHORT_2;
 860     Element mElement_SHORT_3;
 861     Element mElement_SHORT_4;
 862
 863     Element mElement_UINT_2;
 864     Element mElement_UINT_3;
 865     Element mElement_UINT_4;
 866
 867     Element mElement_INT_2;
 868     Element mElement_INT_3;
 869     Element mElement_INT_4;
 870
 871     Element mElement_ULONG_2;
 872     Element mElement_ULONG_3;
 873     Element mElement_ULONG_4;
 874
 875     Element mElement_LONG_2;
 876     Element mElement_LONG_3;
 877     Element mElement_LONG_4;
 878
 879     Element mElement_MATRIX_4X4;
 880     Element mElement_MATRIX_3X3;
 881     Element mElement_MATRIX_2X2;
 882
 883     Sampler mSampler_CLAMP_NEAREST;
 884     Sampler mSampler_CLAMP_LINEAR;
 885     Sampler mSampler_CLAMP_LINEAR_MIP_LINEAR;
 886     Sampler mSampler_WRAP_NEAREST;
 887     Sampler mSampler_WRAP_LINEAR;
 888     Sampler mSampler_WRAP_LINEAR_MIP_LINEAR;
 889     Sampler mSampler_MIRRORED_REPEAT_NEAREST;
 890     Sampler mSampler_MIRRORED_REPEAT_LINEAR;
 891     Sampler mSampler_MIRRORED_REPEAT_LINEAR_MIP_LINEAR;
 892
 893     ProgramStore mProgramStore_BLEND_NONE_DEPTH_TEST;
 894     ProgramStore mProgramStore_BLEND_NONE_DEPTH_NO_DEPTH;
 895     ProgramStore mProgramStore_BLEND_ALPHA_DEPTH_TEST;
 896     ProgramStore mProgramStore_BLEND_ALPHA_DEPTH_NO_DEPTH;
 897
 898     ProgramRaster mProgramRaster_CULL_BACK;
 899     ProgramRaster mProgramRaster_CULL_FRONT;
 900     ProgramRaster mProgramRaster_CULL_NONE;
 901
 902     ///////////////////////////////////////////////////////////////////////////////////
 903     //
 904
 905     /**
 906      * Base class application should derive from for handling RS messages
 907      * coming from their scripts.  When a script calls sendToClient the data
 908      * fields will be filled in and then the run method called by a message
 909      * handling thread.  This will occur some time after sendToClient completes
 910      * in the script.
 911      *
 912      */
 913     public static class RSMessageHandler implements Runnable {
 914         protected int[] mData;
 915         protected int mID;
 916         protected int mLength;
 917         public void run() {
 918         }
 919     }
 920     /**
 921      * If an application is expecting messages it should set this field to an
 922      * instance of RSMessage.  This instance will receive all the user messages
 923      * sent from sendToClient by scripts from this context.
 924      *
 925      */
 926     RSMessageHandler mMessageCallback = null;
 927
 928     public void setMessageHandler(RSMessageHandler msg) {
 929         mMessageCallback = msg;
 930     }
 931     public RSMessageHandler getMessageHandler() {
 932         return mMessageCallback;
 933     }
 934
 935     /**
 936      * Place a message into the message queue to be sent back to the message
 937      * handler once all previous commands have been executed.
 938      *
 939      * @param id
 940      * @param data
 941      */
 942     public void sendMessage(int id, int[] data) {
 943         nContextSendMessage(id, data);
 944     }
 945
 946     /**
 947      * Runtime error base class.  An application should derive from this class
 948      * if it wishes to install an error handler.  When errors occur at runtime
 949      * the fields in this class will be filled and the run method called.
 950      *
 951      */
 952     public static class RSErrorHandler implements Runnable {
 953         protected String mErrorMessage;
 954         protected int mErrorNum;
 955         public void run() {
 956         }
 957     }
 958
 959     /**
 960      * Application Error handler.  All runtime errors will be dispatched to the
 961      * instance of RSAsyncError set here.  If this field is null a
 962      * RSRuntimeException will instead be thrown with details about the error.
 963      * This will cause program termaination.
 964      *
 965      */
 966     RSErrorHandler mErrorCallback = null;
 967
 968     public void setErrorHandler(RSErrorHandler msg) {
 969         mErrorCallback = msg;
 970     }
 971     public RSErrorHandler getErrorHandler() {
 972         return mErrorCallback;
 973     }
 974
 975     /**
 976      * RenderScript worker threads priority enumeration.  The default value is
 977      * NORMAL.  Applications wishing to do background processing such as
 978      * wallpapers should set their priority to LOW to avoid starving forground
 979      * processes.
 980      */
 981     public enum Priority {
 982         LOW (Process.THREAD_PRIORITY_BACKGROUND + (5 * Process.THREAD_PRIORITY_LESS_FAVORABLE)),
 983         NORMAL (Process.THREAD_PRIORITY_DISPLAY);
 984
 985         int mID;
 986         Priority(int id) {
 987             mID = id;
 988         }
 989     }
 990
 991     void validate() {
 992         if (mContext == 0) {
 993             throw new RSInvalidStateException("Calling RS with no Context active.");
 994         }
 995     }
 996
 997
 998     /**
 999      * Change the priority of the worker threads for this context.
1000      *
1001      * @param p New priority to be set.
1002      */
1003     public void setPriority(Priority p) {
1004         validate();
1005         nContextSetPriority(p.mID);
1006     }
1007
1008     static class MessageThread extends Thread {
1009         RenderScript mRS;
1010         boolean mRun = true;
1011         int[] mAuxData = new int[2];
1012
1013         static final int RS_MESSAGE_TO_CLIENT_NONE = 0;
1014         static final int RS_MESSAGE_TO_CLIENT_EXCEPTION = 1;
1015         static final int RS_MESSAGE_TO_CLIENT_RESIZE = 2;
1016         static final int RS_MESSAGE_TO_CLIENT_ERROR = 3;
1017         static final int RS_MESSAGE_TO_CLIENT_USER = 4;
1018         static final int RS_MESSAGE_TO_CLIENT_NEW_BUFFER = 5;
1019
1020         static final int RS_ERROR_FATAL_DEBUG = 0x0800;
1021         static final int RS_ERROR_FATAL_UNKNOWN = 0x1000;
1022
1023         MessageThread(RenderScript rs) {
1024             super("RSMessageThread");
1025             mRS = rs;
1026
1027         }
1028
1029         public void run() {
1030             // This function is a temporary solution.  The final solution will
1031             // used typed allocations where the message id is the type indicator.
1032             int[] rbuf = new int[16];
1033             mRS.nContextInitToClient(mRS.mContext);
1034             while(mRun) {
1035                 rbuf[0] = 0;
1036                 int msg = mRS.nContextPeekMessage(mRS.mContext, mAuxData);
1037                 int size = mAuxData[1];
1038                 int subID = mAuxData[0];
1039
1040                 if (msg == RS_MESSAGE_TO_CLIENT_USER) {
1041                     if ((size>>2) >= rbuf.length) {
1042                         rbuf = new int[(size + 3) >> 2];
1043                     }
1044                     if (mRS.nContextGetUserMessage(mRS.mContext, rbuf) !=
1045                         RS_MESSAGE_TO_CLIENT_USER) {
1046                         throw new RSDriverException("Error processing message from Renderscript.");
1047                     }
1048
1049                     if(mRS.mMessageCallback != null) {
1050                         mRS.mMessageCallback.mData = rbuf;
1051                         mRS.mMessageCallback.mID = subID;
1052                         mRS.mMessageCallback.mLength = size;
1053                         mRS.mMessageCallback.run();
1054                     } else {
1055                         throw new RSInvalidStateException("Received a message from the script with no message handler installed.");
1056                     }
1057                     continue;
1058                 }
1059
1060                 if (msg == RS_MESSAGE_TO_CLIENT_ERROR) {
1061                     String e = mRS.nContextGetErrorMessage(mRS.mContext);
1062
1063                     // Throw RSRuntimeException under the following conditions:
1064                     //
1065                     // 1) It is an unknown fatal error.
1066                     // 2) It is a debug fatal error, and we are not in a
1067                     //    debug context.
1068                     // 3) It is a debug fatal error, and we do not have an
1069                     //    error callback.
1070                     if (subID >= RS_ERROR_FATAL_UNKNOWN ||
1071                         (subID >= RS_ERROR_FATAL_DEBUG &&
1072                          (mRS.mContextType != ContextType.DEBUG ||
1073                           mRS.mErrorCallback == null))) {
1074                         throw new RSRuntimeException("Fatal error " + subID + ", details: " + e);
1075                     }
1076
1077                     if(mRS.mErrorCallback != null) {
1078                         mRS.mErrorCallback.mErrorMessage = e;
1079                         mRS.mErrorCallback.mErrorNum = subID;
1080                         mRS.mErrorCallback.run();
1081                     } else {
1082                         android.util.Log.e(LOG_TAG, "non fatal RS error, " + e);
1083                         // Do not throw here. In these cases, we do not have
1084                         // a fatal error.
1085                     }
1086                     continue;
1087                 }
1088
1089                 if (msg == RS_MESSAGE_TO_CLIENT_NEW_BUFFER) {
1090                     Allocation.sendBufferNotification(subID);
1091                     continue;
1092                 }
1093
1094                 // 2: teardown.
1095                 // But we want to avoid starving other threads during
1096                 // teardown by yielding until the next line in the destructor
1097                 // can execute to set mRun = false
1098                 try {
1099                     sleep(1, 0);
1100                 } catch(InterruptedException e) {
1101                 }
1102             }
1103             //Log.d(LOG_TAG, "MessageThread exiting.");
1104         }
1105     }
1106
1107     RenderScript(Context ctx) {
1108         mContextType = ContextType.NORMAL;
1109         if (ctx != null) {
1110             mApplicationContext = ctx.getApplicationContext();
1111         }
1112     }
1113
1114     /**
1115      * Gets the application context associated with the RenderScript context.
1116      *
1117      * @return The application context.
1118      */
1119     public final Context getApplicationContext() {
1120         return mApplicationContext;
1121     }
1122
1123     /**
1124      * @hide
1125      */
1126     public static RenderScript create(Context ctx, int sdkVersion) {
1127         return create(ctx, sdkVersion, ContextType.NORMAL);
1128     }
1129
1130     /**
1131      * Create a basic RenderScript context.
1132      *
1133      * @hide
1134      * @param ctx The context.
1135      * @return RenderScript
1136      */
1137     public static RenderScript create(Context ctx, int sdkVersion, ContextType ct) {
1138         RenderScript rs = new RenderScript(ctx);
1139
1140         rs.mDev = rs.nDeviceCreate();
1141         rs.mContext = rs.nContextCreate(rs.mDev, 0, sdkVersion, ct.mID);
1142         rs.mContextType = ct;
1143         if (rs.mContext == 0) {
1144             throw new RSDriverException("Failed to create RS context.");
1145         }
1146         rs.mMessageThread = new MessageThread(rs);
1147         rs.mMessageThread.start();
1148         return rs;
1149     }
1150
1151     /**
1152      * Create a basic RenderScript context.
1153      *
1154      * @param ctx The context.
1155      * @return RenderScript
1156      */
1157     public static RenderScript create(Context ctx) {
1158         return create(ctx, ContextType.NORMAL);
1159     }
1160
1161     /**
1162      * Create a basic RenderScript context.
1163      *
1164      *
1165      * @param ctx The context.
1166      * @param ct The type of context to be created.
1167      * @return RenderScript
1168      */
1169     public static RenderScript create(Context ctx, ContextType ct) {
1170         int v = ctx.getApplicationInfo().targetSdkVersion;
1171         return create(ctx, v, ct);
1172     }
1173
1174     /**
1175      * Print the currently available debugging information about the state of
1176      * the RS context to the log.
1177      *
1178      */
1179     public void contextDump() {
1180         validate();
1181         nContextDump(0);
1182     }
1183
1184     /**
1185      * Wait for any commands in the fifo between the java bindings and native to
1186      * be processed.
1187      *
1188      */
1189     public void finish() {
1190         nContextFinish();
1191     }
1192
1193     /**
1194      * Destroy this renderscript context.  Once this function is called its no
1195      * longer legal to use this or any objects created by this context.
1196      *
1197      */
1198     public void destroy() {
1199         validate();
1200         nContextDeinitToClient(mContext);
1201         mMessageThread.mRun = false;
1202         try {
1203             mMessageThread.join();
1204         } catch(InterruptedException e) {
1205         }
1206
1207         nContextDestroy();
1208         mContext = 0;
1209
1210         nDeviceDestroy(mDev);
1211         mDev = 0;
1212     }
1213
1214     boolean isAlive() {
1215         return mContext != 0;
1216     }
1217
1218     int safeID(BaseObj o) {
1219         if(o != null) {
1220             return o.getID(this);
1221         }
1222         return 0;
1223     }
1224 }