GraphicsJNI.h revision 5827cb5059ed0eec4c73adf1acbd7ee47b2c5c8f
1#ifndef GraphicsJNI_DEFINED 2#define GraphicsJNI_DEFINED 3 4#include "SkBitmap.h" 5#include "SkDevice.h" 6#include "SkPixelRef.h" 7#include "SkMallocPixelRef.h" 8#include "SkPoint.h" 9#include "SkRect.h" 10#include "SkImageDecoder.h" 11#include <jni.h> 12 13class SkBitmapRegionDecoder; 14class SkCanvas; 15class SkPaint; 16class SkPicture; 17 18class GraphicsJNI { 19public: 20 // returns true if an exception is set (and dumps it out to the Log) 21 static bool hasException(JNIEnv*); 22 23 static void get_jrect(JNIEnv*, jobject jrect, int* L, int* T, int* R, int* B); 24 static void set_jrect(JNIEnv*, jobject jrect, int L, int T, int R, int B); 25 26 static SkIRect* jrect_to_irect(JNIEnv*, jobject jrect, SkIRect*); 27 static void irect_to_jrect(const SkIRect&, JNIEnv*, jobject jrect); 28 29 static SkRect* jrectf_to_rect(JNIEnv*, jobject jrectf, SkRect*); 30 static SkRect* jrect_to_rect(JNIEnv*, jobject jrect, SkRect*); 31 static void rect_to_jrectf(const SkRect&, JNIEnv*, jobject jrectf); 32 33 static void set_jpoint(JNIEnv*, jobject jrect, int x, int y); 34 35 static SkIPoint* jpoint_to_ipoint(JNIEnv*, jobject jpoint, SkIPoint* point); 36 static void ipoint_to_jpoint(const SkIPoint& point, JNIEnv*, jobject jpoint); 37 38 static SkPoint* jpointf_to_point(JNIEnv*, jobject jpointf, SkPoint* point); 39 static void point_to_jpointf(const SkPoint& point, JNIEnv*, jobject jpointf); 40 41 static SkCanvas* getNativeCanvas(JNIEnv*, jobject canvas); 42 static SkPaint* getNativePaint(JNIEnv*, jobject paint); 43 static SkBitmap* getNativeBitmap(JNIEnv*, jobject bitmap); 44 static SkPicture* getNativePicture(JNIEnv*, jobject picture); 45 static SkRegion* getNativeRegion(JNIEnv*, jobject region); 46 47 /** Return the corresponding native config from the java Config enum, 48 or kNo_Config if the java object is null. 49 */ 50 static SkBitmap::Config getNativeBitmapConfig(JNIEnv*, jobject jconfig); 51 52 /** Create a java Bitmap object given the native bitmap (required) and optional 53 storage array (may be null). 54 */ 55 static jobject createBitmap(JNIEnv* env, SkBitmap* bitmap, jbyteArray buffer, 56 bool isMutable, jbyteArray ninepatch, jintArray layoutbounds, 57 int density = -1); 58 59 static jobject createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable, 60 jbyteArray ninepatch, int density = -1); 61 62 static void reinitBitmap(JNIEnv* env, jobject javaBitmap); 63 64 static int getBitmapAllocationByteCount(JNIEnv* env, jobject javaBitmap); 65 66 static jobject createRegion(JNIEnv* env, SkRegion* region); 67 68 static jobject createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap); 69 70 static jbyteArray allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap, 71 SkColorTable* ctable); 72 73 /** Copy the colors in colors[] to the bitmap, convert to the correct 74 format along the way. 75 */ 76 static bool SetPixels(JNIEnv* env, jintArray colors, int srcOffset, 77 int srcStride, int x, int y, int width, int height, 78 const SkBitmap& dstBitmap); 79 80 static jbyteArray getBitmapStorageObj(SkPixelRef *pixref); 81}; 82 83class AndroidPixelRef : public SkMallocPixelRef { 84public: 85 AndroidPixelRef(JNIEnv* env, void* storage, size_t size, jbyteArray storageObj, 86 SkColorTable* ctable); 87 88 virtual ~AndroidPixelRef(); 89 90 jbyteArray getStorageObj() { return fStorageObj; } 91 92 void setLocalJNIRef(jbyteArray arr); 93 94 /** Used to hold a ref to the pixels when the Java bitmap may be collected. 95 * If specified, 'localref' is a valid JNI local reference to the byte array 96 * containing the pixel data. 97 * 98 * 'localref' may only be NULL if setLocalJNIRef() was already called with 99 * a JNI local ref that is still valid. 100 */ 101 virtual void globalRef(void* localref=NULL); 102 103 /** Release a ref that was acquired using globalRef(). */ 104 virtual void globalUnref(); 105 106private: 107 JavaVM* fVM; 108 bool fOnJavaHeap; // If true, the memory was allocated on the Java heap 109 110 jbyteArray fStorageObj; // The Java byte[] object used as the bitmap backing store 111 bool fHasGlobalRef; // If true, fStorageObj holds a JNI global ref 112 113 mutable int32_t fGlobalRefCnt; 114}; 115 116/** A helper class for accessing Java-heap-allocated bitmaps. 117 * This should be used when calling into a JNI method that retains a 118 * reference to the bitmap longer than the lifetime of the Java Bitmap. 119 * 120 * After creating an instance of this class, a call to 121 * AndroidPixelRef::globalRef() will allocate a JNI global reference 122 * to the backing buffer object. 123 */ 124class JavaHeapBitmapRef { 125public: 126 127 JavaHeapBitmapRef(JNIEnv *env, SkBitmap* nativeBitmap, jbyteArray buffer); 128 ~JavaHeapBitmapRef(); 129 130private: 131 JNIEnv* fEnv; 132 SkBitmap* fNativeBitmap; 133 jbyteArray fBuffer; 134}; 135 136/** Allocator which allocates the backing buffer in the Java heap. 137 * Instances can only be used to perform a single allocation, which helps 138 * ensure that the allocated buffer is properly accounted for with a 139 * reference in the heap (or a JNI global reference). 140 */ 141class JavaPixelAllocator : public SkBitmap::Allocator { 142public: 143 JavaPixelAllocator(JNIEnv* env); 144 // overrides 145 virtual bool allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable); 146 147 /** Return the Java array object created for the last allocation. 148 * This returns a local JNI reference which the caller is responsible 149 * for storing appropriately (usually by passing it to the Bitmap 150 * constructor). 151 */ 152 jbyteArray getStorageObj() { return fStorageObj; } 153 154 /** Same as getStorageObj(), but also resets the allocator so that it 155 * can allocate again. 156 */ 157 jbyteArray getStorageObjAndReset() { 158 jbyteArray result = fStorageObj; 159 fStorageObj = NULL; 160 fAllocCount = 0; 161 return result; 162 }; 163 164private: 165 JavaVM* fVM; 166 bool fAllocateInJavaHeap; 167 jbyteArray fStorageObj; 168 int fAllocCount; 169}; 170 171enum JNIAccess { 172 kRO_JNIAccess, 173 kRW_JNIAccess 174}; 175 176class AutoJavaFloatArray { 177public: 178 AutoJavaFloatArray(JNIEnv* env, jfloatArray array, 179 int minLength = 0, JNIAccess = kRW_JNIAccess); 180 ~AutoJavaFloatArray(); 181 182 float* ptr() const { return fPtr; } 183 int length() const { return fLen; } 184 185private: 186 JNIEnv* fEnv; 187 jfloatArray fArray; 188 float* fPtr; 189 int fLen; 190 int fReleaseMode; 191}; 192 193class AutoJavaIntArray { 194public: 195 AutoJavaIntArray(JNIEnv* env, jintArray array, int minLength = 0); 196 ~AutoJavaIntArray(); 197 198 jint* ptr() const { return fPtr; } 199 int length() const { return fLen; } 200 201private: 202 JNIEnv* fEnv; 203 jintArray fArray; 204 jint* fPtr; 205 int fLen; 206}; 207 208class AutoJavaShortArray { 209public: 210 AutoJavaShortArray(JNIEnv* env, jshortArray array, 211 int minLength = 0, JNIAccess = kRW_JNIAccess); 212 ~AutoJavaShortArray(); 213 214 jshort* ptr() const { return fPtr; } 215 int length() const { return fLen; } 216 217private: 218 JNIEnv* fEnv; 219 jshortArray fArray; 220 jshort* fPtr; 221 int fLen; 222 int fReleaseMode; 223}; 224 225class AutoJavaByteArray { 226public: 227 AutoJavaByteArray(JNIEnv* env, jbyteArray array, int minLength = 0); 228 ~AutoJavaByteArray(); 229 230 jbyte* ptr() const { return fPtr; } 231 int length() const { return fLen; } 232 233private: 234 JNIEnv* fEnv; 235 jbyteArray fArray; 236 jbyte* fPtr; 237 int fLen; 238}; 239 240void doThrowNPE(JNIEnv* env); 241void doThrowAIOOBE(JNIEnv* env); // Array Index Out Of Bounds Exception 242void doThrowIAE(JNIEnv* env, const char* msg = NULL); // Illegal Argument 243void doThrowRE(JNIEnv* env, const char* msg = NULL); // Runtime 244void doThrowISE(JNIEnv* env, const char* msg = NULL); // Illegal State 245void doThrowOOME(JNIEnv* env, const char* msg = NULL); // Out of memory 246void doThrowIOE(JNIEnv* env, const char* msg = NULL); // IO Exception 247 248#define NPE_CHECK_RETURN_ZERO(env, object) \ 249 do { if (NULL == (object)) { doThrowNPE(env); return 0; } } while (0) 250 251#define NPE_CHECK_RETURN_VOID(env, object) \ 252 do { if (NULL == (object)) { doThrowNPE(env); return; } } while (0) 253 254#endif 255