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