Merge "libgui: ConsumerBase-based classes now create their own BufferQueues" into main (9d934309) · Commits · e / os / android_frameworks_native

libs/gui/BLASTBufferQueue.cpp

+12 −4

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@
		#define ATRACE_TAG ATRACE_TAG_GRAPHICS
		//#define LOG_NDEBUG 0

		#include <com_android_graphics_libgui_flags.h>
		#include <cutils/atomic.h>
		#include <gui/BLASTBufferQueue.h>
		#include <gui/BufferItemConsumer.h>
		@@ -174,14 +175,21 @@ BLASTBufferQueue::BLASTBufferQueue(const std::string& name, bool updateDestinati
		mSyncTransaction(nullptr),
		mUpdateDestinationFrame(updateDestinationFrame) {
		createBufferQueue(&mProducer, &mConsumer);
		// since the adapter is in the client process, set dequeue timeout
		// explicitly so that dequeueBuffer will block
		mProducer->setDequeueTimeout(std::numeric_limits<int64_t>::max());

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		mBufferItemConsumer = new BLASTBufferItemConsumer(mProducer, mConsumer,
		GraphicBuffer::USAGE_HW_COMPOSER \|
		GraphicBuffer::USAGE_HW_TEXTURE,
		1, false, this);
		#else
		mBufferItemConsumer = new BLASTBufferItemConsumer(mConsumer,
		GraphicBuffer::USAGE_HW_COMPOSER \|
		GraphicBuffer::USAGE_HW_TEXTURE,
		1, false, this);
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		// since the adapter is in the client process, set dequeue timeout
		// explicitly so that dequeueBuffer will block
		mProducer->setDequeueTimeout(std::numeric_limits<int64_t>::max());

		static std::atomic<uint32_t> nextId = 0;
		mProducerId = nextId++;
		mName = name + "#" + std::to_string(mProducerId);

libs/gui/BufferItemConsumer.cpp

+23 −4

Original line number	Diff line number	Diff line
		@@ -35,18 +35,37 @@

		namespace android {

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		BufferItemConsumer::BufferItemConsumer(uint64_t consumerUsage, int bufferCount,
		bool controlledByApp, bool isConsumerSurfaceFlinger)
		: ConsumerBase(controlledByApp, isConsumerSurfaceFlinger) {
		initialize(consumerUsage, bufferCount);
		}

		BufferItemConsumer::BufferItemConsumer(const sp<IGraphicBufferProducer>& producer,
		const sp<IGraphicBufferConsumer>& consumer,
		uint64_t consumerUsage, int bufferCount,
		bool controlledByApp)
		: ConsumerBase(producer, consumer, controlledByApp) {
		initialize(consumerUsage, bufferCount);
		}
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

		BufferItemConsumer::BufferItemConsumer(
		const sp<IGraphicBufferConsumer>& consumer, uint64_t consumerUsage,
		int bufferCount, bool controlledByApp) :
		ConsumerBase(consumer, controlledByApp)
		{
		initialize(consumerUsage, bufferCount);
		}

		void BufferItemConsumer::initialize(uint64_t consumerUsage, int bufferCount) {
		status_t err = mConsumer->setConsumerUsageBits(consumerUsage);
		LOG_ALWAYS_FATAL_IF(err != OK,
		"Failed to set consumer usage bits to %#" PRIx64, consumerUsage);
		LOG_ALWAYS_FATAL_IF(err != OK, "Failed to set consumer usage bits to %#" PRIx64, consumerUsage);
		if (bufferCount != DEFAULT_MAX_BUFFERS) {
		err = mConsumer->setMaxAcquiredBufferCount(bufferCount);
		LOG_ALWAYS_FATAL_IF(err != OK,
		"Failed to set max acquired buffer count to %d", bufferCount);
		LOG_ALWAYS_FATAL_IF(err != OK, "Failed to set max acquired buffer count to %d",
		bufferCount);
		}
		}

libs/gui/ConsumerBase.cpp

+64 −4

Original line number	Diff line number	Diff line
		@@ -14,8 +14,6 @@
		* limitations under the License.
		*/

		#include <inttypes.h>

		#define LOG_TAG "ConsumerBase"
		#define ATRACE_TAG ATRACE_TAG_GRAPHICS
		//#define LOG_NDEBUG 0
		@@ -29,19 +27,22 @@

		#include <cutils/atomic.h>

		#include <com_android_graphics_libgui_flags.h>
		#include <gui/BufferItem.h>
		#include <gui/BufferQueue.h>
		#include <gui/ConsumerBase.h>
		#include <gui/ISurfaceComposer.h>
		#include <gui/Surface.h>
		#include <gui/SurfaceComposerClient.h>
		#include <ui/BufferQueueDefs.h>

		#include <private/gui/ComposerService.h>

		#include <log/log.h>
		#include <utils/Log.h>
		#include <utils/String8.h>
		#include <utils/Trace.h>

		#include <com_android_graphics_libgui_flags.h>
		#include <inttypes.h>

		// Macros for including the ConsumerBase name in log messages
		#define CB_LOGV(x, ...) ALOGV("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		@@ -62,6 +63,30 @@ ConsumerBase::ConsumerBase(const sp<IGraphicBufferConsumer>& bufferQueue, bool c
		mAbandoned(false),
		mConsumer(bufferQueue),
		mPrevFinalReleaseFence(Fence::NO_FENCE) {
		initialize(controlledByApp);
		}

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		ConsumerBase::ConsumerBase(bool controlledByApp, bool consumerIsSurfaceFlinger)
		: mAbandoned(false), mPrevFinalReleaseFence(Fence::NO_FENCE) {
		sp<IGraphicBufferProducer> producer;
		BufferQueue::createBufferQueue(&producer, &mConsumer, consumerIsSurfaceFlinger);
		mSurface = sp<Surface>::make(producer, controlledByApp);
		initialize(controlledByApp);
		}

		ConsumerBase::ConsumerBase(const sp<IGraphicBufferProducer>& producer,
		const sp<IGraphicBufferConsumer>& consumer, bool controlledByApp)
		: mAbandoned(false),
		mConsumer(consumer),
		mSurface(sp<Surface>::make(producer, controlledByApp)),
		mPrevFinalReleaseFence(Fence::NO_FENCE) {
		initialize(controlledByApp);
		}

		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

		void ConsumerBase::initialize(bool controlledByApp) {
		// Choose a name using the PID and a process-unique ID.
		mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());

		@@ -355,6 +380,17 @@ status_t ConsumerBase::setTransformHint(uint32_t hint) {
		return mConsumer->setTransformHint(hint);
		}

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		status_t ConsumerBase::setMaxBufferCount(int bufferCount) {
		Mutex::Autolock lock(mMutex);
		if (mAbandoned) {
		CB_LOGE("setMaxBufferCount: ConsumerBase is abandoned!");
		return NO_INIT;
		}
		return mConsumer->setMaxBufferCount(bufferCount);
		}
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

		status_t ConsumerBase::setMaxAcquiredBufferCount(int maxAcquiredBuffers) {
		Mutex::Autolock lock(mMutex);
		if (mAbandoned) {
		@@ -364,6 +400,17 @@ status_t ConsumerBase::setMaxAcquiredBufferCount(int maxAcquiredBuffers) {
		return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers);
		}

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		status_t ConsumerBase::setConsumerIsProtected(bool isProtected) {
		Mutex::Autolock lock(mMutex);
		if (mAbandoned) {
		CB_LOGE("setConsumerIsProtected: ConsumerBase is abandoned!");
		return NO_INIT;
		}
		return mConsumer->setConsumerIsProtected(isProtected);
		}
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

		sp<NativeHandle> ConsumerBase::getSidebandStream() const {
		Mutex::Autolock _l(mMutex);
		if (mAbandoned) {
		@@ -430,6 +477,19 @@ void ConsumerBase::dumpLocked(String8& result, const char* prefix) const {
		}
		}

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		sp<Surface> ConsumerBase::getSurface() const {
		LOG_ALWAYS_FATAL_IF(mSurface == nullptr,
		"It's illegal to get the surface of a Consumer that does not own it. This "
		"should be impossible once the old CTOR is removed.");
		return mSurface;
		}

		sp<IGraphicBufferConsumer> ConsumerBase::getIGraphicBufferConsumer() const {
		return mConsumer;
		}
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

		status_t ConsumerBase::acquireBufferLocked(BufferItem *item,
		nsecs_t presentWhen, uint64_t maxFrameNumber) {
		if (mAbandoned) {

libs/gui/CpuConsumer.cpp

+21 −8

Original line number	Diff line number	Diff line
		@@ -18,9 +18,9 @@
		#define LOG_TAG "CpuConsumer"
		//#define ATRACE_TAG ATRACE_TAG_GRAPHICS

		#include <gui/CpuConsumer.h>

		#include <com_android_graphics_libgui_flags.h>
		#include <gui/BufferItem.h>
		#include <gui/CpuConsumer.h>
		#include <utils/Log.h>

		#define CC_LOGV(x, ...) ALOGV("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		@@ -31,12 +31,25 @@

		namespace android {

		CpuConsumer::CpuConsumer(const sp<IGraphicBufferConsumer>& bq,
		size_t maxLockedBuffers, bool controlledByApp) :
		ConsumerBase(bq, controlledByApp),
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		CpuConsumer::CpuConsumer(size_t maxLockedBuffers, bool controlledByApp,
		bool isConsumerSurfaceFlinger)
		: ConsumerBase(controlledByApp, isConsumerSurfaceFlinger),
		mMaxLockedBuffers(maxLockedBuffers),
		mCurrentLockedBuffers(0) {
		// Create tracking entries for locked buffers
		mAcquiredBuffers.insertAt(0, maxLockedBuffers);

		mConsumer->setConsumerUsageBits(GRALLOC_USAGE_SW_READ_OFTEN);
		mConsumer->setMaxAcquiredBufferCount(static_cast<int32_t>(maxLockedBuffers));
		}
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

		CpuConsumer::CpuConsumer(const sp<IGraphicBufferConsumer>& bq, size_t maxLockedBuffers,
		bool controlledByApp)
		: ConsumerBase(bq, controlledByApp),
		mMaxLockedBuffers(maxLockedBuffers),
		mCurrentLockedBuffers(0)
		{
		mCurrentLockedBuffers(0) {
		// Create tracking entries for locked buffers
		mAcquiredBuffers.insertAt(0, maxLockedBuffers);

libs/gui/GLConsumer.cpp

+76 −21

Original line number	Diff line number	Diff line
		@@ -101,6 +101,34 @@ static bool hasEglProtectedContent() {
		return hasIt;
		}

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		GLConsumer::GLConsumer(uint32_t tex, uint32_t texTarget, bool useFenceSync, bool isControlledByApp)
		: ConsumerBase(isControlledByApp, /* isConsumerSurfaceFlinger */ false),
		mCurrentCrop(Rect::EMPTY_RECT),
		mCurrentTransform(0),
		mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
		mCurrentFence(Fence::NO_FENCE),
		mCurrentTimestamp(0),
		mCurrentDataSpace(HAL_DATASPACE_UNKNOWN),
		mCurrentFrameNumber(0),
		mDefaultWidth(1),
		mDefaultHeight(1),
		mFilteringEnabled(true),
		mTexName(tex),
		mUseFenceSync(useFenceSync),
		mTexTarget(texTarget),
		mEglDisplay(EGL_NO_DISPLAY),
		mEglContext(EGL_NO_CONTEXT),
		mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT),
		mAttached(true) {
		GLC_LOGV("GLConsumer");

		memcpy(mCurrentTransformMatrix, mtxIdentity.asArray(), sizeof(mCurrentTransformMatrix));

		mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);
		}
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

		GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t tex,
		uint32_t texTarget, bool useFenceSync, bool isControlledByApp) :
		ConsumerBase(bq, isControlledByApp),
		@@ -130,9 +158,9 @@ GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t tex,
		mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);
		}

		GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t texTarget,
		bool useFenceSync, bool isControlledByApp) :
		ConsumerBase(bq, isControlledByApp),
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		GLConsumer::GLConsumer(uint32_t texTarget, bool useFenceSync, bool isControlledByApp)
		: ConsumerBase(isControlledByApp, /* isConsumerSurfaceFlinger */ false),
		mCurrentCrop(Rect::EMPTY_RECT),
		mCurrentTransform(0),
		mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
		@@ -149,8 +177,35 @@ GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t texTarget,
		mEglDisplay(EGL_NO_DISPLAY),
		mEglContext(EGL_NO_CONTEXT),
		mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT),
		mAttached(false)
		{
		mAttached(false) {
		GLC_LOGV("GLConsumer");

		memcpy(mCurrentTransformMatrix, mtxIdentity.asArray(), sizeof(mCurrentTransformMatrix));

		mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);
		}
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

		GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t texTarget, bool useFenceSync,
		bool isControlledByApp)
		: ConsumerBase(bq, isControlledByApp),
		mCurrentCrop(Rect::EMPTY_RECT),
		mCurrentTransform(0),
		mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
		mCurrentFence(Fence::NO_FENCE),
		mCurrentTimestamp(0),
		mCurrentDataSpace(HAL_DATASPACE_UNKNOWN),
		mCurrentFrameNumber(0),
		mDefaultWidth(1),
		mDefaultHeight(1),
		mFilteringEnabled(true),
		mTexName(0),
		mUseFenceSync(useFenceSync),
		mTexTarget(texTarget),
		mEglDisplay(EGL_NO_DISPLAY),
		mEglContext(EGL_NO_CONTEXT),
		mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT),
		mAttached(false) {
		GLC_LOGV("GLConsumer");

		memcpy(mCurrentTransformMatrix, mtxIdentity.asArray(),