| #include "SkBitmap.h"
|
| #include "SkPixelRef.h"
|
| #include "SkImageEncoder.h"
|
| #include "SkColorPriv.h"
|
| #include "GraphicsJNI.h"
|
| #include "SkDither.h"
|
| #include "SkUnPreMultiply.h"
|
|
|
| #include <binder/Parcel.h>
|
| #include "android_os_Parcel.h" |
| #include "android_util_Binder.h"
|
| #include "android_nio_utils.h"
|
| #include "CreateJavaOutputStreamAdaptor.h"
|
|
|
| #include <jni.h>
|
|
|
| #include <Caches.h>
|
|
|
| #if 0
|
| #define TRACE_BITMAP(code) code
|
| #else
|
| #define TRACE_BITMAP(code)
|
| #endif
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
| // Conversions to/from SkColor, for get/setPixels, and the create method, which
|
| // is basically like setPixels
|
|
|
| typedef void (*FromColorProc)(void* dst, const SkColor src[], int width,
|
| int x, int y);
|
|
|
| static void FromColor_D32(void* dst, const SkColor src[], int width,
|
| int, int) {
|
| SkPMColor* d = (SkPMColor*)dst;
|
|
|
| for (int i = 0; i < width; i++) {
|
| *d++ = SkPreMultiplyColor(*src++);
|
| }
|
| }
|
|
|
| static void FromColor_D565(void* dst, const SkColor src[], int width,
|
| int x, int y) {
|
| uint16_t* d = (uint16_t*)dst;
|
|
|
| DITHER_565_SCAN(y);
|
| for (int stop = x + width; x < stop; x++) {
|
| SkColor c = *src++;
|
| *d++ = SkDitherRGBTo565(SkColorGetR(c), SkColorGetG(c), SkColorGetB(c),
|
| DITHER_VALUE(x));
|
| }
|
| }
|
|
|
| static void FromColor_D4444(void* dst, const SkColor src[], int width,
|
| int x, int y) {
|
| SkPMColor16* d = (SkPMColor16*)dst;
|
|
|
| DITHER_4444_SCAN(y);
|
| for (int stop = x + width; x < stop; x++) {
|
| SkPMColor c = SkPreMultiplyColor(*src++);
|
| *d++ = SkDitherARGB32To4444(c, DITHER_VALUE(x));
|
| // *d++ = SkPixel32ToPixel4444(c);
|
| }
|
| }
|
|
|
| // can return NULL
|
| static FromColorProc ChooseFromColorProc(SkBitmap::Config config) {
|
| switch (config) {
|
| case SkBitmap::kARGB_8888_Config:
|
| return FromColor_D32;
|
| case SkBitmap::kARGB_4444_Config:
|
| return FromColor_D4444;
|
| case SkBitmap::kRGB_565_Config:
|
| return FromColor_D565;
|
| default:
|
| break;
|
| }
|
| return NULL;
|
| }
|
|
|
| bool GraphicsJNI::SetPixels(JNIEnv* env, jintArray srcColors,
|
| int srcOffset, int srcStride,
|
| int x, int y, int width, int height,
|
| const SkBitmap& dstBitmap) {
|
| SkAutoLockPixels alp(dstBitmap);
|
| void* dst = dstBitmap.getPixels();
|
| FromColorProc proc = ChooseFromColorProc(dstBitmap.config());
|
|
|
| if (NULL == dst || NULL == proc) {
|
| return false;
|
| }
|
|
|
| const jint* array = env->GetIntArrayElements(srcColors, NULL);
|
| const SkColor* src = (const SkColor*)array + srcOffset;
|
|
|
| // reset to to actual choice from caller
|
| dst = dstBitmap.getAddr(x, y);
|
| // now copy/convert each scanline
|
| for (int y = 0; y < height; y++) {
|
| proc(dst, src, width, x, y);
|
| src += srcStride;
|
| dst = (char*)dst + dstBitmap.rowBytes();
|
| }
|
|
|
| dstBitmap.notifyPixelsChanged();
|
|
|
| env->ReleaseIntArrayElements(srcColors, const_cast<jint*>(array),
|
| JNI_ABORT);
|
| return true;
|
| }
|
|
|
| //////////////////// ToColor procs
|
|
|
| typedef void (*ToColorProc)(SkColor dst[], const void* src, int width,
|
| SkColorTable*);
|
|
|
| static void ToColor_S32_Alpha(SkColor dst[], const void* src, int width,
|
| SkColorTable*) {
|
| SkASSERT(width > 0);
|
| const SkPMColor* s = (const SkPMColor*)src;
|
| do {
|
| *dst++ = SkUnPreMultiply::PMColorToColor(*s++);
|
| } while (--width != 0);
|
| }
|
|
|
| static void ToColor_S32_Opaque(SkColor dst[], const void* src, int width,
|
| SkColorTable*) {
|
| SkASSERT(width > 0);
|
| const SkPMColor* s = (const SkPMColor*)src;
|
| do {
|
| SkPMColor c = *s++;
|
| *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c),
|
| SkGetPackedB32(c));
|
| } while (--width != 0);
|
| }
|
|
|
| static void ToColor_S4444_Alpha(SkColor dst[], const void* src, int width,
|
| SkColorTable*) {
|
| SkASSERT(width > 0);
|
| const SkPMColor16* s = (const SkPMColor16*)src;
|
| do {
|
| *dst++ = SkUnPreMultiply::PMColorToColor(SkPixel4444ToPixel32(*s++));
|
| } while (--width != 0);
|
| }
|
|
|
| static void ToColor_S4444_Opaque(SkColor dst[], const void* src, int width,
|
| SkColorTable*) {
|
| SkASSERT(width > 0);
|
| const SkPMColor* s = (const SkPMColor*)src;
|
| do {
|
| SkPMColor c = SkPixel4444ToPixel32(*s++);
|
| *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c),
|
| SkGetPackedB32(c));
|
| } while (--width != 0);
|
| }
|
|
|
| static void ToColor_S565(SkColor dst[], const void* src, int width,
|
| SkColorTable*) {
|
| SkASSERT(width > 0);
|
| const uint16_t* s = (const uint16_t*)src;
|
| do {
|
| uint16_t c = *s++;
|
| *dst++ = SkColorSetRGB(SkPacked16ToR32(c), SkPacked16ToG32(c),
|
| SkPacked16ToB32(c));
|
| } while (--width != 0);
|
| }
|
|
|
| static void ToColor_SI8_Alpha(SkColor dst[], const void* src, int width,
|
| SkColorTable* ctable) {
|
| SkASSERT(width > 0);
|
| const uint8_t* s = (const uint8_t*)src;
|
| const SkPMColor* colors = ctable->lockColors();
|
| do {
|
| *dst++ = SkUnPreMultiply::PMColorToColor(colors[*s++]);
|
| } while (--width != 0);
|
| ctable->unlockColors(false);
|
| }
|
|
|
| static void ToColor_SI8_Opaque(SkColor dst[], const void* src, int width,
|
| SkColorTable* ctable) {
|
| SkASSERT(width > 0);
|
| const uint8_t* s = (const uint8_t*)src;
|
| const SkPMColor* colors = ctable->lockColors();
|
| do {
|
| SkPMColor c = colors[*s++];
|
| *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c),
|
| SkGetPackedB32(c));
|
| } while (--width != 0);
|
| ctable->unlockColors(false);
|
| }
|
|
|
| // can return NULL
|
| static ToColorProc ChooseToColorProc(const SkBitmap& src) {
|
| switch (src.config()) {
|
| case SkBitmap::kARGB_8888_Config:
|
| return src.isOpaque() ? ToColor_S32_Opaque : ToColor_S32_Alpha;
|
| case SkBitmap::kARGB_4444_Config:
|
| return src.isOpaque() ? ToColor_S4444_Opaque : ToColor_S4444_Alpha;
|
| case SkBitmap::kRGB_565_Config:
|
| return ToColor_S565;
|
| case SkBitmap::kIndex8_Config:
|
| if (src.getColorTable() == NULL) {
|
| return NULL;
|
| }
|
| return src.isOpaque() ? ToColor_SI8_Opaque : ToColor_SI8_Alpha;
|
| default:
|
| break;
|
| }
|
| return NULL;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
| ///////////////////////////////////////////////////////////////////////////////
|
|
|
| static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,
|
| int offset, int stride, int width, int height,
|
| SkBitmap::Config config, jboolean isMutable) {
|
| if (NULL != jColors) {
|
| size_t n = env->GetArrayLength(jColors);
|
| if (n < SkAbs32(stride) * (size_t)height) {
|
| doThrowAIOOBE(env);
|
| return NULL;
|
| }
|
| }
|
|
|
| SkBitmap bitmap;
|
|
|
| bitmap.setConfig(config, width, height);
|
|
|
| jbyteArray buff = GraphicsJNI::allocateJavaPixelRef(env, &bitmap, NULL);
|
| if (NULL == buff) {
|
| return NULL;
|
| }
|
|
|
| if (jColors != NULL) {
|
| GraphicsJNI::SetPixels(env, jColors, offset, stride,
|
| 0, 0, width, height, bitmap);
|
| }
|
|
|
| return GraphicsJNI::createBitmap(env, new SkBitmap(bitmap), buff, isMutable, NULL);
|
| }
|
|
|
| static jobject Bitmap_copy(JNIEnv* env, jobject, const SkBitmap* src,
|
| SkBitmap::Config dstConfig, jboolean isMutable) {
|
| SkBitmap result;
|
| JavaPixelAllocator allocator(env);
|
|
|
| if (!src->copyTo(&result, dstConfig, &allocator)) {
|
| return NULL;
|
| }
|
|
|
| return GraphicsJNI::createBitmap(env, new SkBitmap(result), allocator.getStorageObj(), isMutable, NULL);
|
| }
|
|
|
| static void Bitmap_destructor(JNIEnv* env, jobject, SkBitmap* bitmap) {
|
| #ifdef USE_OPENGL_RENDERER
|
| if (android::uirenderer::Caches::hasInstance()) {
|
| android::uirenderer::Caches::getInstance().resourceCache.destructor(bitmap);
|
| return;
|
| }
|
| #endif // USE_OPENGL_RENDERER
|
| delete bitmap;
|
| }
|
|
|
| static void Bitmap_recycle(JNIEnv* env, jobject, SkBitmap* bitmap) {
|
| #ifdef USE_OPENGL_RENDERER
|
| if (android::uirenderer::Caches::hasInstance()) {
|
| android::uirenderer::Caches::getInstance().resourceCache.recycle(bitmap);
|
| return;
|
| }
|
| #endif // USE_OPENGL_RENDERER
|
| bitmap->setPixels(NULL, NULL);
|
| }
|
|
|
| // These must match the int values in Bitmap.java
|
| enum JavaEncodeFormat {
|
| kJPEG_JavaEncodeFormat = 0,
|
| kPNG_JavaEncodeFormat = 1,
|
| kWEBP_JavaEncodeFormat = 2
|
| };
|
|
|
| static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap,
|
| int format, int quality,
|
| jobject jstream, jbyteArray jstorage) {
|
| SkImageEncoder::Type fm;
|
|
|
| switch (format) {
|
| case kJPEG_JavaEncodeFormat:
|
| fm = SkImageEncoder::kJPEG_Type;
|
| break;
|
| case kPNG_JavaEncodeFormat:
|
| fm = SkImageEncoder::kPNG_Type;
|
| break;
|
| case kWEBP_JavaEncodeFormat:
|
| fm = SkImageEncoder::kWEBP_Type;
|
| break;
|
| default:
|
| return false;
|
| }
|
|
|
| bool success = false;
|
| SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
|
| if (NULL != strm) {
|
| SkImageEncoder* encoder = SkImageEncoder::Create(fm);
|
| if (NULL != encoder) {
|
| success = encoder->encodeStream(strm, *bitmap, quality);
|
| delete encoder;
|
| }
|
| delete strm;
|
| }
|
| return success;
|
| }
|
|
|
| static void Bitmap_erase(JNIEnv* env, jobject, SkBitmap* bitmap, jint color) {
|
| bitmap->eraseColor(color);
|
| }
|
|
|
| static int Bitmap_width(JNIEnv* env, jobject, SkBitmap* bitmap) {
|
| return bitmap->width();
|
| }
|
|
|
| static int Bitmap_height(JNIEnv* env, jobject, SkBitmap* bitmap) {
|
| return bitmap->height();
|
| }
|
|
|
| static int Bitmap_rowBytes(JNIEnv* env, jobject, SkBitmap* bitmap) {
|
| return bitmap->rowBytes();
|
| }
|
|
|
| static int Bitmap_config(JNIEnv* env, jobject, SkBitmap* bitmap) {
|
| return bitmap->config();
|
| }
|
|
|
| static int Bitmap_getGenerationId(JNIEnv* env, jobject, SkBitmap* bitmap) {
|
| return bitmap->getGenerationID();
|
| }
|
|
|
| static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, SkBitmap* bitmap) {
|
| return !bitmap->isOpaque();
|
| }
|
|
|
| static void Bitmap_setHasAlpha(JNIEnv* env, jobject, SkBitmap* bitmap,
|
| jboolean hasAlpha) {
|
| bitmap->setIsOpaque(!hasAlpha);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
|
|
| static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) {
|
| if (parcel == NULL) {
|
| SkDebugf("-------- unparcel parcel is NULL\n");
|
| return NULL;
|
| }
|
|
|
| android::Parcel* p = android::parcelForJavaObject(env, parcel);
|
|
|
| const bool isMutable = p->readInt32() != 0;
|
| const SkBitmap::Config config = (SkBitmap::Config)p->readInt32();
|
| const int width = p->readInt32();
|
| const int height = p->readInt32();
|
| const int rowBytes = p->readInt32();
|
| const int density = p->readInt32();
|
|
|
| if (SkBitmap::kARGB_8888_Config != config &&
|
| SkBitmap::kRGB_565_Config != config &&
|
| SkBitmap::kARGB_4444_Config != config &&
|
| SkBitmap::kIndex8_Config != config &&
|
| SkBitmap::kA8_Config != config) {
|
| SkDebugf("Bitmap_createFromParcel unknown config: %d\n", config);
|
| return NULL;
|
| }
|
|
|
| SkBitmap* bitmap = new SkBitmap;
|
|
|
| bitmap->setConfig(config, width, height, rowBytes);
|
|
|
| SkColorTable* ctable = NULL;
|
| if (config == SkBitmap::kIndex8_Config) {
|
| int count = p->readInt32();
|
| if (count > 0) {
|
| size_t size = count * sizeof(SkPMColor);
|
| const SkPMColor* src = (const SkPMColor*)p->readInplace(size);
|
| ctable = new SkColorTable(src, count);
|
| }
|
| }
|
|
|
| jbyteArray buffer = GraphicsJNI::allocateJavaPixelRef(env, bitmap, ctable);
|
| if (NULL == buffer) {
|
| SkSafeUnref(ctable);
|
| delete bitmap;
|
| return NULL;
|
| }
|
|
|
| SkSafeUnref(ctable);
|
|
|
| size_t size = bitmap->getSize();
|
|
|
| android::Parcel::ReadableBlob blob;
|
| android::status_t status = p->readBlob(size, &blob);
|
| if (status) {
|
| doThrowRE(env, "Could not read bitmap from parcel blob.");
|
| delete bitmap;
|
| return NULL;
|
| }
|
|
|
| bitmap->lockPixels();
|
| memcpy(bitmap->getPixels(), blob.data(), size);
|
| bitmap->unlockPixels();
|
|
|
| blob.release();
|
| return GraphicsJNI::createBitmap(env, bitmap, buffer, isMutable, NULL, density);
|
| }
|
|
|
| static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject,
|
| const SkBitmap* bitmap,
|
| jboolean isMutable, jint density,
|
| jobject parcel) {
|
| if (parcel == NULL) {
|
| SkDebugf("------- writeToParcel null parcel\n");
|
| return false;
|
| }
|
|
|
| android::Parcel* p = android::parcelForJavaObject(env, parcel);
|
|
|
| p->writeInt32(isMutable);
|
| p->writeInt32(bitmap->config());
|
| p->writeInt32(bitmap->width());
|
| p->writeInt32(bitmap->height());
|
| p->writeInt32(bitmap->rowBytes());
|
| p->writeInt32(density);
|
|
|
| if (bitmap->getConfig() == SkBitmap::kIndex8_Config) {
|
| SkColorTable* ctable = bitmap->getColorTable();
|
| if (ctable != NULL) {
|
| int count = ctable->count();
|
| p->writeInt32(count);
|
| memcpy(p->writeInplace(count * sizeof(SkPMColor)),
|
| ctable->lockColors(), count * sizeof(SkPMColor));
|
| ctable->unlockColors(false);
|
| } else {
|
| p->writeInt32(0); // indicate no ctable
|
| }
|
| }
|
|
|
| size_t size = bitmap->getSize();
|
|
|
| android::Parcel::WritableBlob blob;
|
| android::status_t status = p->writeBlob(size, &blob);
|
| if (status) {
|
| doThrowRE(env, "Could not write bitmap to parcel blob.");
|
| return false;
|
| }
|
|
|
| bitmap->lockPixels();
|
| const void* pSrc = bitmap->getPixels();
|
| if (pSrc == NULL) {
|
| memset(blob.data(), 0, size);
|
| } else {
|
| memcpy(blob.data(), pSrc, size);
|
| }
|
| bitmap->unlockPixels();
|
|
|
| blob.release();
|
| return true;
|
| }
|
|
|
| static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz,
|
| const SkBitmap* src, const SkPaint* paint,
|
| jintArray offsetXY) {
|
| SkIPoint offset;
|
| SkBitmap* dst = new SkBitmap;
|
| JavaPixelAllocator allocator(env);
|
|
|
| src->extractAlpha(dst, paint, &allocator, &offset);
|
| // If Skia can't allocate pixels for destination bitmap, it resets
|
| // it, that is set its pixels buffer to NULL, and zero width and height.
|
| if (dst->getPixels() == NULL && src->getPixels() != NULL) {
|
| delete dst;
|
| doThrowOOME(env, "failed to allocate pixels for alpha");
|
| return NULL;
|
| }
|
| if (offsetXY != 0 && env->GetArrayLength(offsetXY) >= 2) {
|
| int* array = env->GetIntArrayElements(offsetXY, NULL);
|
| array[0] = offset.fX;
|
| array[1] = offset.fY;
|
| env->ReleaseIntArrayElements(offsetXY, array, 0);
|
| }
|
|
|
| return GraphicsJNI::createBitmap(env, dst, allocator.getStorageObj(), true, NULL);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
|
|
| static int Bitmap_getPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,
|
| int x, int y) {
|
| SkAutoLockPixels alp(*bitmap);
|
|
|
| ToColorProc proc = ChooseToColorProc(*bitmap);
|
| if (NULL == proc) {
|
| return 0;
|
| }
|
| const void* src = bitmap->getAddr(x, y);
|
| if (NULL == src) {
|
| return 0;
|
| }
|
|
|
| SkColor dst[1];
|
| proc(dst, src, 1, bitmap->getColorTable());
|
| return dst[0];
|
| }
|
|
|
| static void Bitmap_getPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,
|
| jintArray pixelArray, int offset, int stride,
|
| int x, int y, int width, int height) {
|
| SkAutoLockPixels alp(*bitmap);
|
|
|
| ToColorProc proc = ChooseToColorProc(*bitmap);
|
| if (NULL == proc) {
|
| return;
|
| }
|
| const void* src = bitmap->getAddr(x, y);
|
| if (NULL == src) {
|
| return;
|
| }
|
|
|
| SkColorTable* ctable = bitmap->getColorTable();
|
| jint* dst = env->GetIntArrayElements(pixelArray, NULL);
|
| SkColor* d = (SkColor*)dst + offset;
|
| while (--height >= 0) {
|
| proc(d, src, width, ctable);
|
| d += stride;
|
| src = (void*)((const char*)src + bitmap->rowBytes());
|
| }
|
| env->ReleaseIntArrayElements(pixelArray, dst, 0);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
|
|
| static void Bitmap_setPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,
|
| int x, int y, SkColor color) {
|
| SkAutoLockPixels alp(*bitmap);
|
| if (NULL == bitmap->getPixels()) {
|
| return;
|
| }
|
|
|
| FromColorProc proc = ChooseFromColorProc(bitmap->config());
|
| if (NULL == proc) {
|
| return;
|
| }
|
|
|
| proc(bitmap->getAddr(x, y), &color, 1, x, y);
|
| bitmap->notifyPixelsChanged();
|
| }
|
|
|
| static void Bitmap_setPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,
|
| jintArray pixelArray, int offset, int stride,
|
| int x, int y, int width, int height) {
|
| GraphicsJNI::SetPixels(env, pixelArray, offset, stride,
|
| x, y, width, height, *bitmap);
|
| }
|
|
|
| static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject,
|
| const SkBitmap* bitmap, jobject jbuffer) {
|
| SkAutoLockPixels alp(*bitmap);
|
| const void* src = bitmap->getPixels();
|
|
|
| if (NULL != src) {
|
| android::AutoBufferPointer abp(env, jbuffer, JNI_TRUE);
|
|
|
| // the java side has already checked that buffer is large enough
|
| memcpy(abp.pointer(), src, bitmap->getSize());
|
| }
|
| }
|
|
|
| static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject,
|
| const SkBitmap* bitmap, jobject jbuffer) {
|
| SkAutoLockPixels alp(*bitmap);
|
| void* dst = bitmap->getPixels();
|
|
|
| if (NULL != dst) {
|
| android::AutoBufferPointer abp(env, jbuffer, JNI_FALSE);
|
| // the java side has already checked that buffer is large enough
|
| memcpy(dst, abp.pointer(), bitmap->getSize());
|
| bitmap->notifyPixelsChanged();
|
| }
|
| }
|
|
|
| static bool Bitmap_sameAs(JNIEnv* env, jobject, const SkBitmap* bm0,
|
| const SkBitmap* bm1) {
|
| if (bm0->width() != bm1->width() ||
|
| bm0->height() != bm1->height() ||
|
| bm0->config() != bm1->config()) {
|
| return false;
|
| }
|
|
|
| SkAutoLockPixels alp0(*bm0);
|
| SkAutoLockPixels alp1(*bm1);
|
|
|
| // if we can't load the pixels, return false
|
| if (NULL == bm0->getPixels() || NULL == bm1->getPixels()) {
|
| return false;
|
| }
|
|
|
| if (bm0->config() == SkBitmap::kIndex8_Config) {
|
| SkColorTable* ct0 = bm0->getColorTable();
|
| SkColorTable* ct1 = bm1->getColorTable();
|
| if (NULL == ct0 || NULL == ct1) {
|
| return false;
|
| }
|
| if (ct0->count() != ct1->count()) {
|
| return false;
|
| }
|
|
|
| SkAutoLockColors alc0(ct0);
|
| SkAutoLockColors alc1(ct1);
|
| const size_t size = ct0->count() * sizeof(SkPMColor);
|
| if (memcmp(alc0.colors(), alc1.colors(), size) != 0) {
|
| return false;
|
| }
|
| }
|
|
|
| // now compare each scanline. We can't do the entire buffer at once,
|
| // since we don't care about the pixel values that might extend beyond
|
| // the width (since the scanline might be larger than the logical width)
|
| const int h = bm0->height();
|
| const size_t size = bm0->width() * bm0->bytesPerPixel();
|
| for (int y = 0; y < h; y++) {
|
| if (memcmp(bm0->getAddr(0, y), bm1->getAddr(0, y), size) != 0) {
|
| return false;
|
| }
|
| }
|
| return true;
|
| }
|
|
|
| static void Bitmap_prepareToDraw(JNIEnv* env, jobject, SkBitmap* bitmap) {
|
| bitmap->lockPixels();
|
| bitmap->unlockPixels();
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
|
|
| #include <android_runtime/AndroidRuntime.h>
|
|
|
| static JNINativeMethod gBitmapMethods[] = {
|
| { "nativeCreate", "([IIIIIIZ)Landroid/graphics/Bitmap;",
|
| (void*)Bitmap_creator },
|
| { "nativeCopy", "(IIZ)Landroid/graphics/Bitmap;",
|
| (void*)Bitmap_copy },
|
| { "nativeDestructor", "(I)V", (void*)Bitmap_destructor },
|
| { "nativeRecycle", "(I)V", (void*)Bitmap_recycle },
|
| { "nativeCompress", "(IIILjava/io/OutputStream;[B)Z",
|
| (void*)Bitmap_compress },
|
| { "nativeErase", "(II)V", (void*)Bitmap_erase },
|
| { "nativeWidth", "(I)I", (void*)Bitmap_width },
|
| { "nativeHeight", "(I)I", (void*)Bitmap_height },
|
| { "nativeRowBytes", "(I)I", (void*)Bitmap_rowBytes },
|
| { "nativeConfig", "(I)I", (void*)Bitmap_config },
|
| { "nativeHasAlpha", "(I)Z", (void*)Bitmap_hasAlpha },
|
| { "nativeSetHasAlpha", "(IZ)V", (void*)Bitmap_setHasAlpha },
|
| { "nativeCreateFromParcel",
|
| "(Landroid/os/Parcel;)Landroid/graphics/Bitmap;",
|
| (void*)Bitmap_createFromParcel },
|
| { "nativeWriteToParcel", "(IZILandroid/os/Parcel;)Z",
|
| (void*)Bitmap_writeToParcel },
|
| { "nativeExtractAlpha", "(II[I)Landroid/graphics/Bitmap;",
|
| (void*)Bitmap_extractAlpha },
|
| { "nativeGenerationId", "(I)I", (void*)Bitmap_getGenerationId },
|
| { "nativeGetPixel", "(III)I", (void*)Bitmap_getPixel },
|
| { "nativeGetPixels", "(I[IIIIIII)V", (void*)Bitmap_getPixels },
|
| { "nativeSetPixel", "(IIII)V", (void*)Bitmap_setPixel },
|
| { "nativeSetPixels", "(I[IIIIIII)V", (void*)Bitmap_setPixels },
|
| { "nativeCopyPixelsToBuffer", "(ILjava/nio/Buffer;)V",
|
| (void*)Bitmap_copyPixelsToBuffer },
|
| { "nativeCopyPixelsFromBuffer", "(ILjava/nio/Buffer;)V",
|
| (void*)Bitmap_copyPixelsFromBuffer },
|
| { "nativeSameAs", "(II)Z", (void*)Bitmap_sameAs },
|
| { "nativePrepareToDraw", "(I)V", (void*)Bitmap_prepareToDraw },
|
| };
|
|
|
| #define kClassPathName "android/graphics/Bitmap"
|
|
|
| int register_android_graphics_Bitmap(JNIEnv* env)
|
| {
|
| return android::AndroidRuntime::registerNativeMethods(env, kClassPathName,
|
| gBitmapMethods, SK_ARRAY_COUNT(gBitmapMethods));
|
| }
|