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