Merge "Attempt to solve the double-GC problem" into mnc-dev (c64b3fab) · Commits · e / os / android_frameworks_base

core/jni/android/graphics/Bitmap.cpp

+448 −144

File changed.

Preview size limit exceeded, changes collapsed.

core/jni/android/graphics/Bitmap.h

0 → 100644

+114 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/
		#ifndef BITMAP_H_
		#define BITMAP_H_

		#include <jni.h>
		#include <SkBitmap.h>
		#include <SkColorTable.h>
		#include <SkImageInfo.h>
		#include <utils/Mutex.h>
		#include <memory>

		namespace android {

		enum class PixelStorageType {
		Invalid,
		External,
		Java,
		};

		class WrappedPixelRef;

		typedef void (FreeFunc)(void addr, void* context);

		/**
		* Glue-thingy that deals with managing the interaction between the Java
		* Bitmap object & SkBitmap along with trying to map a notion of strong/weak
		* lifecycles onto SkPixelRef which only has strong counts to avoid requiring
		* two GC passes to free the byte[] that backs a Bitmap.
		*
		* Since not all Bitmaps are byte[]-backed it also supports external allocations,
		* which currently is used by screenshots to wrap a gralloc buffer.
		*/
		class Bitmap {
		public:
		Bitmap(JNIEnv* env, jbyteArray storageObj, void* address,
		const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable);
		Bitmap(void* address, void* context, FreeFunc freeFunc,
		const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable);

		const SkImageInfo& info() const;

		// Returns nullptr if it is not backed by a jbyteArray
		jbyteArray javaByteArray() const {
		return mPixelStorageType == PixelStorageType::Java
		? mPixelStorage.java.jstrongRef : nullptr;
		}

		int width() const { return info().width(); }
		int height() const { return info().height(); }
		size_t rowBytes() const;
		SkPixelRef* pixelRef() const;
		bool valid() const { return mPixelStorageType != PixelStorageType::Invalid; }

		void reconfigure(const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable);
		void reconfigure(const SkImageInfo& info);

		void getSkBitmap(SkBitmap* outBitmap);
		void detachFromJava();

		void freePixels();

		bool hasHardwareMipMap();
		void setHasHardwareMipMap(bool hasMipMap);

		private:
		friend class WrappedPixelRef;

		~Bitmap();
		void doFreePixels();
		void onStrongRefDestroyed();

		void pinPixelsLocked();
		void unpinPixelsLocked();
		JNIEnv* jniEnv();
		bool shouldDisposeSelfLocked();
		void assertValid() const;

		android::Mutex mLock;
		int mPinnedRefCount = 0;
		std::unique_ptr<WrappedPixelRef> mPixelRef;
		PixelStorageType mPixelStorageType;
		bool mAttachedToJava = true;

		union {
		struct {
		void* address;
		void* context;
		FreeFunc freeFunc;
		} external;
		struct {
		JavaVM* jvm;
		jweak jweakRef;
		jbyteArray jstrongRef;
		} java;
		} mPixelStorage;
		};

		} // namespace android

		#endif /* BITMAP_H_ */

core/jni/android/graphics/BitmapFactory.cpp

+22 −30

Original line number	Diff line number	Diff line
		@@ -156,13 +156,11 @@ private:

		class RecyclingPixelAllocator : public SkBitmap::Allocator {
		public:
		RecyclingPixelAllocator(SkPixelRef* pixelRef, unsigned int size)
		: mPixelRef(pixelRef), mSize(size) {
		SkSafeRef(mPixelRef);
		RecyclingPixelAllocator(android::Bitmap* bitmap, unsigned int size)
		: mBitmap(bitmap), mSize(size) {
		}

		~RecyclingPixelAllocator() {
		SkSafeUnref(mPixelRef);
		}

		virtual bool allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) {
		@@ -185,11 +183,9 @@ public:
		return false;
		}

		// Create a new pixelref with the new ctable that wraps the previous pixelref
		SkPixelRef* pr = new AndroidPixelRef(static_cast<AndroidPixelRef>(mPixelRef),
		info, bitmap->rowBytes(), ctable);
		mBitmap->reconfigure(info, bitmap->rowBytes(), ctable);
		bitmap->setPixelRef(mBitmap->pixelRef());

		bitmap->setPixelRef(pr)->unref();
		// since we're already allocated, we lockPixels right away
		// HeapAllocator/JavaPixelAllocator behaves this way too
		bitmap->lockPixels();
		@@ -197,7 +193,7 @@ public:
		}

		private:
		SkPixelRef* const mPixelRef;
		android::Bitmap* const mBitmap;
		const unsigned int mSize;
		};

		@@ -258,27 +254,24 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding
		decoder->setPreferQualityOverSpeed(preferQualityOverSpeed);
		decoder->setRequireUnpremultipliedColors(requireUnpremultiplied);

		SkBitmap* outputBitmap = NULL;
		android::Bitmap* reuseBitmap = nullptr;
		unsigned int existingBufferSize = 0;
		if (javaBitmap != NULL) {
		outputBitmap = GraphicsJNI::getSkBitmapDeprecated(env, javaBitmap);
		if (outputBitmap->isImmutable()) {
		reuseBitmap = GraphicsJNI::getBitmap(env, javaBitmap);
		if (reuseBitmap->pixelRef()->isImmutable()) {
		ALOGW("Unable to reuse an immutable bitmap as an image decoder target.");
		javaBitmap = NULL;
		outputBitmap = NULL;
		reuseBitmap = nullptr;
		} else {
		existingBufferSize = GraphicsJNI::getBitmapAllocationByteCount(env, javaBitmap);
		}
		}

		SkAutoTDelete<SkBitmap> adb(outputBitmap == NULL ? new SkBitmap : NULL);
		if (outputBitmap == NULL) outputBitmap = adb.get();

		NinePatchPeeker peeker(decoder);
		decoder->setPeeker(&peeker);

		JavaPixelAllocator javaAllocator(env);
		RecyclingPixelAllocator recyclingAllocator(outputBitmap->pixelRef(), existingBufferSize);
		RecyclingPixelAllocator recyclingAllocator(reuseBitmap, existingBufferSize);
		ScaleCheckingAllocator scaleCheckingAllocator(scale, existingBufferSize);
		SkBitmap::Allocator* outputAllocator = (javaBitmap != NULL) ?
		(SkBitmap::Allocator)&recyclingAllocator : (SkBitmap::Allocator)&javaAllocator;
		@@ -374,6 +367,7 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding
		}
		}

		SkBitmap outputBitmap;
		if (willScale) {
		// This is weird so let me explain: we could use the scale parameter
		// directly, but for historical reasons this is how the corresponding
		@@ -388,26 +382,27 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding
		// FIXME: If the alphaType is kUnpremul and the image has alpha, the
		// colors may not be correct, since Skia does not yet support drawing
		// to/from unpremultiplied bitmaps.
		outputBitmap->setInfo(SkImageInfo::Make(scaledWidth, scaledHeight,
		outputBitmap.setInfo(SkImageInfo::Make(scaledWidth, scaledHeight,
		colorType, decodingBitmap.alphaType()));
		if (!outputBitmap->tryAllocPixels(outputAllocator, NULL)) {
		if (!outputBitmap.tryAllocPixels(outputAllocator, NULL)) {
		return nullObjectReturn("allocation failed for scaled bitmap");
		}

		// If outputBitmap's pixels are newly allocated by Java, there is no need
		// to erase to 0, since the pixels were initialized to 0.
		if (outputAllocator != &javaAllocator) {
		outputBitmap->eraseColor(0);
		outputBitmap.eraseColor(0);
		}

		SkPaint paint;
		paint.setFilterQuality(kLow_SkFilterQuality);

		SkCanvas canvas(*outputBitmap);
		SkCanvas canvas(outputBitmap);
		canvas.scale(sx, sy);
		canvas.drawARGB(0x00, 0x00, 0x00, 0x00);
		canvas.drawBitmap(decodingBitmap, 0.0f, 0.0f, &paint);
		} else {
		outputBitmap->swap(decodingBitmap);
		outputBitmap.swap(decodingBitmap);
		}

		if (padding) {
		@@ -422,22 +417,19 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding

		// if we get here, we're in kDecodePixels_Mode and will therefore
		// already have a pixelref installed.
		if (outputBitmap->pixelRef() == NULL) {
		if (outputBitmap.pixelRef() == NULL) {
		return nullObjectReturn("Got null SkPixelRef");
		}

		if (!isMutable && javaBitmap == NULL) {
		// promise we will never change our pixels (great for sharing and pictures)
		outputBitmap->setImmutable();
		outputBitmap.setImmutable();
		}

		// detach bitmap from its autodeleter, since we want to own it now
		adb.detach();

		if (javaBitmap != NULL) {
		bool isPremultiplied = !requireUnpremultiplied;
		GraphicsJNI::reinitBitmap(env, javaBitmap, outputBitmap, isPremultiplied);
		outputBitmap->notifyPixelsChanged();
		GraphicsJNI::reinitBitmap(env, javaBitmap, outputBitmap.info(), isPremultiplied);
		outputBitmap.notifyPixelsChanged();
		// If a java bitmap was passed in for reuse, pass it back
		return javaBitmap;
		}
		@@ -447,7 +439,7 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding
		if (!requireUnpremultiplied) bitmapCreateFlags \|= GraphicsJNI::kBitmapCreateFlag_Premultiplied;

		// now create the java bitmap
		return GraphicsJNI::createBitmap(env, outputBitmap, javaAllocator.getStorageObj(),
		return GraphicsJNI::createBitmap(env, javaAllocator.getStorageObjAndReset(),
		bitmapCreateFlags, ninePatchChunk, ninePatchInsets, -1);
		}

core/jni/android/graphics/BitmapRegionDecoder.cpp

+8 −16

Original line number	Diff line number	Diff line
		@@ -212,26 +212,21 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle,
		region.fTop = start_y;
		region.fRight = start_x + width;
		region.fBottom = start_y + height;
		SkBitmap* bitmap = NULL;
		SkAutoTDelete<SkBitmap> adb;
		SkBitmap bitmap;

		if (tileBitmap != NULL) {
		// Re-use bitmap.
		bitmap = GraphicsJNI::getSkBitmapDeprecated(env, tileBitmap);
		}
		if (bitmap == NULL) {
		bitmap = new SkBitmap;
		adb.reset(bitmap);
		GraphicsJNI::getSkBitmap(env, tileBitmap, &bitmap);
		}

		if (!brd->decodeRegion(bitmap, region, prefColorType, sampleSize)) {
		if (!brd->decodeRegion(&bitmap, region, prefColorType, sampleSize)) {
		return nullObjectReturn("decoder->decodeRegion returned false");
		}

		// update options (if any)
		if (NULL != options) {
		env->SetIntField(options, gOptions_widthFieldID, bitmap->width());
		env->SetIntField(options, gOptions_heightFieldID, bitmap->height());
		env->SetIntField(options, gOptions_widthFieldID, bitmap.width());
		env->SetIntField(options, gOptions_heightFieldID, bitmap.height());
		// TODO: set the mimeType field with the data from the codec.
		// but how to reuse a set of strings, rather than allocating new one
		// each time?
		@@ -240,19 +235,16 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle,
		}

		if (tileBitmap != NULL) {
		bitmap->notifyPixelsChanged();
		bitmap.notifyPixelsChanged();
		return tileBitmap;
		}

		// detach bitmap from its autodeleter, since we want to own it now
		adb.detach();

		JavaPixelAllocator* allocator = (JavaPixelAllocator*) decoder->getAllocator();
		jbyteArray buff = allocator->getStorageObjAndReset();

		int bitmapCreateFlags = 0;
		if (!requireUnpremultiplied) bitmapCreateFlags \|= GraphicsJNI::kBitmapCreateFlag_Premultiplied;
		return GraphicsJNI::createBitmap(env, bitmap, buff, bitmapCreateFlags, NULL, NULL, -1);
		return GraphicsJNI::createBitmap(env, allocator->getStorageObjAndReset(),
		bitmapCreateFlags);
		}

		static jint nativeGetHeight(JNIEnv* env, jobject, jlong brdHandle) {

core/jni/android/graphics/Graphics.cpp

+34 −86

Original line number	Diff line number	Diff line
		@@ -154,7 +154,7 @@ static jfieldID gPointF_xFieldID;
		static jfieldID gPointF_yFieldID;

		static jclass gBitmap_class;
		static jfieldID gBitmap_skBitmapPtr;
		static jfieldID gBitmap_nativePtr;
		static jmethodID gBitmap_constructorMethodID;
		static jmethodID gBitmap_reinitMethodID;
		static jmethodID gBitmap_getAllocationByteCountMethodID;
		@@ -338,27 +338,22 @@ SkColorType GraphicsJNI::legacyBitmapConfigToColorType(jint legacyConfig) {
		return static_cast<SkColorType>(gConfig2ColorType[legacyConfig]);
		}

		SkBitmap* GraphicsJNI::getSkBitmapDeprecated(JNIEnv* env, jobject bitmap) {
		android::Bitmap* GraphicsJNI::getBitmap(JNIEnv* env, jobject bitmap) {
		SkASSERT(env);
		SkASSERT(bitmap);
		SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class));
		jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_skBitmapPtr);
		SkBitmap* b = reinterpret_cast<SkBitmap*>(bitmapHandle);
		jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativePtr);
		android::Bitmap* b = reinterpret_cast<android::Bitmap*>(bitmapHandle);
		SkASSERT(b);
		return b;
		}

		void GraphicsJNI::getSkBitmap(JNIEnv* env, jobject bitmap, SkBitmap* outBitmap) {
		// TODO: We have to copy from the existing bitmap due to rowBytes not
		// being updated on the SkPixelRef at reconfigure time. This is a short term
		// problem that will be fixed with the specialized wrapper
		outBitmap = getSkBitmapDeprecated(env, bitmap);
		getBitmap(env, bitmap)->getSkBitmap(outBitmap);
		}

		SkPixelRef* GraphicsJNI::getSkPixelRef(JNIEnv* env, jobject bitmap) {
		jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_skBitmapPtr);
		SkBitmap* b = reinterpret_cast<SkBitmap*>(bitmapHandle);
		return b->pixelRef();
		return getBitmap(env, bitmap)->pixelRef();
		}

		SkColorType GraphicsJNI::getNativeBitmapColorType(JNIEnv* env, jobject jconfig) {
		@@ -396,47 +391,43 @@ SkRegion* GraphicsJNI::getNativeRegion(JNIEnv* env, jobject region)
		///////////////////////////////////////////////////////////////////////////////////////////

		// Assert that bitmap's SkAlphaType is consistent with isPremultiplied.
		static void assert_premultiplied(const SkBitmap& bitmap, bool isPremultiplied) {
		static void assert_premultiplied(const SkImageInfo& info, bool isPremultiplied) {
		// kOpaque_SkAlphaType and kIgnore_SkAlphaType mean that isPremultiplied is
		// irrelevant. This just tests to ensure that the SkAlphaType is not
		// opposite of isPremultiplied.
		if (isPremultiplied) {
		SkASSERT(bitmap.alphaType() != kUnpremul_SkAlphaType);
		SkASSERT(info.alphaType() != kUnpremul_SkAlphaType);
		} else {
		SkASSERT(bitmap.alphaType() != kPremul_SkAlphaType);
		SkASSERT(info.alphaType() != kPremul_SkAlphaType);
		}
		}

		jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, jbyteArray buffer,
		int bitmapCreateFlags, jbyteArray ninePatchChunk, jobject ninePatchInsets, int density)
		{
		SkASSERT(bitmap);
		SkASSERT(bitmap->pixelRef());
		SkASSERT(!env->ExceptionCheck());
		jobject GraphicsJNI::createBitmap(JNIEnv* env, android::Bitmap* bitmap,
		int bitmapCreateFlags, jbyteArray ninePatchChunk, jobject ninePatchInsets,
		int density) {
		bool isMutable = bitmapCreateFlags & kBitmapCreateFlag_Mutable;
		bool isPremultiplied = bitmapCreateFlags & kBitmapCreateFlag_Premultiplied;

		// The caller needs to have already set the alpha type properly, so the
		// native SkBitmap stays in sync with the Java Bitmap.
		assert_premultiplied(*bitmap, isPremultiplied);
		assert_premultiplied(bitmap->info(), isPremultiplied);

		jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID,
		reinterpret_cast<jlong>(bitmap), buffer,
		reinterpret_cast<jlong>(bitmap), bitmap->javaByteArray(),
		bitmap->width(), bitmap->height(), density, isMutable, isPremultiplied,
		ninePatchChunk, ninePatchInsets);
		hasException(env); // For the side effect of logging.
		return obj;
		}

		void GraphicsJNI::reinitBitmap(JNIEnv* env, jobject javaBitmap, SkBitmap* bitmap,
		void GraphicsJNI::reinitBitmap(JNIEnv* env, jobject javaBitmap, const SkImageInfo& info,
		bool isPremultiplied)
		{
		// The caller needs to have already set the alpha type properly, so the
		// native SkBitmap stays in sync with the Java Bitmap.
		assert_premultiplied(*bitmap, isPremultiplied);
		assert_premultiplied(info, isPremultiplied);

		env->CallVoidMethod(javaBitmap, gBitmap_reinitMethodID,
		bitmap->width(), bitmap->height(), isPremultiplied);
		info.width(), info.height(), isPremultiplied);
		}

		int GraphicsJNI::getBitmapAllocationByteCount(JNIEnv* env, jobject javaBitmap)
		@@ -477,51 +468,6 @@ static JNIEnv* vm2env(JavaVM* vm)

		///////////////////////////////////////////////////////////////////////////////

		AndroidPixelRef::AndroidPixelRef(JNIEnv* env, const SkImageInfo& info, void* storage,
		size_t rowBytes, jbyteArray storageObj, SkColorTable* ctable) :
		SkMallocPixelRef(info, storage, rowBytes, ctable, (storageObj == NULL)),
		fWrappedPixelRef(NULL) {
		SkASSERT(storage);
		SkASSERT(storageObj);
		SkASSERT(env);

		if (env->GetJavaVM(&fVM) != JNI_OK) {
		SkDebugf("------ [%p] env->GetJavaVM failed\n", env);
		sk_throw();
		}

		fStorageObj = (jbyteArray) env->NewGlobalRef(storageObj);
		}

		AndroidPixelRef::AndroidPixelRef(AndroidPixelRef& wrappedPixelRef, const SkImageInfo& info,
		size_t rowBytes, SkColorTable* ctable) :
		SkMallocPixelRef(info, wrappedPixelRef.getAddr(), rowBytes, ctable, false),
		fWrappedPixelRef(wrappedPixelRef.fWrappedPixelRef ?
		wrappedPixelRef.fWrappedPixelRef : &wrappedPixelRef)
		{
		SkASSERT(fWrappedPixelRef);
		SkSafeRef(fWrappedPixelRef);

		// don't need to initialize this, as all the relevant logic delegates to the wrapped ref
		fStorageObj = NULL;
		}

		AndroidPixelRef::~AndroidPixelRef() {
		if (fWrappedPixelRef) {
		SkSafeUnref(fWrappedPixelRef);
		} else {
		SkASSERT(fStorageObj);
		JNIEnv* env = vm2env(fVM);
		env->DeleteGlobalRef(fStorageObj);
		}

		if (android::uirenderer::Caches::hasInstance()) {
		android::uirenderer::Caches::getInstance().textureCache.releaseTexture(getStableID());
		}
		}

		///////////////////////////////////////////////////////////////////////////////

		static bool computeAllocationSize(const SkBitmap& bitmap, size_t* size) {
		int32_t rowBytes32 = SkToS32(bitmap.rowBytes());
		int64_t bigSize = (int64_t)bitmap.height() * rowBytes32;
		@@ -533,7 +479,7 @@ static bool computeAllocationSize(const SkBitmap& bitmap, size_t* size) {
		return true;
		}

		jbyteArray GraphicsJNI::allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap,
		android::Bitmap* GraphicsJNI::allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap,
		SkColorTable* ctable) {
		const SkImageInfo& info = bitmap->info();
		if (info.fColorType == kUnknown_SkColorType) {
		@@ -562,13 +508,14 @@ jbyteArray GraphicsJNI::allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap,
		return NULL;
		}
		SkASSERT(addr);
		SkPixelRef* pr = new AndroidPixelRef(env, info, (void*) addr, rowBytes, arrayObj, ctable);
		bitmap->setPixelRef(pr)->unref();
		android::Bitmap* wrapper = new android::Bitmap(env, arrayObj, (void*) addr,
		info, rowBytes, ctable);
		wrapper->getSkBitmap(bitmap);
		// since we're already allocated, we lockPixels right away
		// HeapAllocator behaves this way too
		bitmap->lockPixels();

		return arrayObj;
		return wrapper;
		}

		struct AndroidPixelRefContext {
		@@ -627,21 +574,22 @@ bool GraphicsJNI::allocatePixels(JNIEnv* env, SkBitmap* bitmap, SkColorTable* ct

		///////////////////////////////////////////////////////////////////////////////

		JavaPixelAllocator::JavaPixelAllocator(JNIEnv* env)
		: fStorageObj(NULL),
		fAllocCount(0) {
		if (env->GetJavaVM(&fVM) != JNI_OK) {
		SkDebugf("------ [%p] env->GetJavaVM failed\n", env);
		sk_throw();
		JavaPixelAllocator::JavaPixelAllocator(JNIEnv* env) {
		LOG_ALWAYS_FATAL_IF(env->GetJavaVM(&mJavaVM) != JNI_OK,
		"env->GetJavaVM failed");
		}

		JavaPixelAllocator::~JavaPixelAllocator() {
		if (mStorage) {
		mStorage->detachFromJava();
		}
		}

		bool JavaPixelAllocator::allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) {
		JNIEnv* env = vm2env(fVM);
		JNIEnv* env = vm2env(mJavaVM);

		fStorageObj = GraphicsJNI::allocateJavaPixelRef(env, bitmap, ctable);
		fAllocCount += 1;
		return fStorageObj != NULL;
		mStorage = GraphicsJNI::allocateJavaPixelRef(env, bitmap, ctable);
		return mStorage != nullptr;
		}

		////////////////////////////////////////////////////////////////////////////////
		@@ -687,7 +635,7 @@ int register_android_graphics_Graphics(JNIEnv* env)
		gPointF_yFieldID = getFieldIDCheck(env, gPointF_class, "y", "F");

		gBitmap_class = make_globalref(env, "android/graphics/Bitmap");
		gBitmap_skBitmapPtr = getFieldIDCheck(env, gBitmap_class, "mSkBitmapPtr", "J");
		gBitmap_nativePtr = getFieldIDCheck(env, gBitmap_class, "mNativePtr", "J");
		gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", "(J[BIIIZZ[BLandroid/graphics/NinePatch$InsetStruct;)V");
		gBitmap_reinitMethodID = env->GetMethodID(gBitmap_class, "reinit", "(IIZ)V");
		gBitmap_getAllocationByteCountMethodID = env->GetMethodID(gBitmap_class, "getAllocationByteCount", "()I");