Merge "Move Layer creation/deletion into the RenderPipeline." (68116413) · Commits · e / os / android_frameworks_base

libs/hwui/RenderNode.cpp

+5 −43

Original line number	Diff line number	Diff line
		@@ -229,19 +229,6 @@ void RenderNode::prepareLayer(TreeInfo& info, uint32_t dirtyMask) {
		}
		}

		static OffscreenBuffer* createLayer(RenderState& renderState, uint32_t width, uint32_t height) {
		return renderState.layerPool().get(renderState, width, height);
		}

		static void destroyLayer(OffscreenBuffer* layer) {
		RenderState& renderState = layer->renderState;
		renderState.layerPool().putOrDelete(layer);
		}

		static bool layerMatchesWidthAndHeight(OffscreenBuffer* layer, int width, int height) {
		return layer->viewportWidth == (uint32_t) width && layer->viewportHeight == (uint32_t)height;
		}

		void RenderNode::pushLayerUpdate(TreeInfo& info) {
		LayerType layerType = properties().effectiveLayerType();
		// If we are not a layer OR we cannot be rendered (eg, view was detached)
		@@ -251,33 +238,14 @@ void RenderNode::pushLayerUpdate(TreeInfo& info) {
		\|\| CC_UNLIKELY(properties().getWidth() == 0)
		\|\| CC_UNLIKELY(properties().getHeight() == 0)) {
		if (CC_UNLIKELY(mLayer)) {
		destroyLayer(mLayer);
		mLayer = nullptr;
		renderthread::CanvasContext::destroyLayer(this);
		}
		return;
		}

		bool transformUpdateNeeded = false;
		if (!mLayer) {
		mLayer = createLayer(info.canvasContext.getRenderState(), getWidth(), getHeight());
		if(info.canvasContext.createOrUpdateLayer(this, *info.damageAccumulator)) {
		damageSelf(info);
		transformUpdateNeeded = true;
		} else if (!layerMatchesWidthAndHeight(mLayer, getWidth(), getHeight())) {
		// TODO: remove now irrelevant, currently enqueued damage (respecting damage ordering)
		// Or, ideally, maintain damage between frames on node/layer so ordering is always correct
		RenderState& renderState = mLayer->renderState;
		if (properties().fitsOnLayer()) {
		mLayer = renderState.layerPool().resize(mLayer, getWidth(), getHeight());
		} else {
		destroyLayer(mLayer);
		mLayer = nullptr;
		}
		damageSelf(info);
		transformUpdateNeeded = true;
		}

		SkRect dirty;
		info.damageAccumulator->peekAtDirty(&dirty);

		if (!mLayer) {
		Caches::getInstance().dumpMemoryUsage();
		@@ -296,13 +264,8 @@ void RenderNode::pushLayerUpdate(TreeInfo& info) {
		return;
		}

		if (transformUpdateNeeded && mLayer) {
		// update the transform in window of the layer to reset its origin wrt light source position
		Matrix4 windowTransform;
		info.damageAccumulator->computeCurrentTransform(&windowTransform);
		mLayer->setWindowTransform(windowTransform);
		}

		SkRect dirty;
		info.damageAccumulator->peekAtDirty(&dirty);
		info.layerUpdateQueue->enqueueLayerWithDamage(this, dirty);

		// There might be prefetched layers that need to be accounted for.
		@@ -451,8 +414,7 @@ void RenderNode::prepareSubTree(TreeInfo& info, bool functorsNeedLayer, DisplayL

		void RenderNode::destroyHardwareResources(TreeObserver* observer, TreeInfo* info) {
		if (mLayer) {
		destroyLayer(mLayer);
		mLayer = nullptr;
		renderthread::CanvasContext::destroyLayer(this);
		}
		if (mDisplayList) {
		for (auto&& child : mDisplayList->getChildren()) {

libs/hwui/RenderNode.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -199,6 +199,7 @@ public:
		}
		OffscreenBuffer* getLayer() const { return mLayer; }
		OffscreenBuffer** getLayerHandle() { return &mLayer; } // ugh...
		void setLayer(OffscreenBuffer* layer) { mLayer = layer; }

		// Note: The position callbacks are relying on the listener using
		// the frameNumber to appropriately batch/synchronize these transactions.

libs/hwui/renderthread/CanvasContext.cpp

+12 −0

Original line number	Diff line number	Diff line
		@@ -85,6 +85,18 @@ CanvasContext* CanvasContext::create(RenderThread& thread,
		return nullptr;
		}

		void CanvasContext::destroyLayer(RenderNode* node) {
		auto renderType = Properties::getRenderPipelineType();
		switch (renderType) {
		case RenderPipelineType::OpenGL:
		OpenGLPipeline::destroyLayer(node);
		break;
		default:
		LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t) renderType);
		break;
		}
		}

		CanvasContext::CanvasContext(RenderThread& thread, bool translucent,
		RenderNode* rootRenderNode, IContextFactory* contextFactory,
		std::unique_ptr<IRenderPipeline> renderPipeline)

libs/hwui/renderthread/CanvasContext.h

+17 −0

Original line number	Diff line number	Diff line
		@@ -68,6 +68,23 @@ public:
		RenderNode* rootRenderNode, IContextFactory* contextFactory);
		virtual ~CanvasContext();

		/**
		* Update or create a layer specific for the provided RenderNode. The layer
		* attached to the node will be specific to the RenderPipeline used by this
		* context
		*
		* @return true if the layer has been created or updated
		*/
		bool createOrUpdateLayer(RenderNode* node, const DamageAccumulator& dmgAccumulator) {
		return mRenderPipeline->createOrUpdateLayer(node, dmgAccumulator);
		}

		/**
		* Destroy any layers that have been attached to the provided RenderNode removing
		* any state that may have been set during createOrUpdateLayer().
		*/
		static void destroyLayer(RenderNode* node);

		// Won't take effect until next EGLSurface creation
		void setSwapBehavior(SwapBehavior swapBehavior);

libs/hwui/renderthread/IRenderPipeline.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -67,6 +67,8 @@ public:
		LayerUpdateQueue* layerUpdateQueue, bool opaque,
		const BakedOpRenderer::LightInfo& lightInfo) = 0;
		virtual TaskManager* getTaskManager() = 0;
		virtual bool createOrUpdateLayer(RenderNode* node,
		const DamageAccumulator& damageAccumulator) = 0;

		virtual ~IRenderPipeline() {}
		};