GraphicsJNI.h revision 340ce75b446f6a6afc12b0582be3fc34ac3a5364 
1#ifndef GraphicsJNI_DEFINED
2#define GraphicsJNI_DEFINED
3
4#include "SkPoint.h"
5#include "SkRect.h"
6#include "SkBitmap.h"
7#include "../images/SkLargeBitmap.h"
8#include "../images/SkImageDecoder.h"
9#include <jni.h>
10
11class SkCanvas;
12class SkPaint;
13class SkPicture;
14
15class GraphicsJNI {
16public:
17    // returns true if an exception is set (and dumps it out to the Log)
18    static bool hasException(JNIEnv*);
19
20    static void get_jrect(JNIEnv*, jobject jrect, int* L, int* T, int* R, int* B);
21    static void set_jrect(JNIEnv*, jobject jrect, int L, int T, int R, int B);
22
23    static SkIRect* jrect_to_irect(JNIEnv*, jobject jrect, SkIRect*);
24    static void irect_to_jrect(const SkIRect&, JNIEnv*, jobject jrect);
25
26    static SkRect* jrectf_to_rect(JNIEnv*, jobject jrectf, SkRect*);
27    static SkRect* jrect_to_rect(JNIEnv*, jobject jrect, SkRect*);
28    static void rect_to_jrectf(const SkRect&, JNIEnv*, jobject jrectf);
29
30    static void set_jpoint(JNIEnv*, jobject jrect, int x, int y);
31
32    static SkIPoint* jpoint_to_ipoint(JNIEnv*, jobject jpoint, SkIPoint* point);
33    static void ipoint_to_jpoint(const SkIPoint& point, JNIEnv*, jobject jpoint);
34
35    static SkPoint* jpointf_to_point(JNIEnv*, jobject jpointf, SkPoint* point);
36    static void point_to_jpointf(const SkPoint& point, JNIEnv*, jobject jpointf);
37
38    static SkCanvas* getNativeCanvas(JNIEnv*, jobject canvas);
39    static SkPaint*  getNativePaint(JNIEnv*, jobject paint);
40    static SkBitmap* getNativeBitmap(JNIEnv*, jobject bitmap);
41    static SkPicture* getNativePicture(JNIEnv*, jobject picture);
42    static SkRegion* getNativeRegion(JNIEnv*, jobject region);
43
44    /** Return the corresponding native config from the java Config enum,
45        or kNo_Config if the java object is null.
46    */
47    static SkBitmap::Config getNativeBitmapConfig(JNIEnv*, jobject jconfig);
48
49    /** Create a java Bitmap object given the native bitmap (required) and optional
50        storage array (may be null). If storage is specified, then it must already be
51        locked, and its native address set as the bitmap's pixels. If storage is null,
52        then the bitmap must be an owner of its natively allocated pixels (via allocPixels).
53        */
54    static jobject createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable,
55                                jbyteArray ninePatch, int density = -1);
56
57    static jobject createRegion(JNIEnv* env, SkRegion* region);
58
59    static jobject createLargeBitmap(JNIEnv* env, SkLargeBitmap* bitmap);
60
61    /** Set a pixelref for the bitmap (needs setConfig to already be called)
62        Returns true on success. If it returns false, then it failed, and the
63        appropriate exception will have been raised.
64    */
65    static bool setJavaPixelRef(JNIEnv*, SkBitmap*, SkColorTable* ctable,
66                                bool reportSizeToVM);
67
68    /** Copy the colors in colors[] to the bitmap, convert to the correct
69        format along the way.
70    */
71    static bool SetPixels(JNIEnv* env, jintArray colors, int srcOffset,
72                          int srcStride, int x, int y, int width, int height,
73                          const SkBitmap& dstBitmap);
74};
75
76class JavaPixelAllocator : public SkBitmap::Allocator {
77public:
78    JavaPixelAllocator(JNIEnv* env, bool reportSizeToVM);
79    // overrides
80    virtual bool allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable);
81
82private:
83    JavaVM* fVM;
84    bool fReportSizeToVM;
85};
86
87class JavaMemoryUsageReporter : public SkVMMemoryReporter {
88public:
89    JavaMemoryUsageReporter(JNIEnv* env);
90    virtual ~JavaMemoryUsageReporter();
91    // overrides
92    virtual bool reportMemory(size_t memorySize);
93
94private:
95    JavaVM* fVM;
96    size_t fTotalSize;
97};
98
99enum JNIAccess {
100    kRO_JNIAccess,
101    kRW_JNIAccess
102};
103
104class AutoJavaFloatArray {
105public:
106    AutoJavaFloatArray(JNIEnv* env, jfloatArray array,
107                       int minLength = 0, JNIAccess = kRW_JNIAccess);
108    ~AutoJavaFloatArray();
109
110    float* ptr() const { return fPtr; }
111    int    length() const { return fLen; }
112
113private:
114    JNIEnv*     fEnv;
115    jfloatArray fArray;
116    float*      fPtr;
117    int         fLen;
118    int         fReleaseMode;
119};
120
121class AutoJavaIntArray {
122public:
123    AutoJavaIntArray(JNIEnv* env, jintArray array, int minLength = 0);
124    ~AutoJavaIntArray();
125
126    jint* ptr() const { return fPtr; }
127    int    length() const { return fLen; }
128
129private:
130    JNIEnv*     fEnv;
131    jintArray fArray;
132    jint*      fPtr;
133    int         fLen;
134};
135
136class AutoJavaShortArray {
137public:
138    AutoJavaShortArray(JNIEnv* env, jshortArray array,
139                       int minLength = 0, JNIAccess = kRW_JNIAccess);
140    ~AutoJavaShortArray();
141
142    jshort* ptr() const { return fPtr; }
143    int    length() const { return fLen; }
144
145private:
146    JNIEnv*     fEnv;
147    jshortArray fArray;
148    jshort*      fPtr;
149    int         fLen;
150    int         fReleaseMode;
151};
152
153class AutoJavaByteArray {
154public:
155    AutoJavaByteArray(JNIEnv* env, jbyteArray array, int minLength = 0);
156    ~AutoJavaByteArray();
157
158    jbyte* ptr() const { return fPtr; }
159    int    length() const { return fLen; }
160
161private:
162    JNIEnv*     fEnv;
163    jbyteArray fArray;
164    jbyte*      fPtr;
165    int         fLen;
166};
167
168void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL);
169void doThrowNPE(JNIEnv* env);
170void doThrowAIOOBE(JNIEnv* env); // Array Index Out Of Bounds Exception
171void doThrowIAE(JNIEnv* env, const char* msg = NULL);   // Illegal Argument
172void doThrowRE(JNIEnv* env, const char* msg = NULL);   // Runtime
173void doThrowISE(JNIEnv* env, const char* msg = NULL);   // Illegal State
174void doThrowOOME(JNIEnv* env, const char* msg = NULL);   // Out of memory
175void doThrowIOE(JNIEnv* env, const char* msg = NULL);   // IO Exception
176
177#define NPE_CHECK_RETURN_ZERO(env, object)    \
178    do { if (NULL == (object)) { doThrowNPE(env); return 0; } } while (0)
179
180#define NPE_CHECK_RETURN_VOID(env, object)    \
181    do { if (NULL == (object)) { doThrowNPE(env); return; } } while (0)
182
183#endif
184
185