Merge "Revert "Fix recent apps in system UI for Skia pipeline"" into oc-dev (9217cb52) · Commits · e / os / android_frameworks_base

core/jni/android/graphics/Shader.cpp

+3 −6

Original line number	Diff line number	Diff line
		@@ -60,17 +60,14 @@ static void Shader_safeUnref(JNIEnv* env, jobject o, jlong shaderHandle) {
		static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong matrixPtr, jobject jbitmap,
		jint tileModeX, jint tileModeY) {
		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
		sk_sp<SkImage> image;
		SkBitmap bitmap;
		if (jbitmap) {
		// Only pass a valid SkBitmap object to the constructor if the Bitmap exists. Otherwise,
		// we'll pass an empty SkBitmap to avoid crashing/excepting for compatibility.
		image = android::bitmap::toBitmap(env, jbitmap).makeImage(nullptr);
		android::bitmap::toBitmap(env, jbitmap).getSkBitmapForShaders(&bitmap);
		}

		if (!image.get()) {
		SkBitmap bitmap;
		image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode);
		}
		sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode);
		sk_sp<SkShader> baseShader = image->makeShader(
		(SkShader::TileMode)tileModeX, (SkShader::TileMode)tileModeY);

libs/hwui/hwui/Bitmap.cpp

+3 −38

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@
		#include "Bitmap.h"

		#include "Caches.h"
		#include "pipeline/skia/SkiaOpenGLPipeline.h"
		#include "renderthread/EglManager.h"
		#include "renderthread/RenderThread.h"
		#include "renderthread/RenderProxy.h"
		@@ -35,15 +34,11 @@
		#include <private/gui/ComposerService.h>
		#include <binder/IServiceManager.h>
		#include <ui/PixelFormat.h>
		#include <GrTexture.h>

		#include <SkCanvas.h>
		#include <SkImagePriv.h>

		namespace android {

		Mutex Bitmap::gLock;

		static bool computeAllocationSize(size_t rowBytes, int height, size_t* size) {
		int32_t rowBytes32 = SkToS32(rowBytes);
		int64_t bigSize = (int64_t) height * rowBytes32;
		@@ -322,7 +317,8 @@ sk_sp<Bitmap> Bitmap::createFrom(sp<GraphicBuffer> graphicBuffer) {
		return nullptr;
		}
		SkImageInfo info = SkImageInfo::Make(graphicBuffer->getWidth(), graphicBuffer->getHeight(),
		kRGBA_8888_SkColorType, kPremul_SkAlphaType, SkColorSpace::MakeSRGB());
		kRGBA_8888_SkColorType, kPremul_SkAlphaType,
		SkColorSpace::MakeSRGB());
		return sk_sp<Bitmap>(new Bitmap(graphicBuffer.get(), info));
		}

		@@ -397,7 +393,6 @@ Bitmap::Bitmap(GraphicBuffer* buffer, const SkImageInfo& info)
		mPixelStorage.hardware.buffer = buffer;
		buffer->incStrong(buffer);
		mRowBytes = bytesPerPixel(buffer->getPixelFormat()) * buffer->getStride();
		setImmutable(); // HW bitmaps are always immutable
		}

		Bitmap::~Bitmap() {
		@@ -491,13 +486,7 @@ void Bitmap::setAlphaType(SkAlphaType alphaType) {
		void Bitmap::getSkBitmap(SkBitmap* outBitmap) {
		outBitmap->setHasHardwareMipMap(mHasHardwareMipMap);
		if (isHardware()) {
		if (uirenderer::Properties::isSkiaEnabled()) {
		// TODO: add color correctness for Skia pipeline - pass null color space for now
		outBitmap->allocPixels(SkImageInfo::Make(info().width(), info().height(),
		info().colorType(), info().alphaType(), nullptr));
		} else {
		outBitmap->allocPixels(info());
		}
		uirenderer::renderthread::RenderProxy::copyGraphicBufferInto(graphicBuffer(), outBitmap);
		return;
		}
		@@ -523,28 +512,4 @@ GraphicBuffer* Bitmap::graphicBuffer() {
		return nullptr;
		}

		sk_sp<SkImage> Bitmap::makeImage(const uirenderer::renderthread::RenderThread* renderThread) {
		AutoMutex _lock(gLock); //TODO: implement lock free solution
		auto image = mImage;
		//TODO: use new API SkImage::isValid() instead of SkImage::getTexture()->getContext()
		if (!image.get() \|\| (image->getTexture() && nullptr == image->getTexture()->getContext())) {
		if (isHardware() && uirenderer::RenderPipelineType::SkiaGL
		== uirenderer::Properties::getRenderPipelineType()) {
		//TODO: add Vulkan support
		if (renderThread) {
		image = uirenderer::skiapipeline::SkiaOpenGLPipeline::makeTextureImage(
		*renderThread, this);
		} else {
		image = uirenderer::renderthread::RenderProxy::makeTextureImage(this);
		}
		} else {
		SkBitmap skiaBitmap;
		getSkBitmapForShaders(&skiaBitmap);
		image = SkMakeImageFromRasterBitmap(skiaBitmap, kNever_SkCopyPixelsMode);
		}
		mImage = image;
		}
		return image;
		}

		} // namespace android

libs/hwui/hwui/Bitmap.h

+0 −12

Original line number	Diff line number	Diff line
		@@ -22,8 +22,6 @@
		#include <SkPixelRef.h>
		#include <cutils/compiler.h>
		#include <ui/GraphicBuffer.h>
		#include <utils/Mutex.h>
		#include <SkImage.h>

		namespace android {

		@@ -113,13 +111,6 @@ public:
		}

		GraphicBuffer* graphicBuffer();

		// makeImage creates or returns a cached SkImage. Can be invoked from UI or render thread.
		// If invoked on the render thread, then RenderThread* argument is required.
		// If not invoked on the render thread, then RenderThread* must be nullptr.
		// makeImage is wrapping a gralloc buffer with an EGLImage and is passing a texture to Skia.
		// This is a temporary implementation until Skia can wrap the gralloc buffer in a SkImage.
		sk_sp<SkImage> makeImage(const uirenderer::renderthread::RenderThread*);
		protected:
		virtual bool onNewLockPixels(LockRec* rec) override;
		virtual void onUnlockPixels() override { };
		@@ -154,9 +145,6 @@ private:
		GraphicBuffer* buffer;
		} hardware;
		} mPixelStorage;

		sk_sp<SkImage> mImage;
		static Mutex gLock;
		};

		} //namespace android
		No newline at end of file

libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp

+0 −83

Original line number	Diff line number	Diff line
		@@ -28,8 +28,6 @@

		#include <cutils/properties.h>
		#include <strings.h>
		#include <SkImagePriv.h>
		#include <gl/GrGLTypes.h>

		using namespace android::uirenderer::renderthread;

		@@ -199,87 +197,6 @@ void SkiaOpenGLPipeline::invokeFunctor(const RenderThread& thread, Functor* func
		}
		}

		static void deleteImageTexture(void* context) {
		EGLImageKHR EGLimage = reinterpret_cast<EGLImageKHR>(context);
		if (EGLimage != EGL_NO_IMAGE_KHR) {
		EGLDisplay display = eglGetCurrentDisplay();
		if (EGL_NO_DISPLAY == display) {
		display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
		}
		eglDestroyImageKHR(display, EGLimage);
		}
		}

		sk_sp<SkImage> SkiaOpenGLPipeline::makeTextureImage(
		const uirenderer::renderthread::RenderThread& renderThread, Bitmap* bitmap) {
		renderThread.eglManager().initialize();

		GraphicBuffer* buffer = bitmap->graphicBuffer();
		EGLDisplay display = eglGetCurrentDisplay();
		if (EGL_NO_DISPLAY == display) {
		display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
		}
		LOG_ALWAYS_FATAL_IF(!bitmap->isHardware(),
		"Texture image requires a HW bitmap.");
		// We use an EGLImage to access the content of the GraphicBuffer
		// The EGL image is later bound to a 2D texture
		EGLClientBuffer clientBuffer = (EGLClientBuffer) buffer->getNativeBuffer();
		EGLint imageAttrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };
		EGLImageKHR EGLimage = eglCreateImageKHR(display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
		clientBuffer, imageAttrs);
		if (EGLimage == EGL_NO_IMAGE_KHR) {
		ALOGW("Could not create EGL image, err =%s",
		uirenderer::renderthread::EglManager::eglErrorString());
		return nullptr;
		}

		GLuint textureId = 0;
		glGenTextures(1, &textureId);
		glBindTexture(GL_TEXTURE_EXTERNAL_OES, textureId);
		glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, EGLimage);

		GLenum status = GL_NO_ERROR;
		while ((status = glGetError()) != GL_NO_ERROR) {
		ALOGW("glEGLImageTargetTexture2DOES failed (%#x)", status);
		eglDestroyImageKHR(display, EGLimage);
		return nullptr;
		}

		sk_sp<GrContext> grContext = sk_ref_sp(renderThread.getGrContext());
		grContext->resetContext();

		GrGLTextureInfo textureInfo;
		textureInfo.fTarget = GL_TEXTURE_EXTERNAL_OES;
		textureInfo.fID = textureId;

		GrBackendTextureDesc textureDescription;
		textureDescription.fWidth = bitmap->info().width();
		textureDescription.fHeight = bitmap->info().height();
		textureDescription.fOrigin = kTopLeft_GrSurfaceOrigin;
		textureDescription.fTextureHandle = reinterpret_cast<GrBackendObject>(&textureInfo);
		PixelFormat format = buffer->getPixelFormat();
		switch (format) {
		case PIXEL_FORMAT_RGBA_8888:
		textureDescription.fConfig = kRGBA_8888_GrPixelConfig;
		break;
		case PIXEL_FORMAT_RGBA_FP16:
		textureDescription.fConfig = kRGBA_half_GrPixelConfig;
		break;
		default:
		eglDestroyImageKHR(display, EGLimage);
		return nullptr;
		}

		// TODO: add color correctness - pass null color space for now
		sk_sp<SkImage> image = SkImage::MakeFromTexture(grContext.get(), textureDescription,
		bitmap->info().alphaType(), nullptr, deleteImageTexture, EGLimage);
		if (!image.get()) {
		eglDestroyImageKHR(display, EGLimage);
		return nullptr;
		}
		return image;
		}

		} /* namespace skiapipeline */
		} /* namespace uirenderer */
		} /* namespace android */

libs/hwui/pipeline/skia/SkiaOpenGLPipeline.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -46,8 +46,6 @@ public:
		bool isContextReady() override;

		static void invokeFunctor(const renderthread::RenderThread& thread, Functor* functor);
		static sk_sp<SkImage> makeTextureImage(
		const uirenderer::renderthread::RenderThread& renderThread, Bitmap* bitmap);

		private:
		renderthread::EglManager& mEglManager;