/core/jni/android/graphics/Bitmap.cpp
C++ | 1396 lines | 1127 code | 183 blank | 86 comment | 191 complexity | 692c8efaf7fb5689f87567c23bc5978d MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, CC0-1.0, BitTorrent-1.0
- #define LOG_TAG "Bitmap"
- #include "Bitmap.h"
- #include "Paint.h"
- #include "SkBitmap.h"
- #include "SkPixelRef.h"
- #include "SkImageEncoder.h"
- #include "SkImageInfo.h"
- #include "SkColorPriv.h"
- #include "GraphicsJNI.h"
- #include "SkDither.h"
- #include "SkUnPreMultiply.h"
- #include "SkStream.h"
- #include <binder/Parcel.h>
- #include "android_os_Parcel.h"
- #include "android_util_Binder.h"
- #include "android_nio_utils.h"
- #include "CreateJavaOutputStreamAdaptor.h"
- #include <Caches.h>
- #include "core_jni_helpers.h"
- #include <jni.h>
- #include <memory>
- #include <string>
- #include <sys/mman.h>
- #include <cutils/ashmem.h>
- #define DEBUG_PARCEL 0
- namespace android {
- class WrappedPixelRef : public SkPixelRef {
- public:
- WrappedPixelRef(Bitmap* wrapper, void* storage,
- const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
- : SkPixelRef(info)
- , mBitmap(*wrapper)
- , mStorage(storage) {
- reconfigure(info, rowBytes, ctable);
- }
- ~WrappedPixelRef() {
- // Tell SkRefCnt that everything is as it expects by forcing
- // the refcnt to 1
- internal_dispose_restore_refcnt_to_1();
- SkSafeUnref(mColorTable);
- }
- void reconfigure(const SkImageInfo& newInfo, size_t rowBytes, SkColorTable* ctable) {
- if (kIndex_8_SkColorType != newInfo.colorType()) {
- ctable = nullptr;
- }
- mRowBytes = rowBytes;
- if (mColorTable != ctable) {
- SkSafeUnref(mColorTable);
- mColorTable = ctable;
- SkSafeRef(mColorTable);
- }
- // Need to validate the alpha type to filter against the color type
- // to prevent things like a non-opaque RGB565 bitmap
- SkAlphaType alphaType;
- LOG_ALWAYS_FATAL_IF(!SkColorTypeValidateAlphaType(
- newInfo.colorType(), newInfo.alphaType(), &alphaType),
- "Failed to validate alpha type!");
- // Dirty hack is dirty
- // TODO: Figure something out here, Skia's current design makes this
- // really hard to work with. Skia really, really wants immutable objects,
- // but with the nested-ref-count hackery going on that's just not
- // feasible without going insane trying to figure it out
- SkImageInfo* myInfo = const_cast<SkImageInfo*>(&this->info());
- *myInfo = newInfo;
- changeAlphaType(alphaType);
- // Docs say to only call this in the ctor, but we're going to call
- // it anyway even if this isn't always the ctor.
- // TODO: Fix this too as part of the above TODO
- setPreLocked(mStorage, mRowBytes, mColorTable);
- }
- // Can't mark as override since SkPixelRef::rowBytes isn't virtual
- // but that's OK since we just want BitmapWrapper to be able to rely
- // on calling rowBytes() on an unlocked pixelref, which it will be
- // doing on a WrappedPixelRef type, not a SkPixelRef, so static
- // dispatching will do what we want.
- size_t rowBytes() const { return mRowBytes; }
- SkColorTable* colorTable() const { return mColorTable; }
- bool hasHardwareMipMap() const {
- return mHasHardwareMipMap;
- }
- void setHasHardwareMipMap(bool hasMipMap) {
- mHasHardwareMipMap = hasMipMap;
- }
- protected:
- virtual bool onNewLockPixels(LockRec* rec) override {
- rec->fPixels = mStorage;
- rec->fRowBytes = mRowBytes;
- rec->fColorTable = mColorTable;
- return true;
- }
- virtual void onUnlockPixels() override {
- // nothing
- }
- virtual size_t getAllocatedSizeInBytes() const override {
- return info().getSafeSize(mRowBytes);
- }
- private:
- Bitmap& mBitmap;
- void* mStorage;
- size_t mRowBytes = 0;
- SkColorTable* mColorTable = nullptr;
- bool mHasHardwareMipMap = false;
- virtual void internal_dispose() const override {
- mBitmap.onStrongRefDestroyed();
- }
- };
- Bitmap::Bitmap(JNIEnv* env, jbyteArray storageObj, void* address,
- const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
- : mPixelStorageType(PixelStorageType::Java) {
- env->GetJavaVM(&mPixelStorage.java.jvm);
- mPixelStorage.java.jweakRef = env->NewWeakGlobalRef(storageObj);
- mPixelStorage.java.jstrongRef = nullptr;
- mPixelRef.reset(new WrappedPixelRef(this, address, info, rowBytes, ctable));
- // Note: this will trigger a call to onStrongRefDestroyed(), but
- // we want the pixel ref to have a ref count of 0 at this point
- mPixelRef->unref();
- }
- Bitmap::Bitmap(void* address, void* context, FreeFunc freeFunc,
- const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
- : mPixelStorageType(PixelStorageType::External) {
- mPixelStorage.external.address = address;
- mPixelStorage.external.context = context;
- mPixelStorage.external.freeFunc = freeFunc;
- mPixelRef.reset(new WrappedPixelRef(this, address, info, rowBytes, ctable));
- // Note: this will trigger a call to onStrongRefDestroyed(), but
- // we want the pixel ref to have a ref count of 0 at this point
- mPixelRef->unref();
- }
- Bitmap::Bitmap(void* address, int fd,
- const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
- : mPixelStorageType(PixelStorageType::Ashmem) {
- mPixelStorage.ashmem.address = address;
- mPixelStorage.ashmem.fd = fd;
- mPixelStorage.ashmem.size = ashmem_get_size_region(fd);
- mPixelRef.reset(new WrappedPixelRef(this, address, info, rowBytes, ctable));
- // Note: this will trigger a call to onStrongRefDestroyed(), but
- // we want the pixel ref to have a ref count of 0 at this point
- mPixelRef->unref();
- }
- Bitmap::~Bitmap() {
- doFreePixels();
- }
- void Bitmap::freePixels() {
- AutoMutex _lock(mLock);
- if (mPinnedRefCount == 0) {
- doFreePixels();
- mPixelStorageType = PixelStorageType::Invalid;
- }
- }
- void Bitmap::doFreePixels() {
- switch (mPixelStorageType) {
- case PixelStorageType::Invalid:
- // already free'd, nothing to do
- break;
- case PixelStorageType::External:
- mPixelStorage.external.freeFunc(mPixelStorage.external.address,
- mPixelStorage.external.context);
- break;
- case PixelStorageType::Ashmem:
- munmap(mPixelStorage.ashmem.address, mPixelStorage.ashmem.size);
- close(mPixelStorage.ashmem.fd);
- break;
- case PixelStorageType::Java:
- JNIEnv* env = jniEnv();
- LOG_ALWAYS_FATAL_IF(mPixelStorage.java.jstrongRef,
- "Deleting a bitmap wrapper while there are outstanding strong "
- "references! mPinnedRefCount = %d", mPinnedRefCount);
- env->DeleteWeakGlobalRef(mPixelStorage.java.jweakRef);
- break;
- }
- if (android::uirenderer::Caches::hasInstance()) {
- android::uirenderer::Caches::getInstance().textureCache.releaseTexture(
- mPixelRef->getStableID());
- }
- }
- bool Bitmap::hasHardwareMipMap() {
- return mPixelRef->hasHardwareMipMap();
- }
- void Bitmap::setHasHardwareMipMap(bool hasMipMap) {
- mPixelRef->setHasHardwareMipMap(hasMipMap);
- }
- int Bitmap::getAshmemFd() const {
- switch (mPixelStorageType) {
- case PixelStorageType::Ashmem:
- return mPixelStorage.ashmem.fd;
- default:
- return -1;
- }
- }
- const SkImageInfo& Bitmap::info() const {
- return mPixelRef->info();
- }
- size_t Bitmap::rowBytes() const {
- return mPixelRef->rowBytes();
- }
- SkPixelRef* Bitmap::peekAtPixelRef() const {
- assertValid();
- return mPixelRef.get();
- }
- SkPixelRef* Bitmap::refPixelRef() {
- assertValid();
- android::AutoMutex _lock(mLock);
- return refPixelRefLocked();
- }
- SkPixelRef* Bitmap::refPixelRefLocked() {
- mPixelRef->ref();
- if (mPixelRef->unique()) {
- // We just restored this from 0, pin the pixels and inc the strong count
- // Note that there *might be* an incoming onStrongRefDestroyed from whatever
- // last unref'd
- pinPixelsLocked();
- mPinnedRefCount++;
- }
- return mPixelRef.get();
- }
- void Bitmap::reconfigure(const SkImageInfo& info, size_t rowBytes,
- SkColorTable* ctable) {
- {
- android::AutoMutex _lock(mLock);
- if (mPinnedRefCount) {
- ALOGW("Called reconfigure on a bitmap that is in use! This may"
- " cause graphical corruption!");
- }
- }
- mPixelRef->reconfigure(info, rowBytes, ctable);
- }
- void Bitmap::reconfigure(const SkImageInfo& info) {
- reconfigure(info, info.minRowBytes(), nullptr);
- }
- void Bitmap::setAlphaType(SkAlphaType alphaType) {
- if (!SkColorTypeValidateAlphaType(info().colorType(), alphaType, &alphaType)) {
- return;
- }
- mPixelRef->changeAlphaType(alphaType);
- }
- void Bitmap::detachFromJava() {
- bool disposeSelf;
- {
- android::AutoMutex _lock(mLock);
- mAttachedToJava = false;
- disposeSelf = shouldDisposeSelfLocked();
- }
- if (disposeSelf) {
- delete this;
- }
- }
- bool Bitmap::shouldDisposeSelfLocked() {
- return mPinnedRefCount == 0 && !mAttachedToJava;
- }
- JNIEnv* Bitmap::jniEnv() {
- JNIEnv* env;
- auto success = mPixelStorage.java.jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
- LOG_ALWAYS_FATAL_IF(success != JNI_OK,
- "Failed to get JNIEnv* from JVM: %p", mPixelStorage.java.jvm);
- return env;
- }
- void Bitmap::onStrongRefDestroyed() {
- bool disposeSelf = false;
- {
- android::AutoMutex _lock(mLock);
- if (mPinnedRefCount > 0) {
- mPinnedRefCount--;
- if (mPinnedRefCount == 0) {
- unpinPixelsLocked();
- disposeSelf = shouldDisposeSelfLocked();
- }
- }
- }
- if (disposeSelf) {
- delete this;
- }
- }
- void Bitmap::pinPixelsLocked() {
- switch (mPixelStorageType) {
- case PixelStorageType::Invalid:
- LOG_ALWAYS_FATAL("Cannot pin invalid pixels!");
- break;
- case PixelStorageType::External:
- case PixelStorageType::Ashmem:
- // Nothing to do
- break;
- case PixelStorageType::Java: {
- JNIEnv* env = jniEnv();
- if (!mPixelStorage.java.jstrongRef) {
- mPixelStorage.java.jstrongRef = reinterpret_cast<jbyteArray>(
- env->NewGlobalRef(mPixelStorage.java.jweakRef));
- if (!mPixelStorage.java.jstrongRef) {
- LOG_ALWAYS_FATAL("Failed to acquire strong reference to pixels");
- }
- }
- break;
- }
- }
- }
- void Bitmap::unpinPixelsLocked() {
- switch (mPixelStorageType) {
- case PixelStorageType::Invalid:
- LOG_ALWAYS_FATAL("Cannot unpin invalid pixels!");
- break;
- case PixelStorageType::External:
- case PixelStorageType::Ashmem:
- // Don't need to do anything
- break;
- case PixelStorageType::Java: {
- JNIEnv* env = jniEnv();
- if (mPixelStorage.java.jstrongRef) {
- env->DeleteGlobalRef(mPixelStorage.java.jstrongRef);
- mPixelStorage.java.jstrongRef = nullptr;
- }
- break;
- }
- }
- }
- void Bitmap::getSkBitmap(SkBitmap* outBitmap) {
- assertValid();
- android::AutoMutex _lock(mLock);
- // Safe because mPixelRef is a WrappedPixelRef type, otherwise rowBytes()
- // would require locking the pixels first.
- outBitmap->setInfo(mPixelRef->info(), mPixelRef->rowBytes());
- outBitmap->setPixelRef(refPixelRefLocked())->unref();
- outBitmap->setHasHardwareMipMap(hasHardwareMipMap());
- }
- void Bitmap::assertValid() const {
- LOG_ALWAYS_FATAL_IF(mPixelStorageType == PixelStorageType::Invalid,
- "Error, cannot access an invalid/free'd bitmap here!");
- }
- } // namespace android
- using namespace android;
- // Convenience class that does not take a global ref on the pixels, relying
- // on the caller already having a local JNI ref
- class LocalScopedBitmap {
- public:
- LocalScopedBitmap(jlong bitmapHandle)
- : mBitmap(reinterpret_cast<Bitmap*>(bitmapHandle)) {}
- Bitmap* operator->() {
- return mBitmap;
- }
- void* pixels() {
- return mBitmap->peekAtPixelRef()->pixels();
- }
- bool valid() {
- return mBitmap && mBitmap->valid();
- }
- private:
- Bitmap* mBitmap;
- };
- ///////////////////////////////////////////////////////////////////////////////
- // 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_D32_Raw(void* dst, const SkColor src[], int width,
- int, int) {
- // Needed to thwart the unreachable code detection from clang.
- static const bool sk_color_ne_zero = SK_COLOR_MATCHES_PMCOLOR_BYTE_ORDER;
- // SkColor's ordering may be different from SkPMColor
- if (sk_color_ne_zero) {
- memcpy(dst, src, width * sizeof(SkColor));
- return;
- }
- // order isn't same, repack each pixel manually
- SkPMColor* d = (SkPMColor*)dst;
- for (int i = 0; i < width; i++) {
- SkColor c = *src++;
- *d++ = SkPackARGB32NoCheck(SkColorGetA(c), SkColorGetR(c),
- SkColorGetG(c), SkColorGetB(c));
- }
- }
- 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 pmc = SkPreMultiplyColor(*src++);
- *d++ = SkDitherARGB32To4444(pmc, DITHER_VALUE(x));
- // *d++ = SkPixel32ToPixel4444(pmc);
- }
- }
- static void FromColor_D4444_Raw(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++) {
- SkColor c = *src++;
- // SkPMColor is used because the ordering is ARGB32, even though the target actually premultiplied
- SkPMColor pmc = SkPackARGB32NoCheck(SkColorGetA(c), SkColorGetR(c),
- SkColorGetG(c), SkColorGetB(c));
- *d++ = SkDitherARGB32To4444(pmc, DITHER_VALUE(x));
- // *d++ = SkPixel32ToPixel4444(pmc);
- }
- }
- static void FromColor_DA8(void* dst, const SkColor src[], int width, int x, int y) {
- uint8_t* d = (uint8_t*)dst;
- for (int stop = x + width; x < stop; x++) {
- *d++ = SkColorGetA(*src++);
- }
- }
- // can return NULL
- static FromColorProc ChooseFromColorProc(const SkBitmap& bitmap) {
- switch (bitmap.colorType()) {
- case kN32_SkColorType:
- return bitmap.alphaType() == kPremul_SkAlphaType ? FromColor_D32 : FromColor_D32_Raw;
- case kARGB_4444_SkColorType:
- return bitmap.alphaType() == kPremul_SkAlphaType ? FromColor_D4444 :
- FromColor_D4444_Raw;
- case kRGB_565_SkColorType:
- return FromColor_D565;
- case kAlpha_8_SkColorType:
- return FromColor_DA8;
- 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);
- 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_Raw(SkColor dst[], const void* src, int width,
- SkColorTable*) {
- SkASSERT(width > 0);
- const SkPMColor* s = (const SkPMColor*)src;
- do {
- SkPMColor c = *s++;
- *dst++ = SkColorSetARGB(SkGetPackedA32(c), SkGetPackedR32(c),
- SkGetPackedG32(c), SkGetPackedB32(c));
- } 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_Raw(SkColor dst[], const void* src, int width,
- SkColorTable*) {
- SkASSERT(width > 0);
- const SkPMColor16* s = (const SkPMColor16*)src;
- do {
- SkPMColor c = SkPixel4444ToPixel32(*s++);
- *dst++ = SkColorSetARGB(SkGetPackedA32(c), SkGetPackedR32(c),
- SkGetPackedG32(c), SkGetPackedB32(c));
- } while (--width != 0);
- }
- static void ToColor_S4444_Opaque(SkColor dst[], const void* src, int width,
- SkColorTable*) {
- SkASSERT(width > 0);
- const SkPMColor16* s = (const SkPMColor16*)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->readColors();
- do {
- *dst++ = SkUnPreMultiply::PMColorToColor(colors[*s++]);
- } while (--width != 0);
- }
- static void ToColor_SI8_Raw(SkColor dst[], const void* src, int width,
- SkColorTable* ctable) {
- SkASSERT(width > 0);
- const uint8_t* s = (const uint8_t*)src;
- const SkPMColor* colors = ctable->readColors();
- do {
- SkPMColor c = colors[*s++];
- *dst++ = SkColorSetARGB(SkGetPackedA32(c), SkGetPackedR32(c),
- SkGetPackedG32(c), SkGetPackedB32(c));
- } while (--width != 0);
- }
- 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->readColors();
- do {
- SkPMColor c = colors[*s++];
- *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c),
- SkGetPackedB32(c));
- } while (--width != 0);
- }
- static void ToColor_SA8(SkColor dst[], const void* src, int width, SkColorTable*) {
- SkASSERT(width > 0);
- const uint8_t* s = (const uint8_t*)src;
- do {
- uint8_t c = *s++;
- *dst++ = SkColorSetARGB(c, c, c, c);
- } while (--width != 0);
- }
- // can return NULL
- static ToColorProc ChooseToColorProc(const SkBitmap& src) {
- switch (src.colorType()) {
- case kN32_SkColorType:
- switch (src.alphaType()) {
- case kOpaque_SkAlphaType:
- return ToColor_S32_Opaque;
- case kPremul_SkAlphaType:
- return ToColor_S32_Alpha;
- case kUnpremul_SkAlphaType:
- return ToColor_S32_Raw;
- default:
- return NULL;
- }
- case kARGB_4444_SkColorType:
- switch (src.alphaType()) {
- case kOpaque_SkAlphaType:
- return ToColor_S4444_Opaque;
- case kPremul_SkAlphaType:
- return ToColor_S4444_Alpha;
- case kUnpremul_SkAlphaType:
- return ToColor_S4444_Raw;
- default:
- return NULL;
- }
- case kRGB_565_SkColorType:
- return ToColor_S565;
- case kIndex_8_SkColorType:
- if (src.getColorTable() == NULL) {
- return NULL;
- }
- switch (src.alphaType()) {
- case kOpaque_SkAlphaType:
- return ToColor_SI8_Opaque;
- case kPremul_SkAlphaType:
- return ToColor_SI8_Alpha;
- case kUnpremul_SkAlphaType:
- return ToColor_SI8_Raw;
- default:
- return NULL;
- }
- case kAlpha_8_SkColorType:
- return ToColor_SA8;
- default:
- break;
- }
- return NULL;
- }
- ///////////////////////////////////////////////////////////////////////////////
- ///////////////////////////////////////////////////////////////////////////////
- static int getPremulBitmapCreateFlags(bool isMutable) {
- int flags = GraphicsJNI::kBitmapCreateFlag_Premultiplied;
- if (isMutable) flags |= GraphicsJNI::kBitmapCreateFlag_Mutable;
- return flags;
- }
- static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,
- jint offset, jint stride, jint width, jint height,
- jint configHandle, jboolean isMutable) {
- SkColorType colorType = GraphicsJNI::legacyBitmapConfigToColorType(configHandle);
- if (NULL != jColors) {
- size_t n = env->GetArrayLength(jColors);
- if (n < SkAbs32(stride) * (size_t)height) {
- doThrowAIOOBE(env);
- return NULL;
- }
- }
- // ARGB_4444 is a deprecated format, convert automatically to 8888
- if (colorType == kARGB_4444_SkColorType) {
- colorType = kN32_SkColorType;
- }
- SkBitmap bitmap;
- bitmap.setInfo(SkImageInfo::Make(width, height, colorType, kPremul_SkAlphaType));
- Bitmap* nativeBitmap = GraphicsJNI::allocateJavaPixelRef(env, &bitmap, NULL);
- if (!nativeBitmap) {
- return NULL;
- }
- if (jColors != NULL) {
- GraphicsJNI::SetPixels(env, jColors, offset, stride,
- 0, 0, width, height, bitmap);
- }
- return GraphicsJNI::createBitmap(env, nativeBitmap,
- getPremulBitmapCreateFlags(isMutable));
- }
- static jobject Bitmap_copy(JNIEnv* env, jobject, jlong srcHandle,
- jint dstConfigHandle, jboolean isMutable) {
- SkBitmap src;
- reinterpret_cast<Bitmap*>(srcHandle)->getSkBitmap(&src);
- SkColorType dstCT = GraphicsJNI::legacyBitmapConfigToColorType(dstConfigHandle);
- SkBitmap result;
- JavaPixelAllocator allocator(env);
- if (!src.copyTo(&result, dstCT, &allocator)) {
- return NULL;
- }
- Bitmap* bitmap = allocator.getStorageObjAndReset();
- return GraphicsJNI::createBitmap(env, bitmap,
- getPremulBitmapCreateFlags(isMutable));
- }
- static jobject Bitmap_copyAshmem(JNIEnv* env, jobject, jlong srcHandle) {
- SkBitmap src;
- reinterpret_cast<Bitmap*>(srcHandle)->getSkBitmap(&src);
- SkBitmap result;
- AshmemPixelAllocator allocator(env);
- if (!src.copyTo(&result, &allocator)) {
- return NULL;
- }
- Bitmap* bitmap = allocator.getStorageObjAndReset();
- bitmap->peekAtPixelRef()->setImmutable();
- jobject ret = GraphicsJNI::createBitmap(env, bitmap, getPremulBitmapCreateFlags(false));
- return ret;
- }
- static void Bitmap_destructor(JNIEnv* env, jobject, jlong bitmapHandle) {
- LocalScopedBitmap bitmap(bitmapHandle);
- bitmap->detachFromJava();
- }
- static jboolean Bitmap_recycle(JNIEnv* env, jobject, jlong bitmapHandle) {
- LocalScopedBitmap bitmap(bitmapHandle);
- bitmap->freePixels();
- return JNI_TRUE;
- }
- static void Bitmap_reconfigure(JNIEnv* env, jobject clazz, jlong bitmapHandle,
- jint width, jint height, jint configHandle, jint allocSize,
- jboolean requestPremul) {
- LocalScopedBitmap bitmap(bitmapHandle);
- SkColorType colorType = GraphicsJNI::legacyBitmapConfigToColorType(configHandle);
- // ARGB_4444 is a deprecated format, convert automatically to 8888
- if (colorType == kARGB_4444_SkColorType) {
- colorType = kN32_SkColorType;
- }
- if (width * height * SkColorTypeBytesPerPixel(colorType) > allocSize) {
- // done in native as there's no way to get BytesPerPixel in Java
- doThrowIAE(env, "Bitmap not large enough to support new configuration");
- return;
- }
- SkAlphaType alphaType;
- if (bitmap->info().colorType() != kRGB_565_SkColorType
- && bitmap->info().alphaType() == kOpaque_SkAlphaType) {
- // If the original bitmap was set to opaque, keep that setting, unless it
- // was 565, which is required to be opaque.
- alphaType = kOpaque_SkAlphaType;
- } else {
- // Otherwise respect the premultiplied request.
- alphaType = requestPremul ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
- }
- bitmap->reconfigure(SkImageInfo::Make(width, height, colorType, alphaType));
- }
- // These must match the int values in Bitmap.java
- enum JavaEncodeFormat {
- kJPEG_JavaEncodeFormat = 0,
- kPNG_JavaEncodeFormat = 1,
- kWEBP_JavaEncodeFormat = 2
- };
- static jboolean Bitmap_compress(JNIEnv* env, jobject clazz, jlong bitmapHandle,
- jint format, jint quality,
- jobject jstream, jbyteArray jstorage) {
- LocalScopedBitmap bitmap(bitmapHandle);
- 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 JNI_FALSE;
- }
- if (!bitmap.valid()) {
- return JNI_FALSE;
- }
- bool success = false;
- std::unique_ptr<SkWStream> strm(CreateJavaOutputStreamAdaptor(env, jstream, jstorage));
- if (!strm.get()) {
- return JNI_FALSE;
- }
- std::unique_ptr<SkImageEncoder> encoder(SkImageEncoder::Create(fm));
- if (encoder.get()) {
- SkBitmap skbitmap;
- bitmap->getSkBitmap(&skbitmap);
- success = encoder->encodeStream(strm.get(), skbitmap, quality);
- }
- return success ? JNI_TRUE : JNI_FALSE;
- }
- static void Bitmap_erase(JNIEnv* env, jobject, jlong bitmapHandle, jint color) {
- LocalScopedBitmap bitmap(bitmapHandle);
- SkBitmap skBitmap;
- bitmap->getSkBitmap(&skBitmap);
- skBitmap.eraseColor(color);
- }
- static jint Bitmap_rowBytes(JNIEnv* env, jobject, jlong bitmapHandle) {
- LocalScopedBitmap bitmap(bitmapHandle);
- return static_cast<jint>(bitmap->rowBytes());
- }
- static jint Bitmap_config(JNIEnv* env, jobject, jlong bitmapHandle) {
- LocalScopedBitmap bitmap(bitmapHandle);
- return GraphicsJNI::colorTypeToLegacyBitmapConfig(bitmap->info().colorType());
- }
- static jint Bitmap_getGenerationId(JNIEnv* env, jobject, jlong bitmapHandle) {
- LocalScopedBitmap bitmap(bitmapHandle);
- return static_cast<jint>(bitmap->peekAtPixelRef()->getGenerationID());
- }
- static jboolean Bitmap_isPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle) {
- LocalScopedBitmap bitmap(bitmapHandle);
- if (bitmap->info().alphaType() == kPremul_SkAlphaType) {
- return JNI_TRUE;
- }
- return JNI_FALSE;
- }
- static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, jlong bitmapHandle) {
- LocalScopedBitmap bitmap(bitmapHandle);
- return !bitmap->info().isOpaque() ? JNI_TRUE : JNI_FALSE;
- }
- static void Bitmap_setHasAlpha(JNIEnv* env, jobject, jlong bitmapHandle,
- jboolean hasAlpha, jboolean requestPremul) {
- LocalScopedBitmap bitmap(bitmapHandle);
- if (hasAlpha) {
- bitmap->setAlphaType(
- requestPremul ? kPremul_SkAlphaType : kUnpremul_SkAlphaType);
- } else {
- bitmap->setAlphaType(kOpaque_SkAlphaType);
- }
- }
- static void Bitmap_setPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle,
- jboolean isPremul) {
- LocalScopedBitmap bitmap(bitmapHandle);
- if (!bitmap->info().isOpaque()) {
- if (isPremul) {
- bitmap->setAlphaType(kPremul_SkAlphaType);
- } else {
- bitmap->setAlphaType(kUnpremul_SkAlphaType);
- }
- }
- }
- static jboolean Bitmap_hasMipMap(JNIEnv* env, jobject, jlong bitmapHandle) {
- LocalScopedBitmap bitmap(bitmapHandle);
- return bitmap->hasHardwareMipMap() ? JNI_TRUE : JNI_FALSE;
- }
- static void Bitmap_setHasMipMap(JNIEnv* env, jobject, jlong bitmapHandle,
- jboolean hasMipMap) {
- LocalScopedBitmap bitmap(bitmapHandle);
- bitmap->setHasHardwareMipMap(hasMipMap);
- }
- ///////////////////////////////////////////////////////////////////////////////
- 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 SkColorType colorType = (SkColorType)p->readInt32();
- const SkAlphaType alphaType = (SkAlphaType)p->readInt32();
- const int width = p->readInt32();
- const int height = p->readInt32();
- const int rowBytes = p->readInt32();
- const int density = p->readInt32();
- if (kN32_SkColorType != colorType &&
- kRGB_565_SkColorType != colorType &&
- kARGB_4444_SkColorType != colorType &&
- kIndex_8_SkColorType != colorType &&
- kAlpha_8_SkColorType != colorType) {
- SkDebugf("Bitmap_createFromParcel unknown colortype: %d\n", colorType);
- return NULL;
- }
- std::unique_ptr<SkBitmap> bitmap(new SkBitmap);
- if (!bitmap->setInfo(SkImageInfo::Make(width, height, colorType, alphaType), rowBytes)) {
- return NULL;
- }
- SkColorTable* ctable = NULL;
- if (colorType == kIndex_8_SkColorType) {
- int count = p->readInt32();
- if (count < 0 || count > 256) {
- // The data is corrupt, since SkColorTable enforces a value between 0 and 256,
- // inclusive.
- return NULL;
- }
- if (count > 0) {
- size_t size = count * sizeof(SkPMColor);
- const SkPMColor* src = (const SkPMColor*)p->readInplace(size);
- if (src == NULL) {
- return NULL;
- }
- ctable = new SkColorTable(src, count);
- }
- }
- // Read the bitmap blob.
- size_t size = bitmap->getSize();
- android::Parcel::ReadableBlob blob;
- android::status_t status = p->readBlob(size, &blob);
- if (status) {
- SkSafeUnref(ctable);
- doThrowRE(env, "Could not read bitmap blob.");
- return NULL;
- }
- // Map the bitmap in place from the ashmem region if possible otherwise copy.
- Bitmap* nativeBitmap;
- if (blob.fd() >= 0 && (blob.isMutable() || !isMutable)) {
- #if DEBUG_PARCEL
- ALOGD("Bitmap.createFromParcel: mapped contents of %s bitmap from %s blob "
- "(fds %s)",
- isMutable ? "mutable" : "immutable",
- blob.isMutable() ? "mutable" : "immutable",
- p->allowFds() ? "allowed" : "forbidden");
- #endif
- // Dup the file descriptor so we can keep a reference to it after the Parcel
- // is disposed.
- int dupFd = dup(blob.fd());
- if (dupFd < 0) {
- blob.release();
- SkSafeUnref(ctable);
- doThrowRE(env, "Could not allocate dup blob fd.");
- return NULL;
- }
- // Map the pixels in place and take ownership of the ashmem region.
- nativeBitmap = GraphicsJNI::mapAshmemPixelRef(env, bitmap.get(),
- ctable, dupFd, const_cast<void*>(blob.data()), !isMutable);
- SkSafeUnref(ctable);
- if (!nativeBitmap) {
- close(dupFd);
- blob.release();
- doThrowRE(env, "Could not allocate ashmem pixel ref.");
- return NULL;
- }
- // Clear the blob handle, don't release it.
- blob.clear();
- } else {
- #if DEBUG_PARCEL
- if (blob.fd() >= 0) {
- ALOGD("Bitmap.createFromParcel: copied contents of mutable bitmap "
- "from immutable blob (fds %s)",
- p->allowFds() ? "allowed" : "forbidden");
- } else {
- ALOGD("Bitmap.createFromParcel: copied contents from %s blob "
- "(fds %s)",
- blob.isMutable() ? "mutable" : "immutable",
- p->allowFds() ? "allowed" : "forbidden");
- }
- #endif
- // Copy the pixels into a new buffer.
- nativeBitmap = GraphicsJNI::allocateJavaPixelRef(env, bitmap.get(), ctable);
- SkSafeUnref(ctable);
- if (!nativeBitmap) {
- blob.release();
- doThrowRE(env, "Could not allocate java pixel ref.");
- return NULL;
- }
- bitmap->lockPixels();
- memcpy(bitmap->getPixels(), blob.data(), size);
- bitmap->unlockPixels();
- // Release the blob handle.
- blob.release();
- }
- return GraphicsJNI::createBitmap(env, nativeBitmap,
- getPremulBitmapCreateFlags(isMutable), NULL, NULL, density);
- }
- static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject,
- jlong bitmapHandle,
- jboolean isMutable, jint density,
- jobject parcel) {
- if (parcel == NULL) {
- SkDebugf("------- writeToParcel null parcel\n");
- return JNI_FALSE;
- }
- android::Parcel* p = android::parcelForJavaObject(env, parcel);
- SkBitmap bitmap;
- android::Bitmap* androidBitmap = reinterpret_cast<Bitmap*>(bitmapHandle);
- androidBitmap->getSkBitmap(&bitmap);
- p->writeInt32(isMutable);
- p->writeInt32(bitmap.colorType());
- p->writeInt32(bitmap.alphaType());
- p->writeInt32(bitmap.width());
- p->writeInt32(bitmap.height());
- p->writeInt32(bitmap.rowBytes());
- p->writeInt32(density);
- if (bitmap.colorType() == kIndex_8_SkColorType) {
- SkColorTable* ctable = bitmap.getColorTable();
- if (ctable != NULL) {
- int count = ctable->count();
- p->writeInt32(count);
- memcpy(p->writeInplace(count * sizeof(SkPMColor)),
- ctable->readColors(), count * sizeof(SkPMColor));
- } else {
- p->writeInt32(0); // indicate no ctable
- }
- }
- // Transfer the underlying ashmem region if we have one and it's immutable.
- android::status_t status;
- int fd = androidBitmap->getAshmemFd();
- if (fd >= 0 && !isMutable && p->allowFds()) {
- #if DEBUG_PARCEL
- ALOGD("Bitmap.writeToParcel: transferring immutable bitmap's ashmem fd as "
- "immutable blob (fds %s)",
- p->allowFds() ? "allowed" : "forbidden");
- #endif
- status = p->writeDupImmutableBlobFileDescriptor(fd);
- if (status) {
- doThrowRE(env, "Could not write bitmap blob file descriptor.");
- return JNI_FALSE;
- }
- return JNI_TRUE;
- }
- // Copy the bitmap to a new blob.
- bool mutableCopy = isMutable;
- #if DEBUG_PARCEL
- ALOGD("Bitmap.writeToParcel: copying %s bitmap into new %s blob (fds %s)",
- isMutable ? "mutable" : "immutable",
- mutableCopy ? "mutable" : "immutable",
- p->allowFds() ? "allowed" : "forbidden");
- #endif
- size_t size = bitmap.getSize();
- android::Parcel::WritableBlob blob;
- status = p->writeBlob(size, mutableCopy, &blob);
- if (status) {
- doThrowRE(env, "Could not copy bitmap to parcel blob.");
- return JNI_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 JNI_TRUE;
- }
- static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz,
- jlong srcHandle, jlong paintHandle,
- jintArray offsetXY) {
- SkBitmap src;
- reinterpret_cast<Bitmap*>(srcHandle)->getSkBitmap(&src);
- const android::Paint* paint = reinterpret_cast<android::Paint*>(paintHandle);
- SkIPoint offset;
- SkBitmap dst;
- 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) {
- 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, allocator.getStorageObjAndReset(),
- getPremulBitmapCreateFlags(true));
- }
- ///////////////////////////////////////////////////////////////////////////////
- static jint Bitmap_getPixel(JNIEnv* env, jobject, jlong bitmapHandle,
- jint x, jint y) {
- SkBitmap bitmap;
- reinterpret_cast<Bitmap*>(bitmapHandle)->getSkBitmap(&bitmap);
- 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 static_cast<jint>(dst[0]);
- }
- static void Bitmap_getPixels(JNIEnv* env, jobject, jlong bitmapHandle,
- jintArray pixelArray, jint offset, jint stride,
- jint x, jint y, jint width, jint height) {
- SkBitmap bitmap;
- reinterpret_cast<Bitmap*>(bitmapHandle)->getSkBitmap(&bitmap);
- 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, jlong bitmapHandle,
- jint x, jint y, jint colorHandle) {
- SkBitmap bitmap;
- reinterpret_cast<Bitmap*>(bitmapHandle)->getSkBitmap(&bitmap);
- SkColor color = static_cast<SkColor>(colorHandle);
- SkAutoLockPixels alp(bitmap);
- if (NULL == bitmap.getPixels()) {
- return;
- }
- FromColorProc proc = ChooseFromColorProc(bitmap);
- if (NULL == proc) {
- return;
- }
- proc(bitmap.getAddr(x, y), &color, 1, x, y);
- bitmap.notifyPixelsChanged();
- }
- static void Bitmap_setPixels(JNIEnv* env, jobject, jlong bitmapHandle,
- jintArray pixelArray, jint offset, jint stride,
- jint x, jint y, jint width, jint height) {
- SkBitmap bitmap;
- reinterpret_cast<Bitmap*>(bitmapHandle)->getSkBitmap(&bitmap);
- GraphicsJNI::SetPixels(env, pixelArray, offset, stride,
- x, y, width, height, bitmap);
- }
- static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject,
- jlong bitmapHandle, jobject jbuffer) {
- SkBitmap bitmap;
- reinterpret_cast<Bitmap*>(bitmapHandle)->getSkBitmap(&bitmap);
- 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,
- jlong bitmapHandle, jobject jbuffer) {
- SkBitmap bitmap;
- reinterpret_cast<Bitmap*>(bitmapHandle)->getSkBitmap(&bitmap);
- 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 jboolean Bitmap_sameAs(JNIEnv* env, jobject, jlong bm0Handle,
- jlong bm1Handle) {
- SkBitmap bm0;
- SkBitmap bm1;
- reinterpret_cast<Bitmap*>(bm0Handle)->getSkBitmap(&bm0);
- reinterpret_cast<Bitmap*>(bm1Handle)->getSkBitmap(&bm1);
- if (bm0.width() != bm1.width() ||
- bm0.height() != bm1.height() ||
- bm0.colorType() != bm1.colorType()) {
- return JNI_FALSE;
- }
- SkAutoLockPixels alp0(bm0);
- SkAutoLockPixels alp1(bm1);
- // if we can't load the pixels, return false
- if (NULL == bm0.getPixels() || NULL == bm1.getPixels()) {
- return JNI_FALSE;
- }
- if (bm0.colorType() == kIndex_8_SkColorType) {
- SkColorTable* ct0 = bm0.getColorTable();
- SkColorTable* ct1 = bm1.getColorTable();
- if (NULL == ct0 || NULL == ct1) {
- return JNI_FALSE;
- }
- if (ct0->count() != ct1->count()) {
- return JNI_FALSE;
- }
- const size_t size = ct0->count() * sizeof(SkPMColor);
- if (memcmp(ct0->readColors(), ct1->readColors(), size) != 0) {
- return JNI_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++) {
- // SkBitmap::getAddr(int, int) may return NULL due to unrecognized config
- // (ex: kRLE_Index8_Config). This will cause memcmp method to crash. Since bm0
- // and bm1 both have pixel data() (have passed NULL == getPixels() check),
- // those 2 bitmaps should be valid (only unrecognized), we return JNI_FALSE
- // to warn user those 2 unrecognized config bitmaps may be different.
- void *bm0Addr = bm0.getAddr(0, y);
- void *bm1Addr = bm1.getAddr(0, y);
- if(bm0Addr == NULL || bm1Addr == NULL) {
- return JNI_FALSE;
- }
- if (memcmp(bm0Addr, bm1Addr, size) != 0) {
- return JNI_FALSE;
- }
- }
- return JNI_TRUE;
- }
- static jlong Bitmap_refPixelRef(JNIEnv* env, jobject, jlong bitmapHandle) {
- LocalScopedBitmap bitmap(bitmapHandle);
- SkPixelRef* pixelRef = bitmap.valid() ? bitmap->peekAtPixelRef() : nullptr;
- SkSafeRef(pixelRef);
- return reinterpret_cast<jlong>(pixelRef);
- }
- ///////////////////////////////////////////////////////////////////////////////
- static const JNINativeMethod gBitmapMethods[] = {
- { "nativeCreate", "([IIIIIIZ)Landroid/graphics/Bitmap;",
- (void*)Bitmap_creator },
- { "nativeCopy", "(JIZ)Landroid/graphics/Bitmap;",
- (void*)Bitmap_copy },
- { "nativeCopyAshmem", "(J)Landroid/graphics/Bitmap;",
- (void*)Bitmap_copyAshmem },
- { "nativeDestructor", "(J)V", (void*)Bitmap_destructor },
- { "nativeRecycle", "(J)Z", (void*)Bitmap_recycle },
- { "nativeReconfigure", "(JIIIIZ)V", (void*)Bitmap_reconfigure },
- { "nativeCompress", "(JIILjava/io/OutputStream;[B)Z",
- (void*)Bitmap_compress },
- { "nativeErase", "(JI)V", (void*)Bitmap_erase },
- { "nativeRowBytes", "(J)I", (void*)Bitmap_rowBytes },
- { "nativeConfig", "(J)I", (void*)Bitmap_config },
- { "nativeHasAlpha", "(J)Z", (void*)Bitmap_hasAlpha },
- { "nativeIsPremultiplied", "(J)Z", (void*)Bitmap_isPremultiplied},
- { "nativeSetHasAlpha", "(JZZ)V", (void*)Bitmap_setHasAlpha},
- { "nativeSetPremultiplied", "(JZ)V", (void*)Bitmap_setPremultiplied},
- { "nativeHasMipMap", "(J)Z", (void*)Bitmap_hasMipMap },
- { "nativeSetHasMipMap", "(JZ)V", (void*)Bitmap_setHasMipMap },
- { "nativeCreateFromParcel",
- "(Landroid/os/Parcel;)Landroid/graphics/Bitmap;",
- (void*)Bitmap_createFromParcel },
- { "nativeWriteToParcel", "(JZILandroid/os/Parcel;)Z",
- (void*)Bitmap_writeToParcel },
- { "nativeExtractAlpha", "(JJ[I)Landroid/graphics/Bitmap;",
- (void*)Bitmap_extractAlpha },
- { "nativeGenerationId", "(J)I", (void*)Bitmap_getGenerationId },
- { "nativeGetPixel", "(JII)I", (void*)Bitmap_getPixel },
- { "nativeGetPixels", "(J[IIIIIII)V", (void*)Bitmap_getPixels },
- { "nativeSetPixel", "(JIII)V", (void*)Bitmap_setPixel },
- { "nativeSetPixels", "(J[IIIIIII)V", (void*)Bitmap_setPixels },
- { "nativeCopyPixelsToBuffer", "(JLjava/nio/Buffer;)V",
- (void*)Bitmap_copyPixelsToBuffer },
- { "nativeCopyPixelsFromBuffer", "(JLjava/nio/Buffer;)V",
- (void*)Bitmap_copyPixelsFromBuffer },
- { "nativeSameAs", "(JJ)Z", (void*)Bitmap_sameAs },
- { "nativeRefPixelRef", "(J)J", (void*)Bitmap_refPixelRef },
- };
- int register_android_graphics_Bitmap(JNIEnv* env)
- {
- return android::RegisterMethodsOrDie(env, "android/graphics/Bitmap", gBitmapMethods,
- NELEM(gBitmapMethods));
- }