Merge "Cache shaders having useIsOpaqueWorkaround" into sc-dev am: ba77a4c22d (3a98fb29) · Commits · e / os / android_frameworks_native

libs/renderengine/skia/Cache.cpp

+28 −33

Original line number	Original line	Diff line number	Diff line
	@@ -99,6 +99,9 @@ static void drawImageLayers(SkiaRenderEngine* renderengine, const DisplaySetting
	LayerSettings layer{		LayerSettings layer{
	.geometry =		.geometry =
	Geometry{		Geometry{
			// The position transform doesn't matter when the reduced shader mode
			// in in effect. A matrix transform stage is always included.
			.positionTransform = mat4(),
	.boundaries = rect,		.boundaries = rect,
	.roundedCornersCrop = rect,		.roundedCornersCrop = rect,
	},		},
	@@ -109,25 +112,15 @@ static void drawImageLayers(SkiaRenderEngine* renderengine, const DisplaySetting
	}},		}},
	};		};

	auto threeCornerRadii = {0.0f, 0.05f, 50.f};
	auto oneCornerRadius = {50.f};

	// Test both drawRect and drawRRect
	auto layers = std::vector<const LayerSettings*>{&layer};		auto layers = std::vector<const LayerSettings*>{&layer};
	for (auto dataspace : {kDestDataSpace, kOtherDataSpace}) {		for (auto dataspace : {kDestDataSpace, kOtherDataSpace}) {
	layer.sourceDataspace = dataspace;		layer.sourceDataspace = dataspace;
	for (bool identity : {true, false}) {		for (float roundedCornersRadius : {0.0f, 50.0f}) {
	layer.geometry.positionTransform = identity ? mat4() : kScaleAndTranslate;		// roundedCornersCrop is always set, but the radius triggers the behavior
	// Corner radii less than 0.5 creates a special shader. This likely occurs in real usage
	// due to animating corner radius.
	// For the non-idenity matrix, only the large corner radius will create a new shader.
	for (float roundedCornersRadius : identity ? threeCornerRadii : oneCornerRadius) {
	// roundedCornersCrop is always set, but it is this radius that triggers the
	// behavior
	layer.geometry.roundedCornersRadius = roundedCornersRadius;		layer.geometry.roundedCornersRadius = roundedCornersRadius;
	for (bool isOpaque : {true, false}) {		for (bool isOpaque : {true, false}) {
	layer.source.buffer.isOpaque = isOpaque;		layer.source.buffer.isOpaque = isOpaque;
	for (auto alpha : {half(.23999f), half(1.0f)}) {		for (auto alpha : {half(.2f), half(1.0f)}) {
	layer.alpha = alpha;		layer.alpha = alpha;
	renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,		renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,
	base::unique_fd(), nullptr);		base::unique_fd(), nullptr);
	@@ -136,7 +129,6 @@ static void drawImageLayers(SkiaRenderEngine* renderengine, const DisplaySetting
	}		}
	}		}
	}		}
	}

	static void drawSolidLayers(SkiaRenderEngine* renderengine, const DisplaySettings& display,		static void drawSolidLayers(SkiaRenderEngine* renderengine, const DisplaySettings& display,
	const std::shared_ptr<ExternalTexture>& dstTexture) {		const std::shared_ptr<ExternalTexture>& dstTexture) {
	@@ -157,7 +149,7 @@ static void drawSolidLayers(SkiaRenderEngine* renderengine, const DisplaySetting
	auto layers = std::vector<const LayerSettings*>{&layer};		auto layers = std::vector<const LayerSettings*>{&layer};
	for (auto transform : {mat4(), kScaleAndTranslate}) {		for (auto transform : {mat4(), kScaleAndTranslate}) {
	layer.geometry.positionTransform = transform;		layer.geometry.positionTransform = transform;
	for (float roundedCornersRadius : {0.0f, 0.05f, 50.f}) {		for (float roundedCornersRadius : {0.0f, 50.f}) {
	layer.geometry.roundedCornersRadius = roundedCornersRadius;		layer.geometry.roundedCornersRadius = roundedCornersRadius;
	renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,		renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,
	base::unique_fd(), nullptr);		base::unique_fd(), nullptr);
	@@ -295,34 +287,37 @@ void Cache::primeShaderCache(SkiaRenderEngine* renderengine) {
	ExternalTexture::Usage::READABLE \|		ExternalTexture::Usage::READABLE \|
	ExternalTexture::Usage::WRITEABLE);		ExternalTexture::Usage::WRITEABLE);

	// 6 shaders
	drawSolidLayers(renderengine, display, dstTexture);		drawSolidLayers(renderengine, display, dstTexture);
	// 8 shaders
	drawShadowLayers(renderengine, display, srcTexture);		drawShadowLayers(renderengine, display, srcTexture);

	if (renderengine->supportsBackgroundBlur()) {		if (renderengine->supportsBackgroundBlur()) {
	// 2 shaders
	drawBlurLayers(renderengine, display, dstTexture);		drawBlurLayers(renderengine, display, dstTexture);
	}		}

	// The majority of shaders are related to sampling images.
	drawImageLayers(renderengine, display, dstTexture, srcTexture);

	// should be the same as AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;		// should be the same as AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
	const int64_t usageExternal = GRALLOC_USAGE_HW_TEXTURE;		const int64_t usageExternal = GRALLOC_USAGE_HW_TEXTURE;

	sp<GraphicBuffer> externalBuffer =		sp<GraphicBuffer> externalBuffer =
	new GraphicBuffer(displayRect.width(), displayRect.height(), PIXEL_FORMAT_RGBA_8888,		new GraphicBuffer(displayRect.width(), displayRect.height(), PIXEL_FORMAT_RGBA_8888,
	1, usageExternal, "primeShaderCache_external");		1, usageExternal, "primeShaderCache_external");
	const auto externalTexture =		const auto externalTexture =
	std::make_shared<ExternalTexture>(externalBuffer, *renderengine,		std::make_shared<ExternalTexture>(externalBuffer, *renderengine,
	ExternalTexture::Usage::READABLE);		ExternalTexture::Usage::READABLE);
	// TODO(b/184665179) doubles number of image shader compilations, but only somewhere
	// between 6 and 8 will occur in real uses.
	drawImageLayers(renderengine, display, dstTexture, externalTexture);

			// Another external texture with a different pixel format triggers useIsOpaqueWorkaround
			sp<GraphicBuffer> f16ExternalBuffer =
			new GraphicBuffer(displayRect.width(), displayRect.height(), PIXEL_FORMAT_RGBA_FP16,
			1, usageExternal, "primeShaderCache_external_f16");
			const auto f16ExternalTexture =
			std::make_shared<ExternalTexture>(f16ExternalBuffer, *renderengine,
			ExternalTexture::Usage::READABLE);

			// The majority of shaders are related to sampling images.
			// These need to be generated with various source textures
			for (auto texture : {srcTexture, externalTexture, f16ExternalTexture}) {
			drawImageLayers(renderengine, display, dstTexture, texture);
	// Draw layers for b/185569240.		// Draw layers for b/185569240.
	drawClippedLayers(renderengine, display, dstTexture, externalTexture);		drawClippedLayers(renderengine, display, dstTexture, texture);
			}

	const nsecs_t timeAfter = systemTime();		const nsecs_t timeAfter = systemTime();
	const float compileTimeMs = static_cast<float>(timeAfter - timeBefore) / 1.0E6;		const float compileTimeMs = static_cast<float>(timeAfter - timeBefore) / 1.0E6;