Merge "Update hwui_unit_tests to support running with Vulkan backend." (57b8eb3d) · Commits · e / os / android_frameworks_base

libs/hwui/DeferredLayerUpdater.cpp

+11 −17

Original line number	Original line	Diff line number	Diff line
	@@ -131,7 +131,7 @@ void DeferredLayerUpdater::doUpdateVkTexImage() {
	mLayer->getApi(), Layer::Api::OpenGL, Layer::Api::Vulkan);		mLayer->getApi(), Layer::Api::OpenGL, Layer::Api::Vulkan);

	static const mat4 identityMatrix;		static const mat4 identityMatrix;
	updateLayer(false, identityMatrix.data);		updateLayer(false, GL_NONE, identityMatrix.data);

	VkLayer* vkLayer = static_cast<VkLayer*>(mLayer);		VkLayer* vkLayer = static_cast<VkLayer*>(mLayer);
	vkLayer->updateTexture();		vkLayer->updateTexture();
	@@ -139,12 +139,12 @@ void DeferredLayerUpdater::doUpdateVkTexImage() {

	void DeferredLayerUpdater::updateLayer(bool forceFilter, GLenum renderTarget,		void DeferredLayerUpdater::updateLayer(bool forceFilter, GLenum renderTarget,
	const float* textureTransform) {		const float* textureTransform) {
	LOG_ALWAYS_FATAL_IF(mLayer->getApi() != Layer::Api::OpenGL,		mLayer->setBlend(mBlend);
	"updateLayer non GL backend %x, GL %x, VK %x",		mLayer->setForceFilter(forceFilter);
	mLayer->getApi(), Layer::Api::OpenGL, Layer::Api::Vulkan);		mLayer->setSize(mWidth, mHeight);
			mLayer->getTexTransform().load(textureTransform);
	updateLayer(forceFilter, textureTransform);

			if (mLayer->getApi() == Layer::Api::OpenGL) {
	GlLayer* glLayer = static_cast<GlLayer*>(mLayer);		GlLayer* glLayer = static_cast<GlLayer*>(mLayer);
	if (renderTarget != glLayer->getRenderTarget()) {		if (renderTarget != glLayer->getRenderTarget()) {
	glLayer->setRenderTarget(renderTarget);		glLayer->setRenderTarget(renderTarget);
	@@ -153,12 +153,6 @@ void DeferredLayerUpdater::updateLayer(bool forceFilter, GLenum renderTarget,
	glLayer->setWrap(GL_CLAMP_TO_EDGE, false, true);		glLayer->setWrap(GL_CLAMP_TO_EDGE, false, true);
	}		}
	}		}

	void DeferredLayerUpdater::updateLayer(bool forceFilter, const float* textureTransform) {
	mLayer->setBlend(mBlend);
	mLayer->setForceFilter(forceFilter);
	mLayer->setSize(mWidth, mHeight);
	mLayer->getTexTransform().load(textureTransform);
	}		}

	void DeferredLayerUpdater::detachSurfaceTexture() {		void DeferredLayerUpdater::detachSurfaceTexture() {

libs/hwui/DeferredLayerUpdater.h

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -114,7 +114,6 @@ private:

	void doUpdateTexImage();		void doUpdateTexImage();
	void doUpdateVkTexImage();		void doUpdateVkTexImage();
	void updateLayer(bool forceFilter, const float* textureTransform);
	};		};

	} /* namespace uirenderer */		} /* namespace uirenderer */

libs/hwui/Properties.cpp

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -222,6 +222,12 @@ RenderPipelineType Properties::getRenderPipelineType() {
	return sRenderPipelineType;		return sRenderPipelineType;
	}		}

			#ifdef HWUI_GLES_WRAP_ENABLED
			void Properties::overrideRenderPipelineType(RenderPipelineType type) {
			sRenderPipelineType = type;
			}
			#endif

	bool Properties::isSkiaEnabled() {		bool Properties::isSkiaEnabled() {
	auto renderType = getRenderPipelineType();		auto renderType = getRenderPipelineType();
	return RenderPipelineType::SkiaGL == renderType		return RenderPipelineType::SkiaGL == renderType

libs/hwui/Properties.h

+5 −1

Original line number	Original line	Diff line number	Diff line
	@@ -318,11 +318,15 @@ public:
	// any overhead they add		// any overhead they add
	static bool filterOutTestOverhead;		static bool filterOutTestOverhead;

			// Used for testing only to change the render pipeline.
			#ifdef HWUI_GLES_WRAP_ENABLED
			static void overrideRenderPipelineType(RenderPipelineType);
			#endif

	private:		private:
	static ProfileType sProfileType;		static ProfileType sProfileType;
	static bool sDisableProfileBars;		static bool sDisableProfileBars;
	static RenderPipelineType sRenderPipelineType;		static RenderPipelineType sRenderPipelineType;

	}; // class Caches		}; // class Caches

	}; // namespace uirenderer		}; // namespace uirenderer

libs/hwui/tests/common/TestUtils.cpp

+30 −5

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,9 @@

	#include <renderthread/EglManager.h>		#include <renderthread/EglManager.h>
	#include <renderthread/OpenGLPipeline.h>		#include <renderthread/OpenGLPipeline.h>
			#include <pipeline/skia/SkiaOpenGLPipeline.h>
			#include <pipeline/skia/SkiaVulkanPipeline.h>
			#include <renderthread/VulkanManager.h>
	#include <utils/Unicode.h>		#include <utils/Unicode.h>
	#include <SkClipStack.h>		#include <SkClipStack.h>

	@@ -46,11 +49,25 @@ SkColor TestUtils::interpolateColor(float fraction, SkColor start, SkColor end)
	\| (int)((startB + (int)(fraction * (endB - startB))));		\| (int)((startB + (int)(fraction * (endB - startB))));
	}		}

			sp<DeferredLayerUpdater> TestUtils::createTextureLayerUpdater(
			renderthread::RenderThread& renderThread) {
			android::uirenderer::renderthread::IRenderPipeline* pipeline;
			if (Properties::getRenderPipelineType() == RenderPipelineType::OpenGL) {
			pipeline = new renderthread::OpenGLPipeline(renderThread);
			} else if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaGL) {
			pipeline = new skiapipeline::SkiaOpenGLPipeline(renderThread);
			} else {
			pipeline = new skiapipeline::SkiaVulkanPipeline(renderThread);
			}
			sp<DeferredLayerUpdater> layerUpdater = pipeline->createTextureLayer();
			delete pipeline;
			return layerUpdater;
			}

	sp<DeferredLayerUpdater> TestUtils::createTextureLayerUpdater(		sp<DeferredLayerUpdater> TestUtils::createTextureLayerUpdater(
	renderthread::RenderThread& renderThread, uint32_t width, uint32_t height,		renderthread::RenderThread& renderThread, uint32_t width, uint32_t height,
	const SkMatrix& transform) {		const SkMatrix& transform) {
	renderthread::OpenGLPipeline pipeline(renderThread);		sp<DeferredLayerUpdater> layerUpdater = createTextureLayerUpdater(renderThread);
	sp<DeferredLayerUpdater> layerUpdater = pipeline.createTextureLayer();
	layerUpdater->backingLayer()->getTransform().load(transform);		layerUpdater->backingLayer()->getTransform().load(transform);
	layerUpdater->setSize(width, height);		layerUpdater->setSize(width, height);
	layerUpdater->setTransform(&transform);		layerUpdater->setTransform(&transform);
	@@ -111,13 +128,21 @@ void TestUtils::drawUtf8ToCanvas(Canvas* canvas, const char* text,
	void TestUtils::TestTask::run() {		void TestUtils::TestTask::run() {
	// RenderState only valid once RenderThread is running, so queried here		// RenderState only valid once RenderThread is running, so queried here
	renderthread::RenderThread& renderThread = renderthread::RenderThread::getInstance();		renderthread::RenderThread& renderThread = renderthread::RenderThread::getInstance();
			if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaVulkan) {
			renderThread.vulkanManager().initialize();
			} else {
	renderThread.eglManager().initialize();		renderThread.eglManager().initialize();
			}

	rtCallback(renderThread);		rtCallback(renderThread);

			if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaVulkan) {
			renderThread.vulkanManager().destroy();
			} else {
	renderThread.renderState().flush(Caches::FlushMode::Full);		renderThread.renderState().flush(Caches::FlushMode::Full);
	renderThread.eglManager().destroy();		renderThread.eglManager().destroy();
	}		}
			}

	std::unique_ptr<uint16_t[]> TestUtils::asciiToUtf16(const char* str) {		std::unique_ptr<uint16_t[]> TestUtils::asciiToUtf16(const char* str) {
	const int length = strlen(str);		const int length = strlen(str);