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 
13 class SkBitmapRegionDecoder;
14 class SkCanvas;
15 
16 namespace android {
17 class Paint;
18 class TypefaceImpl;
19 }
20 
21 class GraphicsJNI {
22 public:
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 
111 class AndroidPixelRef : public SkMallocPixelRef {
112 public:
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 private:
127     AndroidPixelRef* const fWrappedPixelRef; // if set, delegate memory management calls to this
128 
129     JavaVM* fVM;
130     jbyteArray fStorageObj; // The Java byte[] object used as the bitmap backing store
131 };
132 
133 /** Allocator which allocates the backing buffer in the Java heap.
134  *  Instances can only be used to perform a single allocation, which helps
135  *  ensure that the allocated buffer is properly accounted for with a
136  *  reference in the heap (or a JNI global reference).
137  */
138 class JavaPixelAllocator : public SkBitmap::Allocator {
139 public:
140     JavaPixelAllocator(JNIEnv* env);
141     // overrides
142     virtual bool allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable);
143 
144     /** Return the Java array object created for the last allocation.
145      *  This returns a local JNI reference which the caller is responsible
146      *  for storing appropriately (usually by passing it to the Bitmap
147      *  constructor).
148      */
getStorageObj()149     jbyteArray getStorageObj() { return fStorageObj; }
150 
151     /** Same as getStorageObj(), but also resets the allocator so that it
152      *  can allocate again.
153      */
getStorageObjAndReset()154     jbyteArray getStorageObjAndReset() {
155         jbyteArray result = fStorageObj;
156         fStorageObj = NULL;
157         fAllocCount = 0;
158         return result;
159     };
160 
161 private:
162     JavaVM* fVM;
163     bool fAllocateInJavaHeap;
164     jbyteArray fStorageObj;
165     int fAllocCount;
166 };
167 
168 enum JNIAccess {
169     kRO_JNIAccess,
170     kRW_JNIAccess
171 };
172 
173 class AutoJavaFloatArray {
174 public:
175     AutoJavaFloatArray(JNIEnv* env, jfloatArray array,
176                        int minLength = 0, JNIAccess = kRW_JNIAccess);
177     ~AutoJavaFloatArray();
178 
ptr()179     float* ptr() const { return fPtr; }
length()180     int    length() const { return fLen; }
181 
182 private:
183     JNIEnv*     fEnv;
184     jfloatArray fArray;
185     float*      fPtr;
186     int         fLen;
187     int         fReleaseMode;
188 };
189 
190 class AutoJavaIntArray {
191 public:
192     AutoJavaIntArray(JNIEnv* env, jintArray array, int minLength = 0);
193     ~AutoJavaIntArray();
194 
ptr()195     jint* ptr() const { return fPtr; }
length()196     int    length() const { return fLen; }
197 
198 private:
199     JNIEnv*     fEnv;
200     jintArray fArray;
201     jint*      fPtr;
202     int         fLen;
203 };
204 
205 class AutoJavaShortArray {
206 public:
207     AutoJavaShortArray(JNIEnv* env, jshortArray array,
208                        int minLength = 0, JNIAccess = kRW_JNIAccess);
209     ~AutoJavaShortArray();
210 
ptr()211     jshort* ptr() const { return fPtr; }
length()212     int    length() const { return fLen; }
213 
214 private:
215     JNIEnv*     fEnv;
216     jshortArray fArray;
217     jshort*      fPtr;
218     int         fLen;
219     int         fReleaseMode;
220 };
221 
222 class AutoJavaByteArray {
223 public:
224     AutoJavaByteArray(JNIEnv* env, jbyteArray array, int minLength = 0);
225     ~AutoJavaByteArray();
226 
ptr()227     jbyte* ptr() const { return fPtr; }
length()228     int    length() const { return fLen; }
229 
230 private:
231     JNIEnv*     fEnv;
232     jbyteArray fArray;
233     jbyte*      fPtr;
234     int         fLen;
235 };
236 
237 void doThrowNPE(JNIEnv* env);
238 void doThrowAIOOBE(JNIEnv* env); // Array Index Out Of Bounds Exception
239 void doThrowIAE(JNIEnv* env, const char* msg = NULL);   // Illegal Argument
240 void doThrowRE(JNIEnv* env, const char* msg = NULL);   // Runtime
241 void doThrowISE(JNIEnv* env, const char* msg = NULL);   // Illegal State
242 void doThrowOOME(JNIEnv* env, const char* msg = NULL);   // Out of memory
243 void doThrowIOE(JNIEnv* env, const char* msg = NULL);   // IO Exception
244 
245 #define NPE_CHECK_RETURN_ZERO(env, object)    \
246     do { if (NULL == (object)) { doThrowNPE(env); return 0; } } while (0)
247 
248 #define NPE_CHECK_RETURN_VOID(env, object)    \
249     do { if (NULL == (object)) { doThrowNPE(env); return; } } while (0)
250 
251 #endif
252