core/jni/android/graphics/GraphicsJNI.h

   1 #ifndef _ANDROID_GRAPHICS_GRAPHICS_JNI_H_
   2 #define _ANDROID_GRAPHICS_GRAPHICS_JNI_H_
   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 struct 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      */
 149     jbyteArray getStorageObj() { return fStorageObj; }
 150
 151     /** Same as getStorageObj(), but also resets the allocator so that it
 152      *  can allocate again.
 153      */
 154     jbyteArray getStorageObjAndReset() {
 155         jbyteArray result = fStorageObj;
 156         fStorageObj = NULL;
 157         fAllocCount = 0;
 158         return result;
 159     };
 160
 161 private:
 162     JavaVM* fVM;
 163     jbyteArray fStorageObj;
 164     int fAllocCount;
 165 };
 166
 167 enum JNIAccess {
 168     kRO_JNIAccess,
 169     kRW_JNIAccess
 170 };
 171
 172 class AutoJavaFloatArray {
 173 public:
 174     AutoJavaFloatArray(JNIEnv* env, jfloatArray array,
 175                        int minLength = 0, JNIAccess = kRW_JNIAccess);
 176     ~AutoJavaFloatArray();
 177
 178     float* ptr() const { return fPtr; }
 179     int    length() const { return fLen; }
 180
 181 private:
 182     JNIEnv*     fEnv;
 183     jfloatArray fArray;
 184     float*      fPtr;
 185     int         fLen;
 186     int         fReleaseMode;
 187 };
 188
 189 class AutoJavaIntArray {
 190 public:
 191     AutoJavaIntArray(JNIEnv* env, jintArray array, int minLength = 0);
 192     ~AutoJavaIntArray();
 193
 194     jint* ptr() const { return fPtr; }
 195     int    length() const { return fLen; }
 196
 197 private:
 198     JNIEnv*     fEnv;
 199     jintArray fArray;
 200     jint*      fPtr;
 201     int         fLen;
 202 };
 203
 204 class AutoJavaShortArray {
 205 public:
 206     AutoJavaShortArray(JNIEnv* env, jshortArray array,
 207                        int minLength = 0, JNIAccess = kRW_JNIAccess);
 208     ~AutoJavaShortArray();
 209
 210     jshort* ptr() const { return fPtr; }
 211     int    length() const { return fLen; }
 212
 213 private:
 214     JNIEnv*     fEnv;
 215     jshortArray fArray;
 216     jshort*      fPtr;
 217     int         fLen;
 218     int         fReleaseMode;
 219 };
 220
 221 class AutoJavaByteArray {
 222 public:
 223     AutoJavaByteArray(JNIEnv* env, jbyteArray array, int minLength = 0);
 224     ~AutoJavaByteArray();
 225
 226     jbyte* ptr() const { return fPtr; }
 227     int    length() const { return fLen; }
 228
 229 private:
 230     JNIEnv*     fEnv;
 231     jbyteArray fArray;
 232     jbyte*      fPtr;
 233     int         fLen;
 234 };
 235
 236 void doThrowNPE(JNIEnv* env);
 237 void doThrowAIOOBE(JNIEnv* env); // Array Index Out Of Bounds Exception
 238 void doThrowIAE(JNIEnv* env, const char* msg = NULL);   // Illegal Argument
 239 void doThrowRE(JNIEnv* env, const char* msg = NULL);   // Runtime
 240 void doThrowISE(JNIEnv* env, const char* msg = NULL);   // Illegal State
 241 void doThrowOOME(JNIEnv* env, const char* msg = NULL);   // Out of memory
 242 void doThrowIOE(JNIEnv* env, const char* msg = NULL);   // IO Exception
 243
 244 #define NPE_CHECK_RETURN_ZERO(env, object)    \
 245     do { if (NULL == (object)) { doThrowNPE(env); return 0; } } while (0)
 246
 247 #define NPE_CHECK_RETURN_VOID(env, object)    \
 248     do { if (NULL == (object)) { doThrowNPE(env); return; } } while (0)
 249
 250 #endif  // _ANDROID_GRAPHICS_GRAPHICS_JNI_H_