Merge "Use android::skia::BitmapRegionDecoder" (d567bb67) · Commits · e / os / android_frameworks_base

libs/hwui/jni/BitmapFactory.cpp

+0 −1

Original line number	Diff line number	Diff line
		@@ -8,7 +8,6 @@
		#include "MimeType.h"
		#include "NinePatchPeeker.h"
		#include "SkAndroidCodec.h"
		#include "SkBRDAllocator.h"
		#include "SkMath.h"
		#include "SkPixelRef.h"
		#include "SkStream.h"

libs/hwui/jni/BitmapRegionDecoder.cpp

+18 −35

Original line number	Diff line number	Diff line
		@@ -22,8 +22,8 @@
		#include "GraphicsJNI.h"
		#include "Utils.h"

		#include "BitmapRegionDecoder.h"
		#include "SkBitmap.h"
		#include "SkBitmapRegionDecoder.h"
		#include "SkCodec.h"
		#include "SkData.h"
		#include "SkStream.h"
		@@ -36,10 +36,8 @@

		using namespace android;

		static jobject createBitmapRegionDecoder(JNIEnv* env, std::unique_ptr<SkStreamRewindable> stream) {
		std::unique_ptr<SkBitmapRegionDecoder> brd(
		SkBitmapRegionDecoder::Create(stream.release(),
		SkBitmapRegionDecoder::kAndroidCodec_Strategy));
		static jobject createBitmapRegionDecoder(JNIEnv* env, sk_sp<SkData> data) {
		auto brd = skia::BitmapRegionDecoder::Make(std::move(data));
		if (!brd) {
		doThrowIOE(env, "Image format not supported");
		return nullObjectReturn("CreateBitmapRegionDecoder returned null");
		@@ -51,11 +49,7 @@ static jobject createBitmapRegionDecoder(JNIEnv* env, std::unique_ptr<SkStreamRe
		static jobject nativeNewInstanceFromByteArray(JNIEnv* env, jobject, jbyteArray byteArray,
		jint offset, jint length) {
		AutoJavaByteArray ar(env, byteArray);
		std::unique_ptr<SkMemoryStream> stream(new SkMemoryStream(ar.ptr() + offset, length, true));

		// the decoder owns the stream.
		jobject brd = createBitmapRegionDecoder(env, std::move(stream));
		return brd;
		return createBitmapRegionDecoder(env, SkData::MakeWithCopy(ar.ptr() + offset, length));
		}

		static jobject nativeNewInstanceFromFileDescriptor(JNIEnv* env, jobject clazz,
		@@ -70,36 +64,28 @@ static jobject nativeNewInstanceFromFileDescriptor(JNIEnv* env, jobject clazz,
		return nullObjectReturn("fstat return -1");
		}

		sk_sp<SkData> data(SkData::MakeFromFD(descriptor));
		std::unique_ptr<SkMemoryStream> stream(new SkMemoryStream(std::move(data)));

		// the decoder owns the stream.
		jobject brd = createBitmapRegionDecoder(env, std::move(stream));
		return brd;
		return createBitmapRegionDecoder(env, SkData::MakeFromFD(descriptor));
		}

		static jobject nativeNewInstanceFromStream(JNIEnv* env, jobject clazz, jobject is, // InputStream
		jbyteArray storage) { // byte[]
		jobject brd = NULL;
		std::unique_ptr<SkStreamRewindable> stream(CopyJavaInputStream(env, is, storage));
		jobject brd = nullptr;
		sk_sp<SkData> data = CopyJavaInputStream(env, is, storage);

		if (stream) {
		// the decoder owns the stream.
		brd = createBitmapRegionDecoder(env, std::move(stream));
		if (data) {
		brd = createBitmapRegionDecoder(env, std::move(data));
		}
		return brd;
		}

		static jobject nativeNewInstanceFromAsset(JNIEnv* env, jobject clazz, jlong native_asset) {
		Asset* asset = reinterpret_cast<Asset*>(native_asset);
		std::unique_ptr<SkMemoryStream> stream(CopyAssetToStream(asset));
		if (NULL == stream) {
		return NULL;
		sk_sp<SkData> data = CopyAssetToData(asset);
		if (!data) {
		return nullptr;
		}

		// the decoder owns the stream.
		jobject brd = createBitmapRegionDecoder(env, std::move(stream));
		return brd;
		return createBitmapRegionDecoder(env, data);
		}

		/*
		@@ -149,7 +135,7 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle, jint in
		recycledBytes = recycledBitmap->getAllocationByteCount();
		}

		SkBitmapRegionDecoder* brd = reinterpret_cast<SkBitmapRegionDecoder*>(brdHandle);
		auto* brd = reinterpret_cast<skia::BitmapRegionDecoder*>(brdHandle);
		SkColorType decodeColorType = brd->computeOutputColorType(colorType);
		if (decodeColorType == kRGBA_F16_SkColorType && isHardware &&
		!uirenderer::HardwareBitmapUploader::hasFP16Support()) {
		@@ -157,7 +143,7 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle, jint in
		}

		// Set up the pixel allocator
		SkBRDAllocator* allocator = nullptr;
		skia::BRDAllocator* allocator = nullptr;
		RecyclingClippingPixelAllocator recycleAlloc(recycledBitmap, recycledBytes);
		HeapAllocator heapAlloc;
		if (javaBitmap) {
		@@ -221,20 +207,17 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle, jint in
		}

		static jint nativeGetHeight(JNIEnv* env, jobject, jlong brdHandle) {
		SkBitmapRegionDecoder* brd =
		reinterpret_cast<SkBitmapRegionDecoder*>(brdHandle);
		auto* brd = reinterpret_cast<skia::BitmapRegionDecoder*>(brdHandle);
		return static_cast<jint>(brd->height());
		}

		static jint nativeGetWidth(JNIEnv* env, jobject, jlong brdHandle) {
		SkBitmapRegionDecoder* brd =
		reinterpret_cast<SkBitmapRegionDecoder*>(brdHandle);
		auto* brd = reinterpret_cast<skia::BitmapRegionDecoder*>(brdHandle);
		return static_cast<jint>(brd->width());
		}

		static void nativeClean(JNIEnv* env, jobject, jlong brdHandle) {
		SkBitmapRegionDecoder* brd =
		reinterpret_cast<SkBitmapRegionDecoder*>(brdHandle);
		auto* brd = reinterpret_cast<skia::BitmapRegionDecoder*>(brdHandle);
		delete brd;
		}

libs/hwui/jni/CreateJavaOutputStreamAdaptor.cpp

+7 −14

Original line number	Diff line number	Diff line
		@@ -177,8 +177,12 @@ SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream, jbyteArray s
		return JavaInputStreamAdaptor::Create(env, stream, storage, swallowExceptions);
		}

		static SkMemoryStream* adaptor_to_mem_stream(SkStream* stream) {
		SkASSERT(stream != NULL);
		sk_sp<SkData> CopyJavaInputStream(JNIEnv* env, jobject inputStream, jbyteArray storage) {
		std::unique_ptr<SkStream> stream(CreateJavaInputStreamAdaptor(env, inputStream, storage));
		if (!stream) {
		return nullptr;
		}

		size_t bufferSize = 4096;
		size_t streamLen = 0;
		size_t len;
		@@ -194,18 +198,7 @@ static SkMemoryStream* adaptor_to_mem_stream(SkStream* stream) {
		}
		data = (char*)sk_realloc_throw(data, streamLen);

		SkMemoryStream* streamMem = new SkMemoryStream();
		streamMem->setMemoryOwned(data, streamLen);
		return streamMem;
		}

		SkStreamRewindable* CopyJavaInputStream(JNIEnv* env, jobject stream,
		jbyteArray storage) {
		std::unique_ptr<SkStream> adaptor(CreateJavaInputStreamAdaptor(env, stream, storage));
		if (NULL == adaptor.get()) {
		return NULL;
		}
		return adaptor_to_mem_stream(adaptor.get());
		return SkData::MakeFromMalloc(data, streamLen);
		}

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

libs/hwui/jni/CreateJavaOutputStreamAdaptor.h

+4 −4

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@
		#define _ANDROID_GRAPHICS_CREATE_JAVA_OUTPUT_STREAM_ADAPTOR_H_

		#include "jni.h"
		#include "SkData.h"

		class SkMemoryStream;
		class SkStream;
		@@ -27,15 +28,14 @@ SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream, jbyteArray s
		bool swallowExceptions = true);

		/**
		* Copy a Java InputStream. The result will be rewindable.
		* Copy a Java InputStream to an SkData.
		* @param env JNIEnv object.
		* @param stream Pointer to Java InputStream.
		* @param storage Java byte array for retrieving data from the
		* Java InputStream.
		* @return SkStreamRewindable The data in stream will be copied
		* to a new SkStreamRewindable.
		* @return SkData containing the stream's data.
		*/
		SkStreamRewindable* CopyJavaInputStream(JNIEnv* env, jobject stream, jbyteArray storage);
		sk_sp<SkData> CopyJavaInputStream(JNIEnv* env, jobject stream, jbyteArray storage);

		SkWStream* CreateJavaOutputStreamAdaptor(JNIEnv* env, jobject stream, jbyteArray storage);

libs/hwui/jni/Graphics.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -470,7 +470,7 @@ SkRegion* GraphicsJNI::getNativeRegion(JNIEnv* env, jobject region)

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

		jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap)
		jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, skia::BitmapRegionDecoder* bitmap)
		{
		ALOG_ASSERT(bitmap != NULL);