Merge "Unify drawing for background blur and blur regions" (16d09068) · Commits · e / os / platform_frameworks_native

libs/renderengine/skia/SkiaGLRenderEngine.cpp

+30 −12

Original line number	Diff line number	Diff line
		@@ -547,9 +547,11 @@ status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,
		const auto layerRect = drawTransform.mapRect(dest);
		if (layer->backgroundBlurRadius > 0) {
		ATRACE_NAME("BackgroundBlur");
		auto blurredSurface =
		mBlurFilter->draw(canvas, surface, layer->backgroundBlurRadius, layerRect);
		auto blurredSurface = mBlurFilter->generate(canvas, surface,
		layer->backgroundBlurRadius, layerRect);
		cachedBlurs[layer->backgroundBlurRadius] = blurredSurface;

		drawBlurRegion(canvas, getBlurRegion(layer), drawTransform, blurredSurface);
		}
		if (layer->blurRegions.size() > 0) {
		for (auto region : layer->blurRegions) {
		@@ -663,13 +665,13 @@ status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,

		paint.setColorFilter(SkColorFilters::Matrix(toSkColorMatrix(display.colorTransform)));

		canvas->save();
		canvas->concat(drawTransform);

		for (const auto effectRegion : layer->blurRegions) {
		drawBlurRegion(canvas, effectRegion, dest, cachedBlurs[effectRegion.blurRadius]);
		drawBlurRegion(canvas, effectRegion, drawTransform,
		cachedBlurs[effectRegion.blurRadius]);
		}

		canvas->save();
		canvas->concat(drawTransform);
		if (layer->shadow.length > 0) {
		const auto rect = layer->geometry.roundedCornersRadius > 0
		? getSkRect(layer->geometry.roundedCornersCrop)
		@@ -730,6 +732,21 @@ inline SkRRect SkiaGLRenderEngine::getRoundedRect(const LayerSettings* layer) {
		return SkRRect::MakeRectXY(rect, cornerRadius, cornerRadius);
		}

		inline BlurRegion SkiaGLRenderEngine::getBlurRegion(const LayerSettings* layer) {
		const auto rect = getSkRect(layer->geometry.boundaries);
		const auto cornersRadius = layer->geometry.roundedCornersRadius;
		return BlurRegion{.blurRadius = static_cast<uint32_t>(layer->backgroundBlurRadius),
		.cornerRadiusTL = cornersRadius,
		.cornerRadiusTR = cornersRadius,
		.cornerRadiusBL = cornersRadius,
		.cornerRadiusBR = cornersRadius,
		.alpha = 1,
		.left = static_cast<int>(rect.fLeft),
		.top = static_cast<int>(rect.fTop),
		.right = static_cast<int>(rect.fRight),
		.bottom = static_cast<int>(rect.fBottom)};
		}

		inline SkColor SkiaGLRenderEngine::getSkColor(const vec4& color) {
		return SkColorSetARGB(color.a * 255, color.r * 255, color.g * 255, color.b * 255);
		}
		@@ -777,18 +794,19 @@ void SkiaGLRenderEngine::drawShadow(SkCanvas* canvas, const SkRect& casterRect,
		}

		void SkiaGLRenderEngine::drawBlurRegion(SkCanvas* canvas, const BlurRegion& effectRegion,
		const SkRect& layerBoundaries,
		const SkMatrix& drawTransform,
		sk_sp<SkSurface> blurredSurface) {
		ATRACE_CALL();

		SkPaint paint;
		paint.setAlpha(static_cast<int>(effectRegion.alpha * 255));
		const auto rect = SkRect::MakeLTRB(effectRegion.left, effectRegion.top, effectRegion.right,
		effectRegion.bottom);

		const auto matrix = mBlurFilter->getShaderMatrix(
		SkMatrix::MakeTrans(layerBoundaries.left(), layerBoundaries.top()));
		const auto matrix = mBlurFilter->getShaderMatrix();
		paint.setShader(blurredSurface->makeImageSnapshot()->makeShader(matrix));

		auto rect = SkRect::MakeLTRB(effectRegion.left, effectRegion.top, effectRegion.right,
		effectRegion.bottom);
		drawTransform.mapRect(&rect);

		if (effectRegion.cornerRadiusTL > 0 \|\| effectRegion.cornerRadiusTR > 0 \|\|
		effectRegion.cornerRadiusBL > 0 \|\| effectRegion.cornerRadiusBR > 0) {
		const SkVector radii[4] =

libs/renderengine/skia/SkiaGLRenderEngine.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -67,6 +67,7 @@ private:
		inline SkRect getSkRect(const FloatRect& layer);
		inline SkRect getSkRect(const Rect& layer);
		inline SkRRect getRoundedRect(const LayerSettings* layer);
		inline BlurRegion getBlurRegion(const LayerSettings* layer);
		inline SkColor getSkColor(const vec4& color);
		inline SkM44 getSkM44(const mat4& matrix);
		inline SkMatrix getDrawTransform(const LayerSettings* layer, const SkMatrix& screenTransform);
		@@ -76,8 +77,8 @@ private:
		bool waitFence(base::unique_fd fenceFd);
		void drawShadow(SkCanvas* canvas, const SkRect& casterRect, float casterCornerRadius,
		const ShadowSettings& shadowSettings);
		void drawBlurRegion(SkCanvas* canvas, const BlurRegion& blurRegion, const SkRect& layerBounds,
		sk_sp<SkSurface> blurrendSurface);
		void drawBlurRegion(SkCanvas* canvas, const BlurRegion& blurRegion,
		const SkMatrix& drawTransform, sk_sp<SkSurface> blurrendSurface);

		EGLDisplay mEGLDisplay;
		EGLConfig mEGLConfig;

libs/renderengine/skia/filters/BlurFilter.cpp

+2 −20

Original line number	Diff line number	Diff line
		@@ -130,26 +130,8 @@ sk_sp<SkSurface> BlurFilter::generate(SkCanvas* canvas, const sk_sp<SkSurface> i
		return lastDrawTarget;
		}

		sk_sp<SkSurface> BlurFilter::draw(SkCanvas* canvas, const sk_sp<SkSurface> input,
		const uint32_t blurRadius, SkRect rect) const {
		ATRACE_CALL();
		sk_sp<SkSurface> surface = generate(canvas, input, blurRadius, rect);
		const auto image = surface->makeImageSnapshot();

		SkPaint paint;
		paint.setShader(image->makeShader(SkMatrix::MakeScale(kInverseInputScale)));
		paint.setFilterQuality(kLow_SkFilterQuality);
		paint.setAlpha(std::min(1.0f, (float)blurRadius / kMaxCrossFadeRadius) * 255);

		canvas->drawRect(rect, paint);

		return surface;
		}

		SkMatrix BlurFilter::getShaderMatrix(const SkMatrix& transformMatrix) const {
		SkMatrix matrix;
		matrix.setConcat(transformMatrix, SkMatrix::MakeScale(kInverseInputScale));
		return matrix;
		SkMatrix BlurFilter::getShaderMatrix() const {
		return SkMatrix::MakeScale(kInverseInputScale);
		}

		} // namespace skia

libs/renderengine/skia/filters/BlurFilter.h

+1 −4

Original line number	Diff line number	Diff line
		@@ -50,11 +50,8 @@ public:
		// Execute blur, saving it to a texture
		sk_sp<SkSurface> generate(SkCanvas* canvas, const sk_sp<SkSurface> input, const uint32_t radius,
		SkRect rect) const;
		// Same as generate but also drawing to the screen
		sk_sp<SkSurface> draw(SkCanvas* canvas, const sk_sp<SkSurface> input, const uint32_t radius,
		SkRect rect) const;
		// Returns a matrix that should be applied to the blur shader
		SkMatrix getShaderMatrix(const SkMatrix& transformMatrix) const;
		SkMatrix getShaderMatrix() const;

		private:
		sk_sp<SkRuntimeEffect> mBlurEffect;