Merge "Move allocatePixelRef methods to hwui. This patch also makes tests to... (7ca5ad1d) · Commits · e / os / android_frameworks_base

core/jni/android/graphics/Bitmap.cpp

+7 −8

Original line number	Diff line number	Diff line
		@@ -548,7 +548,7 @@ static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,
		bitmap.setInfo(SkImageInfo::Make(width, height, colorType, kPremul_SkAlphaType,
		GraphicsJNI::defaultColorSpace()));

		PixelRef* nativeBitmap = GraphicsJNI::allocateHeapPixelRef(&bitmap, NULL);
		sk_sp<PixelRef> nativeBitmap = PixelRef::allocateHeapPixelRef(&bitmap, NULL);
		if (!nativeBitmap) {
		return NULL;
		}
		@@ -558,8 +558,7 @@ static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,
		0, 0, width, height, bitmap);
		}

		return createBitmap(env, nativeBitmap,
		getPremulBitmapCreateFlags(isMutable));
		return createBitmap(env, nativeBitmap.release(), getPremulBitmapCreateFlags(isMutable));
		}

		static jobject Bitmap_copy(JNIEnv* env, jobject, jlong srcHandle,
		@@ -832,7 +831,7 @@ static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) {
		}

		// Map the bitmap in place from the ashmem region if possible otherwise copy.
		PixelRef* nativeBitmap;
		sk_sp<PixelRef> nativeBitmap;
		if (blob.fd() >= 0 && (blob.isMutable() \|\| !isMutable) && (size >= ASHMEM_BITMAP_MIN_SIZE)) {
		#if DEBUG_PARCEL
		ALOGD("Bitmap.createFromParcel: mapped contents of %s bitmap from %s blob "
		@@ -853,8 +852,8 @@ static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) {
		}

		// 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()), size, !isMutable);
		nativeBitmap = sk_sp<PixelRef>(GraphicsJNI::mapAshmemPixelRef(env, bitmap.get(),
		ctable, dupFd, const_cast<void*>(blob.data()), size, !isMutable));
		SkSafeUnref(ctable);
		if (!nativeBitmap) {
		close(dupFd);
		@@ -880,7 +879,7 @@ static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) {
		#endif

		// Copy the pixels into a new buffer.
		nativeBitmap = GraphicsJNI::allocateHeapPixelRef(bitmap.get(), ctable);
		nativeBitmap = PixelRef::allocateHeapPixelRef(bitmap.get(), ctable);
		SkSafeUnref(ctable);
		if (!nativeBitmap) {
		blob.release();
		@@ -895,7 +894,7 @@ static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) {
		blob.release();
		}

		return createBitmap(env, nativeBitmap,
		return createBitmap(env, nativeBitmap.release(),
		getPremulBitmapCreateFlags(isMutable), NULL, NULL, density);
		}

core/jni/android/graphics/Graphics.cpp

+2 −155

Original line number	Diff line number	Diff line
		@@ -399,160 +399,8 @@ jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region)
		return obj;
		}

		static JNIEnv* vm2env(JavaVM* vm)
		{
		JNIEnv* env = NULL;
		if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK \|\| NULL == env)
		{
		SkDebugf("------- [%p] vm->GetEnv() failed\n", vm);
		sk_throw();
		}
		return env;
		}

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

		static bool computeAllocationSize(const SkBitmap& bitmap, size_t* size) {
		int32_t rowBytes32 = SkToS32(bitmap.rowBytes());
		int64_t bigSize = (int64_t)bitmap.height() * rowBytes32;
		if (rowBytes32 < 0 \|\| !sk_64_isS32(bigSize)) {
		return false; // allocation will be too large
		}

		*size = sk_64_asS32(bigSize);
		return true;
		}

		android::PixelRef* GraphicsJNI::allocateHeapPixelRef(SkBitmap* bitmap, SkColorTable* ctable) {
		const SkImageInfo& info = bitmap->info();
		if (info.colorType() == kUnknown_SkColorType) {
		LOG_ALWAYS_FATAL("unknown bitmap configuration");
		return nullptr;
		}

		size_t size;
		if (!computeAllocationSize(*bitmap, &size)) {
		return nullptr;
		}

		// we must respect the rowBytes value already set on the bitmap instead of
		// attempting to compute our own.
		const size_t rowBytes = bitmap->rowBytes();

		void* addr = calloc(size, 1);
		if (!addr) {
		return nullptr;
		}

		auto wrapper = new android::PixelRef(addr, size, info, rowBytes, ctable);
		wrapper->getSkBitmap(bitmap);
		// since we're already allocated, we lockPixels right away
		// HeapAllocator behaves this way too
		bitmap->lockPixels();

		return wrapper;
		}

		struct AndroidPixelRefContext {
		int32_t stableID;
		};

		static void allocatePixelsReleaseProc(void* ptr, void* ctx) {
		AndroidPixelRefContext* context = (AndroidPixelRefContext*)ctx;
		if (android::uirenderer::Caches::hasInstance()) {
		android::uirenderer::Caches::getInstance().textureCache.releaseTexture(context->stableID);
		}

		sk_free(ptr);
		delete context;
		}

		bool GraphicsJNI::allocatePixels(JNIEnv* env, SkBitmap* bitmap, SkColorTable* ctable) {
		const SkImageInfo& info = bitmap->info();
		if (info.colorType() == kUnknown_SkColorType) {
		doThrowIAE(env, "unknown bitmap configuration");
		return NULL;
		}

		size_t size;
		if (!computeAllocationSize(*bitmap, &size)) {
		return false;
		}

		// we must respect the rowBytes value already set on the bitmap instead of
		// attempting to compute our own.
		const size_t rowBytes = bitmap->rowBytes();

		void* addr = sk_malloc_flags(size, 0);
		if (NULL == addr) {
		return false;
		}

		AndroidPixelRefContext* context = new AndroidPixelRefContext;
		SkMallocPixelRef* pr = SkMallocPixelRef::NewWithProc(info, rowBytes, ctable, addr,
		&allocatePixelsReleaseProc, context);
		if (!pr) {
		delete context;
		return false;
		}

		// set the stableID in the context so that it can be used later in
		// allocatePixelsReleaseProc to remove the texture from the cache.
		context->stableID = pr->getStableID();

		bitmap->setPixelRef(pr)->unref();
		// since we're already allocated, we can lockPixels right away
		bitmap->lockPixels();

		return true;
		}

		android::PixelRef* GraphicsJNI::allocateAshmemPixelRef(JNIEnv* env, SkBitmap* bitmap,
		SkColorTable* ctable) {
		int fd;

		const SkImageInfo& info = bitmap->info();
		if (info.colorType() == kUnknown_SkColorType) {
		doThrowIAE(env, "unknown bitmap configuration");
		return nullptr;
		}

		size_t size;
		if (!computeAllocationSize(*bitmap, &size)) {
		return nullptr;
		}

		// we must respect the rowBytes value already set on the bitmap instead of
		// attempting to compute our own.
		const size_t rowBytes = bitmap->rowBytes();

		// Create new ashmem region with read/write priv
		fd = ashmem_create_region("bitmap", size);
		if (fd < 0) {
		return nullptr;
		}

		void* addr = mmap(NULL, size, PROT_READ \| PROT_WRITE, MAP_SHARED, fd, 0);
		if (addr == MAP_FAILED) {
		close(fd);
		return nullptr;
		}

		if (ashmem_set_prot_region(fd, PROT_READ) < 0) {
		munmap(addr, size);
		close(fd);
		return nullptr;
		}

		auto wrapper = new android::PixelRef(addr, fd, size, info, rowBytes, ctable);
		wrapper->getSkBitmap(bitmap);
		// since we're already allocated, we lockPixels right away
		// HeapAllocator behaves this way too
		bitmap->lockPixels();

		return wrapper;
		}

		android::PixelRef* GraphicsJNI::mapAshmemPixelRef(JNIEnv* env, SkBitmap* bitmap,
		SkColorTable* ctable, int fd, void* addr, size_t size, bool readOnly) {
		const SkImageInfo& info = bitmap->info();
		@@ -597,7 +445,7 @@ sk_sp<SkColorSpace> GraphicsJNI::defaultColorSpace() {

		///////////////////////////////////////////////////////////////////////////////
		bool HeapAllocator::allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) {
		mStorage.reset(GraphicsJNI::allocateHeapPixelRef(bitmap, ctable));
		mStorage = android::PixelRef::allocateHeapPixelRef(bitmap, ctable);
		return !!mStorage;
		}

		@@ -702,8 +550,7 @@ AshmemPixelAllocator::AshmemPixelAllocator(JNIEnv *env) {
		}

		bool AshmemPixelAllocator::allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) {
		JNIEnv* env = vm2env(mJavaVM);
		mStorage.reset(GraphicsJNI::allocateAshmemPixelRef(env, bitmap, ctable));
		mStorage = android::PixelRef::allocateAshmemPixelRef(bitmap, ctable);
		return !!mStorage;
		}

core/jni/android/graphics/GraphicsJNI.h

+0 −5

Original line number	Diff line number	Diff line
		@@ -72,11 +72,6 @@ public:

		static jobject createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap);

		static android::PixelRef* allocateHeapPixelRef(SkBitmap* bitmap, SkColorTable* ctable);

		static android::PixelRef* allocateAshmemPixelRef(JNIEnv* env, SkBitmap* bitmap,
		SkColorTable* ctable);

		static android::PixelRef* mapAshmemPixelRef(JNIEnv* env, SkBitmap* bitmap,
		SkColorTable* ctable, int fd, void* addr, size_t size, bool readOnly);

core/jni/android_graphics_Canvas.cpp

+2 −1

Original line number	Diff line number	Diff line
		@@ -446,7 +446,8 @@ static void drawBitmapArray(JNIEnv* env, jobject, jlong canvasHandle,
		GraphicsJNI::defaultColorSpace());
		SkBitmap bitmap;
		bitmap.setInfo(info);
		if (!GraphicsJNI::allocatePixels(env, &bitmap, NULL)) {
		sk_sp<PixelRef> pixelRef = PixelRef::allocateHeapPixelRef(&bitmap, NULL);
		if (!pixelRef) {
		return;
		}

libs/hwui/hwui/PixelRef.cpp

+78 −0

Original line number	Diff line number	Diff line
		@@ -23,6 +23,84 @@

		namespace android {

		static bool computeAllocationSize(const SkBitmap& bitmap, size_t* size) {
		int32_t rowBytes32 = SkToS32(bitmap.rowBytes());
		int64_t bigSize = (int64_t)bitmap.height() * rowBytes32;
		if (rowBytes32 < 0 \|\| !sk_64_isS32(bigSize)) {
		return false; // allocation will be too large
		}

		*size = sk_64_asS32(bigSize);
		return true;
		}

		typedef sk_sp<PixelRef> (*AllocPixeRef)(size_t allocSize, const SkImageInfo& info, size_t rowBytes,
		SkColorTable* ctable);

		static sk_sp<PixelRef> allocatePixelRef(SkBitmap* bitmap, SkColorTable* ctable, AllocPixeRef alloc) {
		const SkImageInfo& info = bitmap->info();
		if (info.colorType() == kUnknown_SkColorType) {
		LOG_ALWAYS_FATAL("unknown bitmap configuration");
		return nullptr;
		}

		size_t size;
		if (!computeAllocationSize(*bitmap, &size)) {
		return nullptr;
		}

		// we must respect the rowBytes value already set on the bitmap instead of
		// attempting to compute our own.
		const size_t rowBytes = bitmap->rowBytes();
		auto wrapper = alloc(size, info, rowBytes, ctable);
		if (wrapper) {
		wrapper->getSkBitmap(bitmap);
		// since we're already allocated, we lockPixels right away
		// HeapAllocator behaves this way too
		bitmap->lockPixels();
		}
		return wrapper;
		}

		sk_sp<PixelRef> PixelRef::allocateHeapPixelRef(SkBitmap* bitmap, SkColorTable* ctable) {
		return allocatePixelRef(bitmap, ctable, &PixelRef::allocateHeapPixelRef);
		}

		sk_sp<PixelRef> PixelRef::allocateAshmemPixelRef(SkBitmap* bitmap, SkColorTable* ctable) {
		return allocatePixelRef(bitmap, ctable, &PixelRef::allocateAshmemPixelRef);
		}

		sk_sp<PixelRef> PixelRef::allocateHeapPixelRef(size_t size, const SkImageInfo& info, size_t rowBytes,
		SkColorTable* ctable) {
		void* addr = calloc(size, 1);
		if (!addr) {
		return nullptr;
		}
		return sk_sp<PixelRef>(new PixelRef(addr, size, info, rowBytes, ctable));
		}

		sk_sp<PixelRef> PixelRef::allocateAshmemPixelRef(size_t size, const SkImageInfo& info,
		size_t rowBytes, SkColorTable* ctable) {
		// Create new ashmem region with read/write priv
		int fd = ashmem_create_region("bitmap", size);
		if (fd < 0) {
		return nullptr;
		}

		void* addr = mmap(NULL, size, PROT_READ \| PROT_WRITE, MAP_SHARED, fd, 0);
		if (addr == MAP_FAILED) {
		close(fd);
		return nullptr;
		}

		if (ashmem_set_prot_region(fd, PROT_READ) < 0) {
		munmap(addr, size);
		close(fd);
		return nullptr;
		}
		return sk_sp<PixelRef>(new PixelRef(addr, fd, size, info, rowBytes, ctable));
		}

		void PixelRef::reconfigure(const SkImageInfo& newInfo, size_t rowBytes, SkColorTable* ctable) {
		if (kIndex_8_SkColorType != newInfo.colorType()) {
		ctable = nullptr;