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

libs/renderengine/RenderEngine.cpp

+1 −1

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

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

libs/renderengine/gl/GLESRenderEngine.cpp

+33 −33

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

		void GLESRenderEngine::drawLayersInternal(
		const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
		const DisplaySettings& display, const std::vector<const LayerSettings*>& layers,
		const DisplaySettings& display, const std::vector<LayerSettings>& layers,
		const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,
		base::unique_fd&& bufferFence) {
		ATRACE_CALL();
		@@ -1110,10 +1110,10 @@ void GLESRenderEngine::drawLayersInternal(
		std::unique_ptr<BindNativeBufferAsFramebuffer> fbo;
		// 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.
		std::deque<const LayerSettings*> blurLayers;
		std::deque<const LayerSettings> blurLayers;
		if (CC_LIKELY(mBlurFilter != nullptr)) {
		for (auto layer : layers) {
		if (layer->backgroundBlurRadius > 0) {
		for (const auto& layer : layers) {
		if (layer.backgroundBlurRadius > 0) {
		blurLayers.push_back(layer);
		}
		}
		@@ -1137,7 +1137,7 @@ void GLESRenderEngine::drawLayersInternal(
		} else {
		setViewportAndProjection(display.physicalDisplay, display.clip);
		auto status =
		mBlurFilter->setAsDrawTarget(display, blurLayers.front()->backgroundBlurRadius);
		mBlurFilter->setAsDrawTarget(display, blurLayers.front().backgroundBlurRadius);
		if (status != NO_ERROR) {
		ALOGE("Failed to prepare blur filter! Aborting GPU composition for buffer (%p).",
		buffer->getBuffer()->handle);
		@@ -1167,7 +1167,7 @@ void GLESRenderEngine::drawLayersInternal(
		.setTexCoords(2 /* size */)
		.setCropCoords(2 /* size */)
		.build();
		for (auto const layer : layers) {
		for (const auto& layer : layers) {
		if (blurLayers.size() > 0 && blurLayers.front() == layer) {
		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
		// instead of to the display.
		status = mBlurFilter->setAsDrawTarget(display,
		blurLayers.front()->backgroundBlurRadius);
		blurLayers.front().backgroundBlurRadius);
		}
		if (status != NO_ERROR) {
		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
		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.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>());
		position[0] = vec2(bounds.left, bounds.top);
		position[1] = vec2(bounds.left, bounds.bottom);
		position[2] = vec2(bounds.right, bounds.bottom);
		position[3] = vec2(bounds.right, bounds.top);

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

		bool usePremultipliedAlpha = true;
		bool disableTexture = true;
		bool isOpaque = false;
		if (layer->source.buffer.buffer != nullptr) {
		if (layer.source.buffer.buffer != nullptr) {
		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);
		bindExternalTextureBuffer(layer->source.buffer.textureName, gBuf,
		layer->source.buffer.fence);
		bindExternalTextureBuffer(layer.source.buffer.textureName, gBuf,
		layer.source.buffer.fence);

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

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

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

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

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

		if (layer->shadow.length > 0.0f) {
		handleShadow(layer->geometry.boundaries, layer->geometry.roundedCornersRadius,
		layer->shadow);
		if (layer.shadow.length > 0.0f) {
		handleShadow(layer.geometry.boundaries, layer.geometry.roundedCornersRadius,
		layer.shadow);
		}
		// 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
		// usual way since it needs to turn on blending anyway.
		else if (layer->geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) {
		handleRoundedCorners(display, *layer, mesh);
		else if (layer.geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) {
		handleRoundedCorners(display, layer, mesh);
		} else {
		drawMesh(mesh);
		}

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

libs/renderengine/gl/GLESRenderEngine.h

+1 −1

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

libs/renderengine/include/renderengine/RenderEngine.h

+2 −2

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

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

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

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

+2 −2

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