Home | History | Annotate | Download | only in graphics 
      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      */
    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     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 
    179     float* ptr() const { return fPtr; }
    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 
    195     jint* ptr() const { return fPtr; }
    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 
    211     jshort* ptr() const { return fPtr; }
    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 
    227     jbyte* ptr() const { return fPtr; }
    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