Merge "Revert "Second Patch for async RenderEngine"" (bf83856b) · Commits · e / os / android_frameworks_native-old

libs/renderengine/RenderEngine.cpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -96,7 +96,7 @@ void RenderEngine::validateOutputBufferUsage(const sp<GraphicBuffer>& buffer) {
	}		}

	std::future<RenderEngineResult> RenderEngine::drawLayers(		std::future<RenderEngineResult> RenderEngine::drawLayers(
	const DisplaySettings& display, const std::vector<LayerSettings>& layers,		const DisplaySettings& display, const std::vector<const LayerSettings*>& layers,
	const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,		const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
	base::unique_fd&& bufferFence) {		base::unique_fd&& bufferFence) {
	const auto resultPromise = std::make_shared<std::promise<RenderEngineResult>>();		const auto resultPromise = std::make_shared<std::promise<RenderEngineResult>>();

libs/renderengine/gl/GLESRenderEngine.cpp

+33 −33

Original line number	Original line	Diff line number	Diff line
	@@ -1080,7 +1080,7 @@ EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer

	void GLESRenderEngine::drawLayersInternal(		void GLESRenderEngine::drawLayersInternal(
	const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,		const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
	const DisplaySettings& display, const std::vector<LayerSettings>& layers,		const DisplaySettings& display, const std::vector<const LayerSettings*>& layers,
	const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,		const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
	base::unique_fd&& bufferFence) {		base::unique_fd&& bufferFence) {
	ATRACE_CALL();		ATRACE_CALL();
	@@ -1110,10 +1110,10 @@ void GLESRenderEngine::drawLayersInternal(
	std::unique_ptr<BindNativeBufferAsFramebuffer> fbo;		std::unique_ptr<BindNativeBufferAsFramebuffer> fbo;
	// Gathering layers that requested blur, we'll need them to decide when to render to an		// Gathering layers that requested blur, we'll need them to decide when to render to an
	// offscreen buffer, and when to render to the native buffer.		// offscreen buffer, and when to render to the native buffer.
	std::deque<const LayerSettings> blurLayers;		std::deque<const LayerSettings*> blurLayers;
	if (CC_LIKELY(mBlurFilter != nullptr)) {		if (CC_LIKELY(mBlurFilter != nullptr)) {
	for (const auto& layer : layers) {		for (auto layer : layers) {
	if (layer.backgroundBlurRadius > 0) {		if (layer->backgroundBlurRadius > 0) {
	blurLayers.push_back(layer);		blurLayers.push_back(layer);
	}		}
	}		}
	@@ -1137,7 +1137,7 @@ void GLESRenderEngine::drawLayersInternal(
	} else {		} else {
	setViewportAndProjection(display.physicalDisplay, display.clip);		setViewportAndProjection(display.physicalDisplay, display.clip);
	auto status =		auto status =
	mBlurFilter->setAsDrawTarget(display, blurLayers.front().backgroundBlurRadius);		mBlurFilter->setAsDrawTarget(display, blurLayers.front()->backgroundBlurRadius);
	if (status != NO_ERROR) {		if (status != NO_ERROR) {
	ALOGE("Failed to prepare blur filter! Aborting GPU composition for buffer (%p).",		ALOGE("Failed to prepare blur filter! Aborting GPU composition for buffer (%p).",
	buffer->getBuffer()->handle);		buffer->getBuffer()->handle);
	@@ -1167,7 +1167,7 @@ void GLESRenderEngine::drawLayersInternal(
	.setTexCoords(2 /* size */)		.setTexCoords(2 /* size */)
	.setCropCoords(2 /* size */)		.setCropCoords(2 /* size */)
	.build();		.build();
	for (const auto& layer : layers) {		for (auto const layer : layers) {
	if (blurLayers.size() > 0 && blurLayers.front() == layer) {		if (blurLayers.size() > 0 && blurLayers.front() == layer) {
	blurLayers.pop_front();		blurLayers.pop_front();

	@@ -1193,7 +1193,7 @@ void GLESRenderEngine::drawLayersInternal(
	// There's still something else to blur, so let's keep rendering to our FBO		// There's still something else to blur, so let's keep rendering to our FBO
	// instead of to the display.		// instead of to the display.
	status = mBlurFilter->setAsDrawTarget(display,		status = mBlurFilter->setAsDrawTarget(display,
	blurLayers.front().backgroundBlurRadius);		blurLayers.front()->backgroundBlurRadius);
	}		}
	if (status != NO_ERROR) {		if (status != NO_ERROR) {
	ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",		ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",
	@@ -1214,42 +1214,42 @@ void GLESRenderEngine::drawLayersInternal(
	}		}

	// Ensure luminance is at least 100 nits to avoid div-by-zero		// Ensure luminance is at least 100 nits to avoid div-by-zero
	const float maxLuminance = std::max(100.f, layer.source.buffer.maxLuminanceNits);		const float maxLuminance = std::max(100.f, layer->source.buffer.maxLuminanceNits);
	mState.maxMasteringLuminance = maxLuminance;		mState.maxMasteringLuminance = maxLuminance;
	mState.maxContentLuminance = maxLuminance;		mState.maxContentLuminance = maxLuminance;
	mState.projectionMatrix = projectionMatrix * layer.geometry.positionTransform;		mState.projectionMatrix = projectionMatrix * layer->geometry.positionTransform;

	const FloatRect bounds = layer.geometry.boundaries;		const FloatRect bounds = layer->geometry.boundaries;
	Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());		Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
	position[0] = vec2(bounds.left, bounds.top);		position[0] = vec2(bounds.left, bounds.top);
	position[1] = vec2(bounds.left, bounds.bottom);		position[1] = vec2(bounds.left, bounds.bottom);
	position[2] = vec2(bounds.right, bounds.bottom);		position[2] = vec2(bounds.right, bounds.bottom);
	position[3] = vec2(bounds.right, bounds.top);		position[3] = vec2(bounds.right, bounds.top);

	setupLayerCropping(layer, mesh);		setupLayerCropping(*layer, mesh);
	setColorTransform(layer.colorTransform);		setColorTransform(layer->colorTransform);

	bool usePremultipliedAlpha = true;		bool usePremultipliedAlpha = true;
	bool disableTexture = true;		bool disableTexture = true;
	bool isOpaque = false;		bool isOpaque = false;
	if (layer.source.buffer.buffer != nullptr) {		if (layer->source.buffer.buffer != nullptr) {
	disableTexture = false;		disableTexture = false;
	isOpaque = layer.source.buffer.isOpaque;		isOpaque = layer->source.buffer.isOpaque;

	sp<GraphicBuffer> gBuf = layer.source.buffer.buffer->getBuffer();		sp<GraphicBuffer> gBuf = layer->source.buffer.buffer->getBuffer();
	validateInputBufferUsage(gBuf);		validateInputBufferUsage(gBuf);
	bindExternalTextureBuffer(layer.source.buffer.textureName, gBuf,		bindExternalTextureBuffer(layer->source.buffer.textureName, gBuf,
	layer.source.buffer.fence);		layer->source.buffer.fence);

	usePremultipliedAlpha = layer.source.buffer.usePremultipliedAlpha;		usePremultipliedAlpha = layer->source.buffer.usePremultipliedAlpha;
	Texture texture(Texture::TEXTURE_EXTERNAL, layer.source.buffer.textureName);		Texture texture(Texture::TEXTURE_EXTERNAL, layer->source.buffer.textureName);
	mat4 texMatrix = layer.source.buffer.textureTransform;		mat4 texMatrix = layer->source.buffer.textureTransform;

	texture.setMatrix(texMatrix.asArray());		texture.setMatrix(texMatrix.asArray());
	texture.setFiltering(layer.source.buffer.useTextureFiltering);		texture.setFiltering(layer->source.buffer.useTextureFiltering);

	texture.setDimensions(gBuf->getWidth(), gBuf->getHeight());		texture.setDimensions(gBuf->getWidth(), gBuf->getHeight());
	setSourceY410BT2020(layer.source.buffer.isY410BT2020);		setSourceY410BT2020(layer->source.buffer.isY410BT2020);

	renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>());		renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>());
	texCoords[0] = vec2(0.0, 0.0);		texCoords[0] = vec2(0.0, 0.0);
	@@ -1264,32 +1264,32 @@ void GLESRenderEngine::drawLayersInternal(
	}		}
	}		}

	const half3 solidColor = layer.source.solidColor;		const half3 solidColor = layer->source.solidColor;
	const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer.alpha);		const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer->alpha);
	// Buffer sources will have a black solid color ignored in the shader,		// Buffer sources will have a black solid color ignored in the shader,
	// so in that scenario the solid color passed here is arbitrary.		// so in that scenario the solid color passed here is arbitrary.
	setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color,		setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color,
	layer.geometry.roundedCornersRadius);		layer->geometry.roundedCornersRadius);
	if (layer.disableBlending) {		if (layer->disableBlending) {
	glDisable(GL_BLEND);		glDisable(GL_BLEND);
	}		}
	setSourceDataSpace(layer.sourceDataspace);		setSourceDataSpace(layer->sourceDataspace);

	if (layer.shadow.length > 0.0f) {		if (layer->shadow.length > 0.0f) {
	handleShadow(layer.geometry.boundaries, layer.geometry.roundedCornersRadius,		handleShadow(layer->geometry.boundaries, layer->geometry.roundedCornersRadius,
	layer.shadow);		layer->shadow);
	}		}
	// We only want to do a special handling for rounded corners when having rounded corners		// We only want to do a special handling for rounded corners when having rounded corners
	// is the only reason it needs to turn on blending, otherwise, we handle it like the		// is the only reason it needs to turn on blending, otherwise, we handle it like the
	// usual way since it needs to turn on blending anyway.		// usual way since it needs to turn on blending anyway.
	else if (layer.geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) {		else if (layer->geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) {
	handleRoundedCorners(display, layer, mesh);		handleRoundedCorners(display, *layer, mesh);
	} else {		} else {
	drawMesh(mesh);		drawMesh(mesh);
	}		}

	// Cleanup if there's a buffer source		// Cleanup if there's a buffer source
	if (layer.source.buffer.buffer != nullptr) {		if (layer->source.buffer.buffer != nullptr) {
	disableBlending();		disableBlending();
	setSourceY410BT2020(false);		setSourceY410BT2020(false);
	disableTexturing();		disableTexturing();

libs/renderengine/gl/GLESRenderEngine.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -104,7 +104,7 @@ protected:
	bool canSkipPostRenderCleanup() const override;		bool canSkipPostRenderCleanup() const override;
	void drawLayersInternal(const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,		void drawLayersInternal(const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
	const DisplaySettings& display,		const DisplaySettings& display,
	const std::vector<LayerSettings>& layers,		const std::vector<const LayerSettings*>& layers,
	const std::shared_ptr<ExternalTexture>& buffer,		const std::shared_ptr<ExternalTexture>& buffer,
	const bool useFramebufferCache, base::unique_fd&& bufferFence) override;		const bool useFramebufferCache, base::unique_fd&& bufferFence) override;

libs/renderengine/include/renderengine/RenderEngine.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -160,7 +160,7 @@ public:
	// @return A future object of RenderEngineResult struct indicating whether		// @return A future object of RenderEngineResult struct indicating whether
	// drawing was successful in async mode.		// drawing was successful in async mode.
	virtual std::future<RenderEngineResult> drawLayers(		virtual std::future<RenderEngineResult> drawLayers(
	const DisplaySettings& display, const std::vector<LayerSettings>& layers,		const DisplaySettings& display, const std::vector<const LayerSettings*>& layers,
	const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,		const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
	base::unique_fd&& bufferFence);		base::unique_fd&& bufferFence);

	@@ -231,7 +231,7 @@ protected:

	virtual void drawLayersInternal(		virtual void drawLayersInternal(
	const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,		const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
	const DisplaySettings& display, const std::vector<LayerSettings>& layers,		const DisplaySettings& display, const std::vector<const LayerSettings*>& layers,
	const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,		const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
	base::unique_fd&& bufferFence) = 0;		base::unique_fd&& bufferFence) = 0;
	};		};

libs/renderengine/include/renderengine/mock/RenderEngine.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -49,12 +49,12 @@ public:
	MOCK_CONST_METHOD0(canSkipPostRenderCleanup, bool());		MOCK_CONST_METHOD0(canSkipPostRenderCleanup, bool());
	MOCK_METHOD5(drawLayers,		MOCK_METHOD5(drawLayers,
	std::future<RenderEngineResult>(const DisplaySettings&,		std::future<RenderEngineResult>(const DisplaySettings&,
	const std::vector<LayerSettings>&,		const std::vector<const LayerSettings*>&,
	const std::shared_ptr<ExternalTexture>&,		const std::shared_ptr<ExternalTexture>&,
	const bool, base::unique_fd&&));		const bool, base::unique_fd&&));
	MOCK_METHOD6(drawLayersInternal,		MOCK_METHOD6(drawLayersInternal,
	void(const std::shared_ptr<std::promise<RenderEngineResult>>&&,		void(const std::shared_ptr<std::promise<RenderEngineResult>>&&,
	const DisplaySettings&, const std::vector<LayerSettings>&,		const DisplaySettings&, const std::vector<const LayerSettings*>&,
	const std::shared_ptr<ExternalTexture>&, const bool, base::unique_fd&&));		const std::shared_ptr<ExternalTexture>&, const bool, base::unique_fd&&));
	MOCK_METHOD0(cleanFramebufferCache, void());		MOCK_METHOD0(cleanFramebufferCache, void());
	MOCK_METHOD0(getContextPriority, int());		MOCK_METHOD0(getContextPriority, int());