Merge "[SurfaceFlinger] Callback to renderengine when erasing BLAST buffers"... (a0fb6c30) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/BufferLayer.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -48,7 +48,7 @@ namespace android {
	class BufferLayer : public Layer {		class BufferLayer : public Layer {
	public:		public:
	explicit BufferLayer(const LayerCreationArgs& args);		explicit BufferLayer(const LayerCreationArgs& args);
	~BufferLayer() override;		virtual ~BufferLayer() override;

	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	// Overriden from Layer		// Overriden from Layer

services/surfaceflinger/BufferStateLayer.cpp

+10 −4

Original line number	Original line	Diff line number	Diff line
	@@ -51,6 +51,16 @@ BufferStateLayer::BufferStateLayer(const LayerCreationArgs& args)
	mCurrentState.dataspace = ui::Dataspace::V0_SRGB;		mCurrentState.dataspace = ui::Dataspace::V0_SRGB;
	}		}

			BufferStateLayer::~BufferStateLayer() {
			if (mActiveBuffer != nullptr) {
			// Ensure that mActiveBuffer is uncached from RenderEngine here, as
			// RenderEngine may have been using the buffer as an external texture
			// after the client uncached the buffer.
			auto& engine(mFlinger->getRenderEngine());
			engine.unbindExternalTextureBuffer(mActiveBuffer->getId());
			}
			}

	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	// Interface implementation for Layer		// Interface implementation for Layer
	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	@@ -610,10 +620,6 @@ void BufferStateLayer::onFirstRef() {
	}		}
	}		}

	void BufferStateLayer::bufferErased(const client_cache_t& clientCacheId) {
	mFlinger->getRenderEngine().unbindExternalTextureBuffer(clientCacheId.id);
	}

	void BufferStateLayer::HwcSlotGenerator::bufferErased(const client_cache_t& clientCacheId) {		void BufferStateLayer::HwcSlotGenerator::bufferErased(const client_cache_t& clientCacheId) {
	std::lock_guard lock(mMutex);		std::lock_guard lock(mMutex);
	if (!clientCacheId.isValid()) {		if (!clientCacheId.isValid()) {

services/surfaceflinger/BufferStateLayer.h

+2 −3

Original line number	Original line	Diff line number	Diff line
	@@ -35,6 +35,8 @@ class BufferStateLayer : public BufferLayer {
	public:		public:
	explicit BufferStateLayer(const LayerCreationArgs&);		explicit BufferStateLayer(const LayerCreationArgs&);

			~BufferStateLayer() override;

	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	// Interface implementation for Layer		// Interface implementation for Layer
	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	@@ -102,9 +104,6 @@ public:
	bool fenceHasSignaled() const override;		bool fenceHasSignaled() const override;
	bool framePresentTimeIsCurrent() const override;		bool framePresentTimeIsCurrent() const override;

	// Inherit from ClientCache::ErasedRecipient
	void bufferErased(const client_cache_t& clientCacheId) override;

	private:		private:
	nsecs_t getDesiredPresentTime() override;		nsecs_t getDesiredPresentTime() override;
	std::shared_ptr<FenceTime> getCurrentFenceTime() const override;		std::shared_ptr<FenceTime> getCurrentFenceTime() const override;

services/surfaceflinger/ClientCache.cpp

+10 −8

Original line number	Original line	Diff line number	Diff line
	@@ -55,16 +55,16 @@ bool ClientCache::getBuffer(const client_cache_t& cacheId,
	return true;		return true;
	}		}

	void ClientCache::add(const client_cache_t& cacheId, const sp<GraphicBuffer>& buffer) {		bool ClientCache::add(const client_cache_t& cacheId, const sp<GraphicBuffer>& buffer) {
	auto& [processToken, id] = cacheId;		auto& [processToken, id] = cacheId;
	if (processToken == nullptr) {		if (processToken == nullptr) {
	ALOGE("failed to cache buffer: invalid process token");		ALOGE("failed to cache buffer: invalid process token");
	return;		return false;
	}		}

	if (!buffer) {		if (!buffer) {
	ALOGE("failed to cache buffer: invalid buffer");		ALOGE("failed to cache buffer: invalid buffer");
	return;		return false;
	}		}

	std::lock_guard lock(mMutex);		std::lock_guard lock(mMutex);
	@@ -77,13 +77,13 @@ void ClientCache::add(const client_cache_t& cacheId, const sp<GraphicBuffer>& bu
	token = processToken.promote();		token = processToken.promote();
	if (!token) {		if (!token) {
	ALOGE("failed to cache buffer: invalid token");		ALOGE("failed to cache buffer: invalid token");
	return;		return false;
	}		}

	status_t err = token->linkToDeath(mDeathRecipient);		status_t err = token->linkToDeath(mDeathRecipient);
	if (err != NO_ERROR) {		if (err != NO_ERROR) {
	ALOGE("failed to cache buffer: could not link to death");		ALOGE("failed to cache buffer: could not link to death");
	return;		return false;
	}		}
	auto [itr, success] =		auto [itr, success] =
	mBuffers.emplace(processToken, std::unordered_map<uint64_t, ClientCacheBuffer>());		mBuffers.emplace(processToken, std::unordered_map<uint64_t, ClientCacheBuffer>());
	@@ -95,10 +95,11 @@ void ClientCache::add(const client_cache_t& cacheId, const sp<GraphicBuffer>& bu

	if (processBuffers.size() > BUFFER_CACHE_MAX_SIZE) {		if (processBuffers.size() > BUFFER_CACHE_MAX_SIZE) {
	ALOGE("failed to cache buffer: cache is full");		ALOGE("failed to cache buffer: cache is full");
	return;		return false;
	}		}

	processBuffers[id].buffer = buffer;		processBuffers[id].buffer = buffer;
			return true;
	}		}

	void ClientCache::erase(const client_cache_t& cacheId) {		void ClientCache::erase(const client_cache_t& cacheId) {
	@@ -139,16 +140,17 @@ sp<GraphicBuffer> ClientCache::get(const client_cache_t& cacheId) {
	return buf->buffer;		return buf->buffer;
	}		}

	void ClientCache::registerErasedRecipient(const client_cache_t& cacheId,		bool ClientCache::registerErasedRecipient(const client_cache_t& cacheId,
	const wp<ErasedRecipient>& recipient) {		const wp<ErasedRecipient>& recipient) {
	std::lock_guard lock(mMutex);		std::lock_guard lock(mMutex);

	ClientCacheBuffer* buf = nullptr;		ClientCacheBuffer* buf = nullptr;
	if (!getBuffer(cacheId, &buf)) {		if (!getBuffer(cacheId, &buf)) {
	ALOGE("failed to register erased recipient, could not retrieve buffer");		ALOGE("failed to register erased recipient, could not retrieve buffer");
	return;		return false;
	}		}
	buf->recipients.insert(recipient);		buf->recipients.insert(recipient);
			return true;
	}		}

	void ClientCache::unregisterErasedRecipient(const client_cache_t& cacheId,		void ClientCache::unregisterErasedRecipient(const client_cache_t& cacheId,

services/surfaceflinger/ClientCache.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -36,7 +36,7 @@ class ClientCache : public Singleton<ClientCache> {
	public:		public:
	ClientCache();		ClientCache();

	void add(const client_cache_t& cacheId, const sp<GraphicBuffer>& buffer);		bool add(const client_cache_t& cacheId, const sp<GraphicBuffer>& buffer);
	void erase(const client_cache_t& cacheId);		void erase(const client_cache_t& cacheId);

	sp<GraphicBuffer> get(const client_cache_t& cacheId);		sp<GraphicBuffer> get(const client_cache_t& cacheId);
	@@ -48,7 +48,7 @@ public:
	virtual void bufferErased(const client_cache_t& clientCacheId) = 0;		virtual void bufferErased(const client_cache_t& clientCacheId) = 0;
	};		};

	void registerErasedRecipient(const client_cache_t& cacheId,		bool registerErasedRecipient(const client_cache_t& cacheId,
	const wp<ErasedRecipient>& recipient);		const wp<ErasedRecipient>& recipient);
	void unregisterErasedRecipient(const client_cache_t& cacheId,		void unregisterErasedRecipient(const client_cache_t& cacheId,
	const wp<ErasedRecipient>& recipient);		const wp<ErasedRecipient>& recipient);