rs/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.Method;
  21 import java.util.concurrent.locks.ReentrantReadWriteLock;
  22
  23 import android.content.Context;
  24 import android.content.res.AssetManager;
  25 import android.graphics.Bitmap;
  26 import android.graphics.SurfaceTexture;
  27 import android.util.Log;
  28 import android.view.Surface;
  29 import android.os.SystemProperties;
  30 import android.os.Trace;
  31 import java.util.ArrayList;
  32
  33 // TODO: Clean up the whitespace that separates methods in this class.
  34
  35 /**
  36  * This class provides access to a RenderScript context, which controls RenderScript
  37  * initialization, resource management, and teardown. An instance of the RenderScript
  38  * class must be created before any other RS objects can be created.
  39  *
  40  * <div class="special reference">
  41  * <h3>Developer Guides</h3>
  42  * <p>For more information about creating an application that uses RenderScript, read the
  43  * <a href="{@docRoot}guide/topics/renderscript/index.html">RenderScript</a> developer guide.</p>
  44  * </div>
  45  **/
  46 public class RenderScript {
  47     static final long TRACE_TAG = Trace.TRACE_TAG_RS;
  48
  49     static final String LOG_TAG = "RenderScript_jni";
  50     static final boolean DEBUG  = false;
  51     @SuppressWarnings({"UnusedDeclaration", "deprecation"})
  52     static final boolean LOG_ENABLED = false;
  53
  54     static private ArrayList<RenderScript> mProcessContextList = new ArrayList<RenderScript>();
  55     private boolean mIsProcessContext = false;
  56     private int mContextFlags = 0;
  57     private int mContextSdkVersion = 0;
  58
  59
  60     private Context mApplicationContext;
  61
  62     /*
  63      * We use a class initializer to allow the native code to cache some
  64      * field offsets.
  65      */
  66     @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"}) // TODO: now used locally; remove?
  67     static boolean sInitialized;
  68     native static void _nInit();
  69
  70     static Object sRuntime;
  71     static Method registerNativeAllocation;
  72     static Method registerNativeFree;
  73
  74     /*
  75      * Context creation flag that specifies a normal context.
  76     */
  77     public static final int CREATE_FLAG_NONE = 0x0000;
  78
  79     /*
  80      * Context creation flag which specifies a context optimized for low
  81      * latency over peak performance. This is a hint and may have no effect
  82      * on some implementations.
  83     */
  84     public static final int CREATE_FLAG_LOW_LATENCY = 0x0002;
  85
  86     /*
  87      * Context creation flag which specifies a context optimized for long
  88      * battery life over peak performance. This is a hint and may have no effect
  89      * on some implementations.
  90     */
  91     public static final int CREATE_FLAG_LOW_POWER = 0x0004;
  92
  93     /**
  94      * @hide
  95      * Context creation flag which instructs the implementation to wait for
  96      * a debugger to be attached before continuing execution.
  97     */
  98     public static final int CREATE_FLAG_WAIT_FOR_ATTACH = 0x0008;
  99
 100     /**
 101      * @hide
 102      * Context creation flag which specifies that optimization level 0 is
 103      * passed to the device compiler upon execution of the RenderScript kernel.
 104      * The default optimization level is 3.
 105     */
 106     public static final int CREATE_FLAG_OPT_LEVEL_0 = 0x0010;
 107
 108     /*
 109      * Detect the bitness of the VM to allow FieldPacker to do the right thing.
 110      */
 111     static native int rsnSystemGetPointerSize();
 112     static int sPointerSize;
 113
 114     static {
 115         sInitialized = false;
 116         if (!SystemProperties.getBoolean("config.disable_renderscript", false)) {
 117             try {
 118                 Class<?> vm_runtime = Class.forName("dalvik.system.VMRuntime");
 119                 Method get_runtime = vm_runtime.getDeclaredMethod("getRuntime");
 120                 sRuntime = get_runtime.invoke(null);
 121                 registerNativeAllocation = vm_runtime.getDeclaredMethod("registerNativeAllocation", Integer.TYPE);
 122                 registerNativeFree = vm_runtime.getDeclaredMethod("registerNativeFree", Integer.TYPE);
 123             } catch (Exception e) {
 124                 Log.e(LOG_TAG, "Error loading GC methods: " + e);
 125                 throw new RSRuntimeException("Error loading GC methods: " + e);
 126             }
 127             try {
 128                 System.loadLibrary("rs_jni");
 129                 _nInit();
 130                 sInitialized = true;
 131                 sPointerSize = rsnSystemGetPointerSize();
 132             } catch (UnsatisfiedLinkError e) {
 133                 Log.e(LOG_TAG, "Error loading RS jni library: " + e);
 134                 throw new RSRuntimeException("Error loading RS jni library: " + e);
 135             }
 136         }
 137     }
 138
 139     // Non-threadsafe functions.
 140     native long  nDeviceCreate();
 141     native void nDeviceDestroy(long dev);
 142     native void nDeviceSetConfig(long dev, int param, int value);
 143     native int nContextGetUserMessage(long con, int[] data);
 144     native String nContextGetErrorMessage(long con);
 145     native int  nContextPeekMessage(long con, int[] subID);
 146     native void nContextInitToClient(long con);
 147     native void nContextDeinitToClient(long con);
 148
 149     // this should be a monotonically increasing ID
 150     // used in conjunction with the API version of a device
 151     static final long sMinorVersion = 1;
 152
 153     /**
 154      * @hide
 155      *
 156      * Only exist to be compatible with old version RenderScript Support lib.
 157      * Will eventually be removed.
 158      *
 159      * @return Always return 1
 160      *
 161      */
 162     public static long getMinorID() {
 163         return 1;
 164     }
 165
 166
 167     /**
 168      * Returns an identifier that can be used to identify a particular
 169      * minor version of RS.
 170      *
 171      * @return The minor RenderScript version number
 172      *
 173      */
 174     public static long getMinorVersion() {
 175         return sMinorVersion;
 176     }
 177
 178     /**
 179      * ContextType specifies the specific type of context to be created.
 180      *
 181      */
 182     public enum ContextType {
 183         /**
 184          * NORMAL context, this is the default and what shipping apps should
 185          * use.
 186          */
 187         NORMAL (0),
 188
 189         /**
 190          * DEBUG context, perform extra runtime checks to validate the
 191          * kernels and APIs are being used as intended.  Get and SetElementAt
 192          * will be bounds checked in this mode.
 193          */
 194         DEBUG (1),
 195
 196         /**
 197          * PROFILE context, Intended to be used once the first time an
 198          * application is run on a new device.  This mode allows the runtime to
 199          * do additional testing and performance tuning.
 200          */
 201         PROFILE (2);
 202
 203         int mID;
 204         ContextType(int id) {
 205             mID = id;
 206         }
 207     }
 208
 209     ContextType mContextType;
 210     ReentrantReadWriteLock mRWLock;
 211
 212     // Methods below are wrapped to protect the non-threadsafe
 213     // lockless fifo.
 214     native long  rsnContextCreateGL(long dev, int ver, int sdkVer,
 215                  int colorMin, int colorPref,
 216                  int alphaMin, int alphaPref,
 217                  int depthMin, int depthPref,
 218                  int stencilMin, int stencilPref,
 219                  int samplesMin, int samplesPref, float samplesQ, int dpi);
 220     synchronized long nContextCreateGL(long dev, int ver, int sdkVer,
 221                  int colorMin, int colorPref,
 222                  int alphaMin, int alphaPref,
 223                  int depthMin, int depthPref,
 224                  int stencilMin, int stencilPref,
 225                  int samplesMin, int samplesPref, float samplesQ, int dpi) {
 226         return rsnContextCreateGL(dev, ver, sdkVer, colorMin, colorPref,
 227                                   alphaMin, alphaPref, depthMin, depthPref,
 228                                   stencilMin, stencilPref,
 229                                   samplesMin, samplesPref, samplesQ, dpi);
 230     }
 231     native long  rsnContextCreate(long dev, int ver, int sdkVer, int contextType);
 232     synchronized long nContextCreate(long dev, int ver, int sdkVer, int contextType) {
 233         return rsnContextCreate(dev, ver, sdkVer, contextType);
 234     }
 235     native void rsnContextDestroy(long con);
 236     synchronized void nContextDestroy() {
 237         validate();
 238
 239         // take teardown lock
 240         // teardown lock can only be taken when no objects are being destroyed
 241         ReentrantReadWriteLock.WriteLock wlock = mRWLock.writeLock();
 242         wlock.lock();
 243
 244         long curCon = mContext;
 245         // context is considered dead as of this point
 246         mContext = 0;
 247
 248         wlock.unlock();
 249         rsnContextDestroy(curCon);
 250     }
 251     native void rsnContextSetSurface(long con, int w, int h, Surface sur);
 252     synchronized void nContextSetSurface(int w, int h, Surface sur) {
 253         validate();
 254         rsnContextSetSurface(mContext, w, h, sur);
 255     }
 256     native void rsnContextSetSurfaceTexture(long con, int w, int h, SurfaceTexture sur);
 257     synchronized void nContextSetSurfaceTexture(int w, int h, SurfaceTexture sur) {
 258         validate();
 259         rsnContextSetSurfaceTexture(mContext, w, h, sur);
 260     }
 261     native void rsnContextSetPriority(long con, int p);
 262     synchronized void nContextSetPriority(int p) {
 263         validate();
 264         rsnContextSetPriority(mContext, p);
 265     }
 266     native void rsnContextSetCacheDir(long con, String cacheDir);
 267     synchronized void nContextSetCacheDir(String cacheDir) {
 268         validate();
 269         rsnContextSetCacheDir(mContext, cacheDir);
 270     }
 271     native void rsnContextDump(long con, int bits);
 272     synchronized void nContextDump(int bits) {
 273         validate();
 274         rsnContextDump(mContext, bits);
 275     }
 276     native void rsnContextFinish(long con);
 277     synchronized void nContextFinish() {
 278         validate();
 279         rsnContextFinish(mContext);
 280     }
 281
 282     native void rsnContextSendMessage(long con, int id, int[] data);
 283     synchronized void nContextSendMessage(int id, int[] data) {
 284         validate();
 285         rsnContextSendMessage(mContext, id, data);
 286     }
 287
 288     native void rsnContextBindRootScript(long con, long script);
 289     synchronized void nContextBindRootScript(long script) {
 290         validate();
 291         rsnContextBindRootScript(mContext, script);
 292     }
 293     native void rsnContextBindSampler(long con, int sampler, int slot);
 294     synchronized void nContextBindSampler(int sampler, int slot) {
 295         validate();
 296         rsnContextBindSampler(mContext, sampler, slot);
 297     }
 298     native void rsnContextBindProgramStore(long con, long pfs);
 299     synchronized void nContextBindProgramStore(long pfs) {
 300         validate();
 301         rsnContextBindProgramStore(mContext, pfs);
 302     }
 303     native void rsnContextBindProgramFragment(long con, long pf);
 304     synchronized void nContextBindProgramFragment(long pf) {
 305         validate();
 306         rsnContextBindProgramFragment(mContext, pf);
 307     }
 308     native void rsnContextBindProgramVertex(long con, long pv);
 309     synchronized void nContextBindProgramVertex(long pv) {
 310         validate();
 311         rsnContextBindProgramVertex(mContext, pv);
 312     }
 313     native void rsnContextBindProgramRaster(long con, long pr);
 314     synchronized void nContextBindProgramRaster(long pr) {
 315         validate();
 316         rsnContextBindProgramRaster(mContext, pr);
 317     }
 318     native void rsnContextPause(long con);
 319     synchronized void nContextPause() {
 320         validate();
 321         rsnContextPause(mContext);
 322     }
 323     native void rsnContextResume(long con);
 324     synchronized void nContextResume() {
 325         validate();
 326         rsnContextResume(mContext);
 327     }
 328
 329     native long rsnClosureCreate(long con, long kernelID, long returnValue,
 330         long[] fieldIDs, long[] values, int[] sizes, long[] depClosures,
 331         long[] depFieldIDs);
 332     synchronized long nClosureCreate(long kernelID, long returnValue,
 333         long[] fieldIDs, long[] values, int[] sizes, long[] depClosures,
 334         long[] depFieldIDs) {
 335       validate();
 336       long c = rsnClosureCreate(mContext, kernelID, returnValue, fieldIDs, values,
 337           sizes, depClosures, depFieldIDs);
 338       if (c == 0) {
 339           throw new RSRuntimeException("Failed creating closure.");
 340       }
 341       return c;
 342     }
 343
 344     native long rsnInvokeClosureCreate(long con, long invokeID, byte[] params,
 345         long[] fieldIDs, long[] values, int[] sizes);
 346     synchronized long nInvokeClosureCreate(long invokeID, byte[] params,
 347         long[] fieldIDs, long[] values, int[] sizes) {
 348       validate();
 349       long c = rsnInvokeClosureCreate(mContext, invokeID, params, fieldIDs,
 350           values, sizes);
 351       if (c == 0) {
 352           throw new RSRuntimeException("Failed creating closure.");
 353       }
 354       return c;
 355     }
 356
 357     native void rsnClosureSetArg(long con, long closureID, int index,
 358       long value, int size);
 359     synchronized void nClosureSetArg(long closureID, int index, long value,
 360         int size) {
 361       validate();
 362       rsnClosureSetArg(mContext, closureID, index, value, size);
 363     }
 364
 365     native void rsnClosureSetGlobal(long con, long closureID, long fieldID,
 366         long value, int size);
 367     // Does this have to be synchronized?
 368     synchronized void nClosureSetGlobal(long closureID, long fieldID,
 369         long value, int size) {
 370       validate(); // TODO: is this necessary?
 371       rsnClosureSetGlobal(mContext, closureID, fieldID, value, size);
 372     }
 373
 374     native long rsnScriptGroup2Create(long con, String name, String cachePath,
 375                                       long[] closures);
 376     synchronized long nScriptGroup2Create(String name, String cachePath,
 377                                           long[] closures) {
 378       validate();
 379       long g = rsnScriptGroup2Create(mContext, name, cachePath, closures);
 380       if (g == 0) {
 381           throw new RSRuntimeException("Failed creating script group.");
 382       }
 383       return g;
 384     }
 385
 386     native void rsnScriptGroup2Execute(long con, long groupID);
 387     synchronized void nScriptGroup2Execute(long groupID) {
 388       validate();
 389       rsnScriptGroup2Execute(mContext, groupID);
 390     }
 391
 392     native void rsnAssignName(long con, long obj, byte[] name);
 393     synchronized void nAssignName(long obj, byte[] name) {
 394         validate();
 395         rsnAssignName(mContext, obj, name);
 396     }
 397     native String rsnGetName(long con, long obj);
 398     synchronized String nGetName(long obj) {
 399         validate();
 400         return rsnGetName(mContext, obj);
 401     }
 402
 403     // nObjDestroy is explicitly _not_ synchronous to prevent crashes in finalizers
 404     native void rsnObjDestroy(long con, long id);
 405     void nObjDestroy(long id) {
 406         // There is a race condition here.  The calling code may be run
 407         // by the gc while teardown is occuring.  This protects againts
 408         // deleting dead objects.
 409         if (mContext != 0) {
 410             rsnObjDestroy(mContext, id);
 411         }
 412     }
 413
 414     native long rsnElementCreate(long con, long type, int kind, boolean norm, int vecSize);
 415     synchronized long nElementCreate(long type, int kind, boolean norm, int vecSize) {
 416         validate();
 417         return rsnElementCreate(mContext, type, kind, norm, vecSize);
 418     }
 419     native long rsnElementCreate2(long con, long[] elements, String[] names, int[] arraySizes);
 420     synchronized long nElementCreate2(long[] elements, String[] names, int[] arraySizes) {
 421         validate();
 422         return rsnElementCreate2(mContext, elements, names, arraySizes);
 423     }
 424     native void rsnElementGetNativeData(long con, long id, int[] elementData);
 425     synchronized void nElementGetNativeData(long id, int[] elementData) {
 426         validate();
 427         rsnElementGetNativeData(mContext, id, elementData);
 428     }
 429     native void rsnElementGetSubElements(long con, long id,
 430                                          long[] IDs, String[] names, int[] arraySizes);
 431     synchronized void nElementGetSubElements(long id, long[] IDs, String[] names, int[] arraySizes) {
 432         validate();
 433         rsnElementGetSubElements(mContext, id, IDs, names, arraySizes);
 434     }
 435
 436     native long rsnTypeCreate(long con, long eid, int x, int y, int z, boolean mips, boolean faces, int yuv);
 437     synchronized long nTypeCreate(long eid, int x, int y, int z, boolean mips, boolean faces, int yuv) {
 438         validate();
 439         return rsnTypeCreate(mContext, eid, x, y, z, mips, faces, yuv);
 440     }
 441     native void rsnTypeGetNativeData(long con, long id, long[] typeData);
 442     synchronized void nTypeGetNativeData(long id, long[] typeData) {
 443         validate();
 444         rsnTypeGetNativeData(mContext, id, typeData);
 445     }
 446
 447     native long rsnAllocationCreateTyped(long con, long type, int mip, int usage, long pointer);
 448     synchronized long nAllocationCreateTyped(long type, int mip, int usage, long pointer) {
 449         validate();
 450         return rsnAllocationCreateTyped(mContext, type, mip, usage, pointer);
 451     }
 452     native long rsnAllocationCreateFromBitmap(long con, long type, int mip, Bitmap bmp, int usage);
 453     synchronized long nAllocationCreateFromBitmap(long type, int mip, Bitmap bmp, int usage) {
 454         validate();
 455         return rsnAllocationCreateFromBitmap(mContext, type, mip, bmp, usage);
 456     }
 457
 458     native long rsnAllocationCreateBitmapBackedAllocation(long con, long type, int mip, Bitmap bmp, int usage);
 459     synchronized long nAllocationCreateBitmapBackedAllocation(long type, int mip, Bitmap bmp, int usage) {
 460         validate();
 461         return rsnAllocationCreateBitmapBackedAllocation(mContext, type, mip, bmp, usage);
 462     }
 463
 464     native long rsnAllocationCubeCreateFromBitmap(long con, long type, int mip, Bitmap bmp, int usage);
 465     synchronized long nAllocationCubeCreateFromBitmap(long type, int mip, Bitmap bmp, int usage) {
 466         validate();
 467         return rsnAllocationCubeCreateFromBitmap(mContext, type, mip, bmp, usage);
 468     }
 469     native long  rsnAllocationCreateBitmapRef(long con, long type, Bitmap bmp);
 470     synchronized long nAllocationCreateBitmapRef(long type, Bitmap bmp) {
 471         validate();
 472         return rsnAllocationCreateBitmapRef(mContext, type, bmp);
 473     }
 474     native long  rsnAllocationCreateFromAssetStream(long con, int mips, int assetStream, int usage);
 475     synchronized long nAllocationCreateFromAssetStream(int mips, int assetStream, int usage) {
 476         validate();
 477         return rsnAllocationCreateFromAssetStream(mContext, mips, assetStream, usage);
 478     }
 479
 480     native void  rsnAllocationCopyToBitmap(long con, long alloc, Bitmap bmp);
 481     synchronized void nAllocationCopyToBitmap(long alloc, Bitmap bmp) {
 482         validate();
 483         rsnAllocationCopyToBitmap(mContext, alloc, bmp);
 484     }
 485
 486
 487     native void rsnAllocationSyncAll(long con, long alloc, int src);
 488     synchronized void nAllocationSyncAll(long alloc, int src) {
 489         validate();
 490         rsnAllocationSyncAll(mContext, alloc, src);
 491     }
 492     native Surface rsnAllocationGetSurface(long con, long alloc);
 493     synchronized Surface nAllocationGetSurface(long alloc) {
 494         validate();
 495         return rsnAllocationGetSurface(mContext, alloc);
 496     }
 497     native void rsnAllocationSetSurface(long con, long alloc, Surface sur);
 498     synchronized void nAllocationSetSurface(long alloc, Surface sur) {
 499         validate();
 500         rsnAllocationSetSurface(mContext, alloc, sur);
 501     }
 502     native void rsnAllocationIoSend(long con, long alloc);
 503     synchronized void nAllocationIoSend(long alloc) {
 504         validate();
 505         rsnAllocationIoSend(mContext, alloc);
 506     }
 507     native void rsnAllocationIoReceive(long con, long alloc);
 508     synchronized void nAllocationIoReceive(long alloc) {
 509         validate();
 510         rsnAllocationIoReceive(mContext, alloc);
 511     }
 512
 513
 514     native void rsnAllocationGenerateMipmaps(long con, long alloc);
 515     synchronized void nAllocationGenerateMipmaps(long alloc) {
 516         validate();
 517         rsnAllocationGenerateMipmaps(mContext, alloc);
 518     }
 519     native void  rsnAllocationCopyFromBitmap(long con, long alloc, Bitmap bmp);
 520     synchronized void nAllocationCopyFromBitmap(long alloc, Bitmap bmp) {
 521         validate();
 522         rsnAllocationCopyFromBitmap(mContext, alloc, bmp);
 523     }
 524
 525
 526     native void rsnAllocationData1D(long con, long id, int off, int mip, int count, Object d, int sizeBytes, int dt,
 527                                     int mSize, boolean usePadding);
 528     synchronized void nAllocationData1D(long id, int off, int mip, int count, Object d, int sizeBytes, Element.DataType dt,
 529                                         int mSize, boolean usePadding) {
 530         validate();
 531         rsnAllocationData1D(mContext, id, off, mip, count, d, sizeBytes, dt.mID, mSize, usePadding);
 532     }
 533
 534     native void rsnAllocationElementData(long con,long id, int xoff, int yoff, int zoff, int mip, int compIdx, byte[] d, int sizeBytes);
 535     synchronized void nAllocationElementData(long id, int xoff, int yoff, int zoff, int mip, int compIdx, byte[] d, int sizeBytes) {
 536         validate();
 537         rsnAllocationElementData(mContext, id, xoff, yoff, zoff, mip, compIdx, d, sizeBytes);
 538     }
 539
 540     native void rsnAllocationData2D(long con,
 541                                     long dstAlloc, int dstXoff, int dstYoff,
 542                                     int dstMip, int dstFace,
 543                                     int width, int height,
 544                                     long srcAlloc, int srcXoff, int srcYoff,
 545                                     int srcMip, int srcFace);
 546     synchronized void nAllocationData2D(long dstAlloc, int dstXoff, int dstYoff,
 547                                         int dstMip, int dstFace,
 548                                         int width, int height,
 549                                         long srcAlloc, int srcXoff, int srcYoff,
 550                                         int srcMip, int srcFace) {
 551         validate();
 552         rsnAllocationData2D(mContext,
 553                             dstAlloc, dstXoff, dstYoff,
 554                             dstMip, dstFace,
 555                             width, height,
 556                             srcAlloc, srcXoff, srcYoff,
 557                             srcMip, srcFace);
 558     }
 559
 560     native void rsnAllocationData2D(long con, long id, int xoff, int yoff, int mip, int face,
 561                                     int w, int h, Object d, int sizeBytes, int dt,
 562                                     int mSize, boolean usePadding);
 563     synchronized void nAllocationData2D(long id, int xoff, int yoff, int mip, int face,
 564                                         int w, int h, Object d, int sizeBytes, Element.DataType dt,
 565                                         int mSize, boolean usePadding) {
 566         validate();
 567         rsnAllocationData2D(mContext, id, xoff, yoff, mip, face, w, h, d, sizeBytes, dt.mID, mSize, usePadding);
 568     }
 569
 570     native void rsnAllocationData2D(long con, long id, int xoff, int yoff, int mip, int face, Bitmap b);
 571     synchronized void nAllocationData2D(long id, int xoff, int yoff, int mip, int face, Bitmap b) {
 572         validate();
 573         rsnAllocationData2D(mContext, id, xoff, yoff, mip, face, b);
 574     }
 575
 576     native void rsnAllocationData3D(long con,
 577                                     long dstAlloc, int dstXoff, int dstYoff, int dstZoff,
 578                                     int dstMip,
 579                                     int width, int height, int depth,
 580                                     long srcAlloc, int srcXoff, int srcYoff, int srcZoff,
 581                                     int srcMip);
 582     synchronized void nAllocationData3D(long dstAlloc, int dstXoff, int dstYoff, int dstZoff,
 583                                         int dstMip,
 584                                         int width, int height, int depth,
 585                                         long srcAlloc, int srcXoff, int srcYoff, int srcZoff,
 586                                         int srcMip) {
 587         validate();
 588         rsnAllocationData3D(mContext,
 589                             dstAlloc, dstXoff, dstYoff, dstZoff,
 590                             dstMip, width, height, depth,
 591                             srcAlloc, srcXoff, srcYoff, srcZoff, srcMip);
 592     }
 593
 594     native void rsnAllocationData3D(long con, long id, int xoff, int yoff, int zoff, int mip,
 595                                     int w, int h, int depth, Object d, int sizeBytes, int dt,
 596                                     int mSize, boolean usePadding);
 597     synchronized void nAllocationData3D(long id, int xoff, int yoff, int zoff, int mip,
 598                                         int w, int h, int depth, Object d, int sizeBytes, Element.DataType dt,
 599                                         int mSize, boolean usePadding) {
 600         validate();
 601         rsnAllocationData3D(mContext, id, xoff, yoff, zoff, mip, w, h, depth, d, sizeBytes,
 602                             dt.mID, mSize, usePadding);
 603     }
 604
 605     native void rsnAllocationRead(long con, long id, Object d, int dt, int mSize, boolean usePadding);
 606     synchronized void nAllocationRead(long id, Object d, Element.DataType dt, int mSize, boolean usePadding) {
 607         validate();
 608         rsnAllocationRead(mContext, id, d, dt.mID, mSize, usePadding);
 609     }
 610
 611     native void rsnAllocationRead1D(long con, long id, int off, int mip, int count, Object d,
 612                                     int sizeBytes, int dt, int mSize, boolean usePadding);
 613     synchronized void nAllocationRead1D(long id, int off, int mip, int count, Object d,
 614                                         int sizeBytes, Element.DataType dt, int mSize, boolean usePadding) {
 615         validate();
 616         rsnAllocationRead1D(mContext, id, off, mip, count, d, sizeBytes, dt.mID, mSize, usePadding);
 617     }
 618
 619     native void rsnAllocationElementRead(long con,long id, int xoff, int yoff, int zoff,
 620                                          int mip, int compIdx, byte[] d, int sizeBytes);
 621     synchronized void nAllocationElementRead(long id, int xoff, int yoff, int zoff,
 622                                              int mip, int compIdx, byte[] d, int sizeBytes) {
 623         validate();
 624         rsnAllocationElementRead(mContext, id, xoff, yoff, zoff, mip, compIdx, d, sizeBytes);
 625     }
 626
 627     native void rsnAllocationRead2D(long con, long id, int xoff, int yoff, int mip, int face,
 628                                     int w, int h, Object d, int sizeBytes, int dt,
 629                                     int mSize, boolean usePadding);
 630     synchronized void nAllocationRead2D(long id, int xoff, int yoff, int mip, int face,
 631                                         int w, int h, Object d, int sizeBytes, Element.DataType dt,
 632                                         int mSize, boolean usePadding) {
 633         validate();
 634         rsnAllocationRead2D(mContext, id, xoff, yoff, mip, face, w, h, d, sizeBytes, dt.mID, mSize, usePadding);
 635     }
 636
 637     native void rsnAllocationRead3D(long con, long id, int xoff, int yoff, int zoff, int mip,
 638                                     int w, int h, int depth, Object d, int sizeBytes, int dt,
 639                                     int mSize, boolean usePadding);
 640     synchronized void nAllocationRead3D(long id, int xoff, int yoff, int zoff, int mip,
 641                                         int w, int h, int depth, Object d, int sizeBytes, Element.DataType dt,
 642                                         int mSize, boolean usePadding) {
 643         validate();
 644         rsnAllocationRead3D(mContext, id, xoff, yoff, zoff, mip, w, h, depth, d, sizeBytes, dt.mID, mSize, usePadding);
 645     }
 646
 647     native long  rsnAllocationGetType(long con, long id);
 648     synchronized long nAllocationGetType(long id) {
 649         validate();
 650         return rsnAllocationGetType(mContext, id);
 651     }
 652
 653     native void rsnAllocationResize1D(long con, long id, int dimX);
 654     synchronized void nAllocationResize1D(long id, int dimX) {
 655         validate();
 656         rsnAllocationResize1D(mContext, id, dimX);
 657     }
 658
 659     native long  rsnAllocationAdapterCreate(long con, long allocId, long typeId);
 660     synchronized long nAllocationAdapterCreate(long allocId, long typeId) {
 661         validate();
 662         return rsnAllocationAdapterCreate(mContext, allocId, typeId);
 663     }
 664
 665     native void  rsnAllocationAdapterOffset(long con, long id, int x, int y, int z,
 666                                             int mip, int face, int a1, int a2, int a3, int a4);
 667     synchronized void nAllocationAdapterOffset(long id, int x, int y, int z,
 668                                                int mip, int face, int a1, int a2, int a3, int a4) {
 669         validate();
 670         rsnAllocationAdapterOffset(mContext, id, x, y, z, mip, face, a1, a2, a3, a4);
 671     }
 672
 673     native long rsnFileA3DCreateFromAssetStream(long con, long assetStream);
 674     synchronized long nFileA3DCreateFromAssetStream(long assetStream) {
 675         validate();
 676         return rsnFileA3DCreateFromAssetStream(mContext, assetStream);
 677     }
 678     native long rsnFileA3DCreateFromFile(long con, String path);
 679     synchronized long nFileA3DCreateFromFile(String path) {
 680         validate();
 681         return rsnFileA3DCreateFromFile(mContext, path);
 682     }
 683     native long rsnFileA3DCreateFromAsset(long con, AssetManager mgr, String path);
 684     synchronized long nFileA3DCreateFromAsset(AssetManager mgr, String path) {
 685         validate();
 686         return rsnFileA3DCreateFromAsset(mContext, mgr, path);
 687     }
 688     native int  rsnFileA3DGetNumIndexEntries(long con, long fileA3D);
 689     synchronized int nFileA3DGetNumIndexEntries(long fileA3D) {
 690         validate();
 691         return rsnFileA3DGetNumIndexEntries(mContext, fileA3D);
 692     }
 693     native void rsnFileA3DGetIndexEntries(long con, long fileA3D, int numEntries, int[] IDs, String[] names);
 694     synchronized void nFileA3DGetIndexEntries(long fileA3D, int numEntries, int[] IDs, String[] names) {
 695         validate();
 696         rsnFileA3DGetIndexEntries(mContext, fileA3D, numEntries, IDs, names);
 697     }
 698     native long rsnFileA3DGetEntryByIndex(long con, long fileA3D, int index);
 699     synchronized long nFileA3DGetEntryByIndex(long fileA3D, int index) {
 700         validate();
 701         return rsnFileA3DGetEntryByIndex(mContext, fileA3D, index);
 702     }
 703
 704     native long rsnFontCreateFromFile(long con, String fileName, float size, int dpi);
 705     synchronized long nFontCreateFromFile(String fileName, float size, int dpi) {
 706         validate();
 707         return rsnFontCreateFromFile(mContext, fileName, size, dpi);
 708     }
 709     native long rsnFontCreateFromAssetStream(long con, String name, float size, int dpi, long assetStream);
 710     synchronized long nFontCreateFromAssetStream(String name, float size, int dpi, long assetStream) {
 711         validate();
 712         return rsnFontCreateFromAssetStream(mContext, name, size, dpi, assetStream);
 713     }
 714     native long rsnFontCreateFromAsset(long con, AssetManager mgr, String path, float size, int dpi);
 715     synchronized long nFontCreateFromAsset(AssetManager mgr, String path, float size, int dpi) {
 716         validate();
 717         return rsnFontCreateFromAsset(mContext, mgr, path, size, dpi);
 718     }
 719
 720
 721     native void rsnScriptBindAllocation(long con, long script, long alloc, int slot);
 722     synchronized void nScriptBindAllocation(long script, long alloc, int slot) {
 723         validate();
 724         rsnScriptBindAllocation(mContext, script, alloc, slot);
 725     }
 726     native void rsnScriptSetTimeZone(long con, long script, byte[] timeZone);
 727     synchronized void nScriptSetTimeZone(long script, byte[] timeZone) {
 728         validate();
 729         rsnScriptSetTimeZone(mContext, script, timeZone);
 730     }
 731     native void rsnScriptInvoke(long con, long id, int slot);
 732     synchronized void nScriptInvoke(long id, int slot) {
 733         validate();
 734         rsnScriptInvoke(mContext, id, slot);
 735     }
 736
 737     native void rsnScriptForEach(long con, long id, int slot, long[] ains,
 738                                  long aout, byte[] params, int[] limits);
 739
 740     synchronized void nScriptForEach(long id, int slot, long[] ains, long aout,
 741                                      byte[] params, int[] limits) {
 742         validate();
 743         rsnScriptForEach(mContext, id, slot, ains, aout, params, limits);
 744     }
 745
 746     native void rsnScriptReduce(long con, long id, int slot, long ain,
 747                                 long aout, int[] limits);
 748     synchronized void nScriptReduce(long id, int slot, long ain, long aout,
 749                                     int[] limits) {
 750         validate();
 751         rsnScriptReduce(mContext, id, slot, ain, aout, limits);
 752     }
 753
 754     native void rsnScriptInvokeV(long con, long id, int slot, byte[] params);
 755     synchronized void nScriptInvokeV(long id, int slot, byte[] params) {
 756         validate();
 757         rsnScriptInvokeV(mContext, id, slot, params);
 758     }
 759
 760     native void rsnScriptSetVarI(long con, long id, int slot, int val);
 761     synchronized void nScriptSetVarI(long id, int slot, int val) {
 762         validate();
 763         rsnScriptSetVarI(mContext, id, slot, val);
 764     }
 765     native int rsnScriptGetVarI(long con, long id, int slot);
 766     synchronized int nScriptGetVarI(long id, int slot) {
 767         validate();
 768         return rsnScriptGetVarI(mContext, id, slot);
 769     }
 770
 771     native void rsnScriptSetVarJ(long con, long id, int slot, long val);
 772     synchronized void nScriptSetVarJ(long id, int slot, long val) {
 773         validate();
 774         rsnScriptSetVarJ(mContext, id, slot, val);
 775     }
 776     native long rsnScriptGetVarJ(long con, long id, int slot);
 777     synchronized long nScriptGetVarJ(long id, int slot) {
 778         validate();
 779         return rsnScriptGetVarJ(mContext, id, slot);
 780     }
 781
 782     native void rsnScriptSetVarF(long con, long id, int slot, float val);
 783     synchronized void nScriptSetVarF(long id, int slot, float val) {
 784         validate();
 785         rsnScriptSetVarF(mContext, id, slot, val);
 786     }
 787     native float rsnScriptGetVarF(long con, long id, int slot);
 788     synchronized float nScriptGetVarF(long id, int slot) {
 789         validate();
 790         return rsnScriptGetVarF(mContext, id, slot);
 791     }
 792     native void rsnScriptSetVarD(long con, long id, int slot, double val);
 793     synchronized void nScriptSetVarD(long id, int slot, double val) {
 794         validate();
 795         rsnScriptSetVarD(mContext, id, slot, val);
 796     }
 797     native double rsnScriptGetVarD(long con, long id, int slot);
 798     synchronized double nScriptGetVarD(long id, int slot) {
 799         validate();
 800         return rsnScriptGetVarD(mContext, id, slot);
 801     }
 802     native void rsnScriptSetVarV(long con, long id, int slot, byte[] val);
 803     synchronized void nScriptSetVarV(long id, int slot, byte[] val) {
 804         validate();
 805         rsnScriptSetVarV(mContext, id, slot, val);
 806     }
 807     native void rsnScriptGetVarV(long con, long id, int slot, byte[] val);
 808     synchronized void nScriptGetVarV(long id, int slot, byte[] val) {
 809         validate();
 810         rsnScriptGetVarV(mContext, id, slot, val);
 811     }
 812     native void rsnScriptSetVarVE(long con, long id, int slot, byte[] val,
 813                                   long e, int[] dims);
 814     synchronized void nScriptSetVarVE(long id, int slot, byte[] val,
 815                                       long e, int[] dims) {
 816         validate();
 817         rsnScriptSetVarVE(mContext, id, slot, val, e, dims);
 818     }
 819     native void rsnScriptSetVarObj(long con, long id, int slot, long val);
 820     synchronized void nScriptSetVarObj(long id, int slot, long val) {
 821         validate();
 822         rsnScriptSetVarObj(mContext, id, slot, val);
 823     }
 824
 825     native long rsnScriptCCreate(long con, String resName, String cacheDir,
 826                                  byte[] script, int length);
 827     synchronized long nScriptCCreate(String resName, String cacheDir, byte[] script, int length) {
 828         validate();
 829         return rsnScriptCCreate(mContext, resName, cacheDir, script, length);
 830     }
 831
 832     native long rsnScriptIntrinsicCreate(long con, int id, long eid);
 833     synchronized long nScriptIntrinsicCreate(int id, long eid) {
 834         validate();
 835         return rsnScriptIntrinsicCreate(mContext, id, eid);
 836     }
 837
 838     native long  rsnScriptKernelIDCreate(long con, long sid, int slot, int sig);
 839     synchronized long nScriptKernelIDCreate(long sid, int slot, int sig) {
 840         validate();
 841         return rsnScriptKernelIDCreate(mContext, sid, slot, sig);
 842     }
 843
 844     native long  rsnScriptInvokeIDCreate(long con, long sid, int slot);
 845     synchronized long nScriptInvokeIDCreate(long sid, int slot) {
 846         validate();
 847         return rsnScriptInvokeIDCreate(mContext, sid, slot);
 848     }
 849
 850     native long  rsnScriptFieldIDCreate(long con, long sid, int slot);
 851     synchronized long nScriptFieldIDCreate(long sid, int slot) {
 852         validate();
 853         return rsnScriptFieldIDCreate(mContext, sid, slot);
 854     }
 855
 856     native long rsnScriptGroupCreate(long con, long[] kernels, long[] src, long[] dstk, long[] dstf, long[] types);
 857     synchronized long nScriptGroupCreate(long[] kernels, long[] src, long[] dstk, long[] dstf, long[] types) {
 858         validate();
 859         return rsnScriptGroupCreate(mContext, kernels, src, dstk, dstf, types);
 860     }
 861
 862     native void rsnScriptGroupSetInput(long con, long group, long kernel, long alloc);
 863     synchronized void nScriptGroupSetInput(long group, long kernel, long alloc) {
 864         validate();
 865         rsnScriptGroupSetInput(mContext, group, kernel, alloc);
 866     }
 867
 868     native void rsnScriptGroupSetOutput(long con, long group, long kernel, long alloc);
 869     synchronized void nScriptGroupSetOutput(long group, long kernel, long alloc) {
 870         validate();
 871         rsnScriptGroupSetOutput(mContext, group, kernel, alloc);
 872     }
 873
 874     native void rsnScriptGroupExecute(long con, long group);
 875     synchronized void nScriptGroupExecute(long group) {
 876         validate();
 877         rsnScriptGroupExecute(mContext, group);
 878     }
 879
 880     native long  rsnSamplerCreate(long con, int magFilter, int minFilter,
 881                                  int wrapS, int wrapT, int wrapR, float aniso);
 882     synchronized long nSamplerCreate(int magFilter, int minFilter,
 883                                  int wrapS, int wrapT, int wrapR, float aniso) {
 884         validate();
 885         return rsnSamplerCreate(mContext, magFilter, minFilter, wrapS, wrapT, wrapR, aniso);
 886     }
 887
 888     native long rsnProgramStoreCreate(long con, boolean r, boolean g, boolean b, boolean a,
 889                                       boolean depthMask, boolean dither,
 890                                       int srcMode, int dstMode, int depthFunc);
 891     synchronized long nProgramStoreCreate(boolean r, boolean g, boolean b, boolean a,
 892                                          boolean depthMask, boolean dither,
 893                                          int srcMode, int dstMode, int depthFunc) {
 894         validate();
 895         return rsnProgramStoreCreate(mContext, r, g, b, a, depthMask, dither, srcMode,
 896                                      dstMode, depthFunc);
 897     }
 898
 899     native long rsnProgramRasterCreate(long con, boolean pointSprite, int cullMode);
 900     synchronized long nProgramRasterCreate(boolean pointSprite, int cullMode) {
 901         validate();
 902         return rsnProgramRasterCreate(mContext, pointSprite, cullMode);
 903     }
 904
 905     native void rsnProgramBindConstants(long con, long pv, int slot, long mID);
 906     synchronized void nProgramBindConstants(long pv, int slot, long mID) {
 907         validate();
 908         rsnProgramBindConstants(mContext, pv, slot, mID);
 909     }
 910     native void rsnProgramBindTexture(long con, long vpf, int slot, long a);
 911     synchronized void nProgramBindTexture(long vpf, int slot, long a) {
 912         validate();
 913         rsnProgramBindTexture(mContext, vpf, slot, a);
 914     }
 915     native void rsnProgramBindSampler(long con, long vpf, int slot, long s);
 916     synchronized void nProgramBindSampler(long vpf, int slot, long s) {
 917         validate();
 918         rsnProgramBindSampler(mContext, vpf, slot, s);
 919     }
 920     native long rsnProgramFragmentCreate(long con, String shader, String[] texNames, long[] params);
 921     synchronized long nProgramFragmentCreate(String shader, String[] texNames, long[] params) {
 922         validate();
 923         return rsnProgramFragmentCreate(mContext, shader, texNames, params);
 924     }
 925     native long rsnProgramVertexCreate(long con, String shader, String[] texNames, long[] params);
 926     synchronized long nProgramVertexCreate(String shader, String[] texNames, long[] params) {
 927         validate();
 928         return rsnProgramVertexCreate(mContext, shader, texNames, params);
 929     }
 930
 931     native long rsnMeshCreate(long con, long[] vtx, long[] idx, int[] prim);
 932     synchronized long nMeshCreate(long[] vtx, long[] idx, int[] prim) {
 933         validate();
 934         return rsnMeshCreate(mContext, vtx, idx, prim);
 935     }
 936     native int  rsnMeshGetVertexBufferCount(long con, long id);
 937     synchronized int nMeshGetVertexBufferCount(long id) {
 938         validate();
 939         return rsnMeshGetVertexBufferCount(mContext, id);
 940     }
 941     native int  rsnMeshGetIndexCount(long con, long id);
 942     synchronized int nMeshGetIndexCount(long id) {
 943         validate();
 944         return rsnMeshGetIndexCount(mContext, id);
 945     }
 946     native void rsnMeshGetVertices(long con, long id, long[] vtxIds, int vtxIdCount);
 947     synchronized void nMeshGetVertices(long id, long[] vtxIds, int vtxIdCount) {
 948         validate();
 949         rsnMeshGetVertices(mContext, id, vtxIds, vtxIdCount);
 950     }
 951     native void rsnMeshGetIndices(long con, long id, long[] idxIds, int[] primitives, int vtxIdCount);
 952     synchronized void nMeshGetIndices(long id, long[] idxIds, int[] primitives, int vtxIdCount) {
 953         validate();
 954         rsnMeshGetIndices(mContext, id, idxIds, primitives, vtxIdCount);
 955     }
 956
 957     native void rsnScriptIntrinsicBLAS_Single(long con, long id, int func, int TransA,
 958                                               int TransB, int Side, int Uplo, int Diag, int M, int N, int K,
 959                                               float alpha, long A, long B, float beta, long C, int incX, int incY,
 960                                               int KL, int KU);
 961     synchronized void nScriptIntrinsicBLAS_Single(long id, int func, int TransA,
 962                                                   int TransB, int Side, int Uplo, int Diag, int M, int N, int K,
 963                                                   float alpha, long A, long B, float beta, long C, int incX, int incY,
 964                                                   int KL, int KU) {
 965         validate();
 966         rsnScriptIntrinsicBLAS_Single(mContext, id, func, TransA, TransB, Side, Uplo, Diag, M, N, K, alpha, A, B, beta, C, incX, incY, KL, KU);
 967     }
 968
 969     native void rsnScriptIntrinsicBLAS_Double(long con, long id, int func, int TransA,
 970                                               int TransB, int Side, int Uplo, int Diag, int M, int N, int K,
 971                                               double alpha, long A, long B, double beta, long C, int incX, int incY,
 972                                               int KL, int KU);
 973     synchronized void nScriptIntrinsicBLAS_Double(long id, int func, int TransA,
 974                                                   int TransB, int Side, int Uplo, int Diag, int M, int N, int K,
 975                                                   double alpha, long A, long B, double beta, long C, int incX, int incY,
 976                                                   int KL, int KU) {
 977         validate();
 978         rsnScriptIntrinsicBLAS_Double(mContext, id, func, TransA, TransB, Side, Uplo, Diag, M, N, K, alpha, A, B, beta, C, incX, incY, KL, KU);
 979     }
 980
 981     native void rsnScriptIntrinsicBLAS_Complex(long con, long id, int func, int TransA,
 982                                                int TransB, int Side, int Uplo, int Diag, int M, int N, int K,
 983                                                float alphaX, float alphaY, long A, long B, float betaX, float betaY, long C, int incX, int incY,
 984                                                int KL, int KU);
 985     synchronized void nScriptIntrinsicBLAS_Complex(long id, int func, int TransA,
 986                                                    int TransB, int Side, int Uplo, int Diag, int M, int N, int K,
 987                                                    float alphaX, float alphaY, long A, long B, float betaX, float betaY, long C, int incX, int incY,
 988                                                    int KL, int KU) {
 989         validate();
 990         rsnScriptIntrinsicBLAS_Complex(mContext, id, func, TransA, TransB, Side, Uplo, Diag, M, N, K, alphaX, alphaY, A, B, betaX, betaY, C, incX, incY, KL, KU);
 991     }
 992
 993     native void rsnScriptIntrinsicBLAS_Z(long con, long id, int func, int TransA,
 994                                          int TransB, int Side, int Uplo, int Diag, int M, int N, int K,
 995                                          double alphaX, double alphaY, long A, long B, double betaX, double betaY, long C, int incX, int incY,
 996                                          int KL, int KU);
 997     synchronized void nScriptIntrinsicBLAS_Z(long id, int func, int TransA,
 998                                              int TransB, int Side, int Uplo, int Diag, int M, int N, int K,
 999                                              double alphaX, double alphaY, long A, long B, double betaX, double betaY, long C, int incX, int incY,
1000                                              int KL, int KU) {
1001         validate();
1002         rsnScriptIntrinsicBLAS_Z(mContext, id, func, TransA, TransB, Side, Uplo, Diag, M, N, K, alphaX, alphaY, A, B, betaX, betaY, C, incX, incY, KL, KU);
1003     }
1004
1005     native void rsnScriptIntrinsicBLAS_BNNM(long con, long id, int M, int N, int K,
1006                                              long A, int a_offset, long B, int b_offset, long C, int c_offset,
1007                                              int c_mult_int);
1008     synchronized void nScriptIntrinsicBLAS_BNNM(long id, int M, int N, int K,
1009                                              long A, int a_offset, long B, int b_offset, long C, int c_offset,
1010                                              int c_mult_int) {
1011         validate();
1012         rsnScriptIntrinsicBLAS_BNNM(mContext, id, M, N, K, A, a_offset, B, b_offset, C, c_offset, c_mult_int);
1013     }
1014
1015
1016
1017     long     mDev;
1018     long     mContext;
1019     private boolean mDestroyed = false;
1020
1021     @SuppressWarnings({"FieldCanBeLocal"})
1022     MessageThread mMessageThread;
1023
1024     Element mElement_U8;
1025     Element mElement_I8;
1026     Element mElement_U16;
1027     Element mElement_I16;
1028     Element mElement_U32;
1029     Element mElement_I32;
1030     Element mElement_U64;
1031     Element mElement_I64;
1032     Element mElement_F16;
1033     Element mElement_F32;
1034     Element mElement_F64;
1035     Element mElement_BOOLEAN;
1036
1037     Element mElement_ELEMENT;
1038     Element mElement_TYPE;
1039     Element mElement_ALLOCATION;
1040     Element mElement_SAMPLER;
1041     Element mElement_SCRIPT;
1042     Element mElement_MESH;
1043     Element mElement_PROGRAM_FRAGMENT;
1044     Element mElement_PROGRAM_VERTEX;
1045     Element mElement_PROGRAM_RASTER;
1046     Element mElement_PROGRAM_STORE;
1047     Element mElement_FONT;
1048
1049     Element mElement_A_8;
1050     Element mElement_RGB_565;
1051     Element mElement_RGB_888;
1052     Element mElement_RGBA_5551;
1053     Element mElement_RGBA_4444;
1054     Element mElement_RGBA_8888;
1055
1056     Element mElement_HALF_2;
1057     Element mElement_HALF_3;
1058     Element mElement_HALF_4;
1059
1060     Element mElement_FLOAT_2;
1061     Element mElement_FLOAT_3;
1062     Element mElement_FLOAT_4;
1063
1064     Element mElement_DOUBLE_2;
1065     Element mElement_DOUBLE_3;
1066     Element mElement_DOUBLE_4;
1067
1068     Element mElement_UCHAR_2;
1069     Element mElement_UCHAR_3;
1070     Element mElement_UCHAR_4;
1071
1072     Element mElement_CHAR_2;
1073     Element mElement_CHAR_3;
1074     Element mElement_CHAR_4;
1075
1076     Element mElement_USHORT_2;
1077     Element mElement_USHORT_3;
1078     Element mElement_USHORT_4;
1079
1080     Element mElement_SHORT_2;
1081     Element mElement_SHORT_3;
1082     Element mElement_SHORT_4;
1083
1084     Element mElement_UINT_2;
1085     Element mElement_UINT_3;
1086     Element mElement_UINT_4;
1087
1088     Element mElement_INT_2;
1089     Element mElement_INT_3;
1090     Element mElement_INT_4;
1091
1092     Element mElement_ULONG_2;
1093     Element mElement_ULONG_3;
1094     Element mElement_ULONG_4;
1095
1096     Element mElement_LONG_2;
1097     Element mElement_LONG_3;
1098     Element mElement_LONG_4;
1099
1100     Element mElement_YUV;
1101
1102     Element mElement_MATRIX_4X4;
1103     Element mElement_MATRIX_3X3;
1104     Element mElement_MATRIX_2X2;
1105
1106     Sampler mSampler_CLAMP_NEAREST;
1107     Sampler mSampler_CLAMP_LINEAR;
1108     Sampler mSampler_CLAMP_LINEAR_MIP_LINEAR;
1109     Sampler mSampler_WRAP_NEAREST;
1110     Sampler mSampler_WRAP_LINEAR;
1111     Sampler mSampler_WRAP_LINEAR_MIP_LINEAR;
1112     Sampler mSampler_MIRRORED_REPEAT_NEAREST;
1113     Sampler mSampler_MIRRORED_REPEAT_LINEAR;
1114     Sampler mSampler_MIRRORED_REPEAT_LINEAR_MIP_LINEAR;
1115
1116     ProgramStore mProgramStore_BLEND_NONE_DEPTH_TEST;
1117     ProgramStore mProgramStore_BLEND_NONE_DEPTH_NO_DEPTH;
1118     ProgramStore mProgramStore_BLEND_ALPHA_DEPTH_TEST;
1119     ProgramStore mProgramStore_BLEND_ALPHA_DEPTH_NO_DEPTH;
1120
1121     ProgramRaster mProgramRaster_CULL_BACK;
1122     ProgramRaster mProgramRaster_CULL_FRONT;
1123     ProgramRaster mProgramRaster_CULL_NONE;
1124
1125     ///////////////////////////////////////////////////////////////////////////////////
1126     //
1127
1128     /**
1129      * The base class from which an application should derive in order
1130      * to receive RS messages from scripts. When a script calls {@code
1131      * rsSendToClient}, the data fields will be filled, and the run
1132      * method will be called on a separate thread.  This will occur
1133      * some time after {@code rsSendToClient} completes in the script,
1134      * as {@code rsSendToClient} is asynchronous. Message handlers are
1135      * not guaranteed to have completed when {@link
1136      * android.renderscript.RenderScript#finish} returns.
1137      *
1138      */
1139     public static class RSMessageHandler implements Runnable {
1140         protected int[] mData;
1141         protected int mID;
1142         protected int mLength;
1143         public void run() {
1144         }
1145     }
1146     /**
1147      * If an application is expecting messages, it should set this
1148      * field to an instance of {@link RSMessageHandler}.  This
1149      * instance will receive all the user messages sent from {@code
1150      * sendToClient} by scripts from this context.
1151      *
1152      */
1153     RSMessageHandler mMessageCallback = null;
1154
1155     public void setMessageHandler(RSMessageHandler msg) {
1156         mMessageCallback = msg;
1157     }
1158     public RSMessageHandler getMessageHandler() {
1159         return mMessageCallback;
1160     }
1161
1162     /**
1163      * Place a message into the message queue to be sent back to the message
1164      * handler once all previous commands have been executed.
1165      *
1166      * @param id
1167      * @param data
1168      */
1169     public void sendMessage(int id, int[] data) {
1170         nContextSendMessage(id, data);
1171     }
1172
1173     /**
1174      * The runtime error handler base class.  An application should derive from this class
1175      * if it wishes to install an error handler.  When errors occur at runtime,
1176      * the fields in this class will be filled, and the run method will be called.
1177      *
1178      */
1179     public static class RSErrorHandler implements Runnable {
1180         protected String mErrorMessage;
1181         protected int mErrorNum;
1182         public void run() {
1183         }
1184     }
1185
1186     /**
1187      * Application Error handler.  All runtime errors will be dispatched to the
1188      * instance of RSAsyncError set here.  If this field is null a
1189      * {@link RSRuntimeException} will instead be thrown with details about the error.
1190      * This will cause program termaination.
1191      *
1192      */
1193     RSErrorHandler mErrorCallback = null;
1194
1195     public void setErrorHandler(RSErrorHandler msg) {
1196         mErrorCallback = msg;
1197     }
1198     public RSErrorHandler getErrorHandler() {
1199         return mErrorCallback;
1200     }
1201
1202     /**
1203      * RenderScript worker thread priority enumeration.  The default value is
1204      * NORMAL.  Applications wishing to do background processing should set
1205      * their priority to LOW to avoid starving forground processes.
1206      */
1207     public enum Priority {
1208         // These values used to represent official thread priority values
1209         // now they are simply enums to be used by the runtime side
1210         LOW (15),
1211         NORMAL (-8);
1212
1213         int mID;
1214         Priority(int id) {
1215             mID = id;
1216         }
1217     }
1218
1219     void validateObject(BaseObj o) {
1220         if (o != null) {
1221             if (o.mRS != this) {
1222                 throw new RSIllegalArgumentException("Attempting to use an object across contexts.");
1223             }
1224         }
1225     }
1226
1227     void validate() {
1228         if (mContext == 0) {
1229             throw new RSInvalidStateException("Calling RS with no Context active.");
1230         }
1231     }
1232
1233
1234     /**
1235      * Change the priority of the worker threads for this context.
1236      *
1237      * @param p New priority to be set.
1238      */
1239     public void setPriority(Priority p) {
1240         validate();
1241         nContextSetPriority(p.mID);
1242     }
1243
1244     static class MessageThread extends Thread {
1245         RenderScript mRS;
1246         boolean mRun = true;
1247         int[] mAuxData = new int[2];
1248
1249         static final int RS_MESSAGE_TO_CLIENT_NONE = 0;
1250         static final int RS_MESSAGE_TO_CLIENT_EXCEPTION = 1;
1251         static final int RS_MESSAGE_TO_CLIENT_RESIZE = 2;
1252         static final int RS_MESSAGE_TO_CLIENT_ERROR = 3;
1253         static final int RS_MESSAGE_TO_CLIENT_USER = 4;
1254         static final int RS_MESSAGE_TO_CLIENT_NEW_BUFFER = 5;
1255
1256         static final int RS_ERROR_FATAL_DEBUG = 0x0800;
1257         static final int RS_ERROR_FATAL_UNKNOWN = 0x1000;
1258
1259         MessageThread(RenderScript rs) {
1260             super("RSMessageThread");
1261             mRS = rs;
1262
1263         }
1264
1265         public void run() {
1266             // This function is a temporary solution.  The final solution will
1267             // used typed allocations where the message id is the type indicator.
1268             int[] rbuf = new int[16];
1269             mRS.nContextInitToClient(mRS.mContext);
1270             while(mRun) {
1271                 rbuf[0] = 0;
1272                 int msg = mRS.nContextPeekMessage(mRS.mContext, mAuxData);
1273                 int size = mAuxData[1];
1274                 int subID = mAuxData[0];
1275
1276                 if (msg == RS_MESSAGE_TO_CLIENT_USER) {
1277                     if ((size>>2) >= rbuf.length) {
1278                         rbuf = new int[(size + 3) >> 2];
1279                     }
1280                     if (mRS.nContextGetUserMessage(mRS.mContext, rbuf) !=
1281                         RS_MESSAGE_TO_CLIENT_USER) {
1282                         throw new RSDriverException("Error processing message from RenderScript.");
1283                     }
1284
1285                     if(mRS.mMessageCallback != null) {
1286                         mRS.mMessageCallback.mData = rbuf;
1287                         mRS.mMessageCallback.mID = subID;
1288                         mRS.mMessageCallback.mLength = size;
1289                         mRS.mMessageCallback.run();
1290                     } else {
1291                         throw new RSInvalidStateException("Received a message from the script with no message handler installed.");
1292                     }
1293                     continue;
1294                 }
1295
1296                 if (msg == RS_MESSAGE_TO_CLIENT_ERROR) {
1297                     String e = mRS.nContextGetErrorMessage(mRS.mContext);
1298
1299                     // Throw RSRuntimeException under the following conditions:
1300                     //
1301                     // 1) It is an unknown fatal error.
1302                     // 2) It is a debug fatal error, and we are not in a
1303                     //    debug context.
1304                     // 3) It is a debug fatal error, and we do not have an
1305                     //    error callback.
1306                     if (subID >= RS_ERROR_FATAL_UNKNOWN ||
1307                         (subID >= RS_ERROR_FATAL_DEBUG &&
1308                          (mRS.mContextType != ContextType.DEBUG ||
1309                           mRS.mErrorCallback == null))) {
1310                         throw new RSRuntimeException("Fatal error " + subID + ", details: " + e);
1311                     }
1312
1313                     if(mRS.mErrorCallback != null) {
1314                         mRS.mErrorCallback.mErrorMessage = e;
1315                         mRS.mErrorCallback.mErrorNum = subID;
1316                         mRS.mErrorCallback.run();
1317                     } else {
1318                         android.util.Log.e(LOG_TAG, "non fatal RS error, " + e);
1319                         // Do not throw here. In these cases, we do not have
1320                         // a fatal error.
1321                     }
1322                     continue;
1323                 }
1324
1325                 if (msg == RS_MESSAGE_TO_CLIENT_NEW_BUFFER) {
1326                     if (mRS.nContextGetUserMessage(mRS.mContext, rbuf) !=
1327                         RS_MESSAGE_TO_CLIENT_NEW_BUFFER) {
1328                         throw new RSDriverException("Error processing message from RenderScript.");
1329                     }
1330                     long bufferID = ((long)rbuf[1] << 32L) + ((long)rbuf[0] & 0xffffffffL);
1331                     Allocation.sendBufferNotification(bufferID);
1332                     continue;
1333                 }
1334
1335                 // 2: teardown.
1336                 // But we want to avoid starving other threads during
1337                 // teardown by yielding until the next line in the destructor
1338                 // can execute to set mRun = false
1339                 try {
1340                     sleep(1, 0);
1341                 } catch(InterruptedException e) {
1342                 }
1343             }
1344             //Log.d(LOG_TAG, "MessageThread exiting.");
1345         }
1346     }
1347
1348     RenderScript(Context ctx) {
1349         mContextType = ContextType.NORMAL;
1350         if (ctx != null) {
1351             mApplicationContext = ctx.getApplicationContext();
1352         }
1353         mRWLock = new ReentrantReadWriteLock();
1354         try {
1355             registerNativeAllocation.invoke(sRuntime, 4 * 1024 * 1024); // 4MB for GC sake
1356         } catch (Exception e) {
1357             Log.e(RenderScript.LOG_TAG, "Couldn't invoke registerNativeAllocation:" + e);
1358             throw new RSRuntimeException("Couldn't invoke registerNativeAllocation:" + e);
1359         }
1360
1361     }
1362
1363     /**
1364      * Gets the application context associated with the RenderScript context.
1365      *
1366      * @return The application context.
1367      */
1368     public final Context getApplicationContext() {
1369         return mApplicationContext;
1370     }
1371
1372     /**
1373      * Create a RenderScript context.
1374      *
1375      * @param ctx The context.
1376      * @return RenderScript
1377      */
1378     private static RenderScript internalCreate(Context ctx, int sdkVersion, ContextType ct, int flags) {
1379         if (!sInitialized) {
1380             Log.e(LOG_TAG, "RenderScript.create() called when disabled; someone is likely to crash");
1381             return null;
1382         }
1383
1384         if ((flags & ~(CREATE_FLAG_LOW_LATENCY | CREATE_FLAG_LOW_POWER |
1385                        CREATE_FLAG_WAIT_FOR_ATTACH | CREATE_FLAG_OPT_LEVEL_0)) != 0) {
1386             throw new RSIllegalArgumentException("Invalid flags passed.");
1387         }
1388
1389         RenderScript rs = new RenderScript(ctx);
1390
1391         rs.mDev = rs.nDeviceCreate();
1392         rs.mContext = rs.nContextCreate(rs.mDev, flags, sdkVersion, ct.mID);
1393         rs.mContextType = ct;
1394         rs.mContextFlags = flags;
1395         rs.mContextSdkVersion = sdkVersion;
1396         if (rs.mContext == 0) {
1397             throw new RSDriverException("Failed to create RS context.");
1398         }
1399
1400         // set up cache directory for entire context
1401         final String CACHE_PATH = "com.android.renderscript.cache";
1402         File f = new File(RenderScriptCacheDir.mCacheDir, CACHE_PATH);
1403         String mCachePath = f.getAbsolutePath();
1404         f.mkdirs();
1405         rs.nContextSetCacheDir(mCachePath);
1406
1407         rs.mMessageThread = new MessageThread(rs);
1408         rs.mMessageThread.start();
1409         return rs;
1410     }
1411
1412     /**
1413      * calls create(ctx, ContextType.NORMAL, CREATE_FLAG_NONE)
1414      *
1415      * See documentation for @create for details
1416      *
1417      * @param ctx The context.
1418      * @return RenderScript
1419      */
1420     public static RenderScript create(Context ctx) {
1421         return create(ctx, ContextType.NORMAL);
1422     }
1423
1424     /**
1425      * calls create(ctx, ct, CREATE_FLAG_NONE)
1426      *
1427      * See documentation for @create for details
1428      *
1429      * @param ctx The context.
1430      * @param ct The type of context to be created.
1431      * @return RenderScript
1432      */
1433     public static RenderScript create(Context ctx, ContextType ct) {
1434         return create(ctx, ct, CREATE_FLAG_NONE);
1435     }
1436
1437
1438     /**
1439      * Gets or creates a RenderScript context of the specified type.
1440      *
1441      * The returned context will be cached for future reuse within
1442      * the process. When an application is finished using
1443      * RenderScript it should call releaseAllContexts()
1444      *
1445      * A process context is a context designed for easy creation and
1446      * lifecycle management.  Multiple calls to this function will
1447      * return the same object provided they are called with the same
1448      * options.  This allows it to be used any time a RenderScript
1449      * context is needed.
1450      *
1451      * Prior to API 23 this always created a new context.
1452      *
1453      * @param ctx The context.
1454      * @param ct The type of context to be created.
1455      * @param flags The OR of the CREATE_FLAG_* options desired
1456      * @return RenderScript
1457      */
1458     public static RenderScript create(Context ctx, ContextType ct, int flags) {
1459         int v = ctx.getApplicationInfo().targetSdkVersion;
1460         return create(ctx, v, ct, flags);
1461     }
1462
1463     /**
1464      * calls create(ctx, sdkVersion, ContextType.NORMAL, CREATE_FLAG_NONE)
1465      *
1466      * Used by the RenderScriptThunker to maintain backward compatibility.
1467      *
1468      * @hide
1469      * @param ctx The context.
1470      * @param sdkVersion The target SDK Version.
1471      * @return RenderScript
1472      */
1473     public static RenderScript create(Context ctx, int sdkVersion) {
1474         return create(ctx, sdkVersion, ContextType.NORMAL, CREATE_FLAG_NONE);
1475     }
1476
1477      /**
1478      * Gets or creates a RenderScript context of the specified type.
1479      *
1480      * @param ctx The context.
1481      * @param ct The type of context to be created.
1482      * @param sdkVersion The target SDK Version.
1483      * @param flags The OR of the CREATE_FLAG_* options desired
1484      * @return RenderScript
1485      */
1486     private static RenderScript create(Context ctx, int sdkVersion, ContextType ct, int flags) {
1487         if (sdkVersion < 23) {
1488             return internalCreate(ctx, sdkVersion, ct, flags);
1489         }
1490
1491         synchronized (mProcessContextList) {
1492             for (RenderScript prs : mProcessContextList) {
1493                 if ((prs.mContextType == ct) &&
1494                     (prs.mContextFlags == flags) &&
1495                     (prs.mContextSdkVersion == sdkVersion)) {
1496
1497                     return prs;
1498                 }
1499             }
1500
1501             RenderScript prs = internalCreate(ctx, sdkVersion, ct, flags);
1502             prs.mIsProcessContext = true;
1503             mProcessContextList.add(prs);
1504             return prs;
1505         }
1506     }
1507
1508     /**
1509      * Releases all the process contexts.  This is the same as
1510      * calling .destroy() on each unique context retreived with
1511      * create(...). If no contexts have been created this
1512      * function does nothing.
1513      *
1514      * Typically you call this when your application is losing focus
1515      * and will not be using a context for some time.
1516      *
1517      * This has no effect on a context created with
1518      * createMultiContext()
1519      */
1520     public static void releaseAllContexts() {
1521         ArrayList<RenderScript> oldList;
1522         synchronized (mProcessContextList) {
1523             oldList = mProcessContextList;
1524             mProcessContextList = new ArrayList<RenderScript>();
1525         }
1526
1527         for (RenderScript prs : oldList) {
1528             prs.mIsProcessContext = false;
1529             prs.destroy();
1530         }
1531         oldList.clear();
1532     }
1533
1534
1535
1536     /**
1537      * Create a RenderScript context.
1538      *
1539      * This is an advanced function intended for applications which
1540      * need to create more than one RenderScript context to be used
1541      * at the same time.
1542      *
1543      * If you need a single context please use create()
1544      *
1545      * @param ctx The context.
1546      * @return RenderScript
1547      */
1548     public static RenderScript createMultiContext(Context ctx, ContextType ct, int flags, int API_number) {
1549         return internalCreate(ctx, API_number, ct, flags);
1550     }
1551
1552
1553     /**
1554      * Print the currently available debugging information about the state of
1555      * the RS context to the log.
1556      *
1557      */
1558     public void contextDump() {
1559         validate();
1560         nContextDump(0);
1561     }
1562
1563     /**
1564      * Wait for any pending asynchronous opeations (such as copies to a RS
1565      * allocation or RS script executions) to complete.
1566      *
1567      */
1568     public void finish() {
1569         nContextFinish();
1570     }
1571
1572     private void helpDestroy() {
1573         boolean shouldDestroy = false;
1574         synchronized(this) {
1575             if (!mDestroyed) {
1576                 shouldDestroy = true;
1577                 mDestroyed = true;
1578             }
1579         }
1580
1581         if (shouldDestroy) {
1582             nContextFinish();
1583
1584             nContextDeinitToClient(mContext);
1585             mMessageThread.mRun = false;
1586             try {
1587                 mMessageThread.join();
1588             } catch(InterruptedException e) {
1589             }
1590
1591             nContextDestroy();
1592
1593             nDeviceDestroy(mDev);
1594             mDev = 0;
1595         }
1596     }
1597
1598     protected void finalize() throws Throwable {
1599         helpDestroy();
1600         super.finalize();
1601     }
1602
1603
1604     /**
1605      * Destroys this RenderScript context.  Once this function is called,
1606      * using this context or any objects belonging to this context is
1607      * illegal.
1608      *
1609      * API 23+, this function is a NOP if the context was created
1610      * with create().  Please use releaseAllContexts() to clean up
1611      * contexts created with the create function.
1612      *
1613      */
1614     public void destroy() {
1615         if (mIsProcessContext) {
1616             // users cannot destroy a process context
1617             return;
1618         }
1619         validate();
1620         helpDestroy();
1621     }
1622
1623     boolean isAlive() {
1624         return mContext != 0;
1625     }
1626
1627     long safeID(BaseObj o) {
1628         if(o != null) {
1629             return o.getID(this);
1630         }
1631         return 0;
1632     }
1633 }