GraphicsJNI.h revision 9f58361e98be7386a4eadd3aa254e9b7d09d0a3b 
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 "../images/SkBitmapRegionDecoder.h"
11#include "../images/SkImageDecoder.h"
12#include <jni.h>
13
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