Merge changes Ic3d35a93,I46ec942d into jb-mr1-dev (14bd369e) · Commits · e / os / platform_frameworks_native

include/gui/BufferQueue.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -422,10 +422,6 @@ private:
		// in requestBuffers() if a width and height of zero is specified.
		uint32_t mDefaultHeight;

		// mPixelFormat holds the pixel format of allocated buffers. It is used
		// in requestBuffers() if a format of zero is specified.
		uint32_t mPixelFormat;

		// mMinUndequeuedBuffers is a constraint on the number of buffers
		// not dequeued at any time
		int mMinUndequeuedBuffers;

include/gui/ConsumerBase.h

0 → 100644

+209 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_GUI_CONSUMERBASE_H
		#define ANDROID_GUI_CONSUMERBASE_H

		#include <gui/BufferQueue.h>

		#include <ui/GraphicBuffer.h>

		#include <utils/String8.h>
		#include <utils/Vector.h>
		#include <utils/threads.h>

		namespace android {
		// ----------------------------------------------------------------------------

		class String8;

		// ConsumerBase is a base class for BufferQueue consumer end-points. It
		// handles common tasks like management of the connection to the BufferQueue
		// and the buffer pool.
		class ConsumerBase : public virtual RefBase,
		protected BufferQueue::ConsumerListener {
		public:
		struct FrameAvailableListener : public virtual RefBase {
		// onFrameAvailable() is called each time an additional frame becomes
		// available for consumption. This means that frames that are queued
		// while in asynchronous mode only trigger the callback if no previous
		// frames are pending. Frames queued while in synchronous mode always
		// trigger the callback.
		//
		// This is called without any lock held and can be called concurrently
		// by multiple threads.
		virtual void onFrameAvailable() = 0;
		};

		virtual ~ConsumerBase();

		// abandon frees all the buffers and puts the ConsumerBase into the
		// 'abandoned' state. Once put in this state the ConsumerBase can never
		// leave it. When in the 'abandoned' state, all methods of the
		// ISurfaceTexture interface will fail with the NO_INIT error.
		//
		// Note that while calling this method causes all the buffers to be freed
		// from the perspective of the the ConsumerBase, if there are additional
		// references on the buffers (e.g. if a buffer is referenced by a client
		// or by OpenGL ES as a texture) then those buffer will remain allocated.
		void abandon();

		// set the name of the ConsumerBase that will be used to identify it in
		// log messages.
		void setName(const String8& name);

		// getBufferQueue returns the BufferQueue object to which this
		// ConsumerBase is connected.
		sp<BufferQueue> getBufferQueue() const;

		// dump writes the current state to a string. These methods should NOT be
		// overridden by child classes. Instead they should override the
		// dumpLocked method, which is called by these methods after locking the
		// mutex.
		void dump(String8& result) const;
		void dump(String8& result, const char* prefix, char* buffer, size_t SIZE) const;

		// setFrameAvailableListener sets the listener object that will be notified
		// when a new frame becomes available.
		void setFrameAvailableListener(const sp<FrameAvailableListener>& listener);

		private:
		ConsumerBase(const ConsumerBase&);
		void operator=(const ConsumerBase&);

		protected:

		// TODO: Fix this comment
		// ConsumerBase constructs a new ConsumerBase object. tex indicates the
		// name of the OpenGL ES texture to which images are to be streamed.
		// allowSynchronousMode specifies whether or not synchronous mode can be
		// enabled. texTarget specifies the OpenGL ES texture target to which the
		// texture will be bound in updateTexImage. useFenceSync specifies whether
		// fences should be used to synchronize access to buffers if that behavior
		// is enabled at compile-time. A custom bufferQueue can be specified
		// if behavior for queue/dequeue/connect etc needs to be customized.
		// Otherwise a default BufferQueue will be created and used.
		//
		// For legacy reasons, the ConsumerBase is created in a state where it is
		// considered attached to an OpenGL ES context for the purposes of the
		// attachToContext and detachFromContext methods. However, despite being
		// considered "attached" to a context, the specific OpenGL ES context
		// doesn't get latched until the first call to updateTexImage. After that
		// point, all calls to updateTexImage must be made with the same OpenGL ES
		// context current.
		//
		// A ConsumerBase may be detached from one OpenGL ES context and then
		// attached to a different context using the detachFromContext and
		// attachToContext methods, respectively. The intention of these methods is
		// purely to allow a ConsumerBase to be transferred from one consumer
		// context to another. If such a transfer is not needed there is no
		// requirement that either of these methods be called.
		ConsumerBase(const sp<BufferQueue> &bufferQueue);

		// Implementation of the BufferQueue::ConsumerListener interface. These
		// calls are used to notify the ConsumerBase of asynchronous events in the
		// BufferQueue.
		virtual void onFrameAvailable();
		virtual void onBuffersReleased();

		// freeBufferLocked frees up the given buffer slot. If the slot has been
		// initialized this will release the reference to the GraphicBuffer in that
		// slot and destroy the EGLImage in that slot. Otherwise it has no effect.
		//
		// This method must be called with mMutex locked.
		virtual void freeBufferLocked(int slotIndex);

		// abandonLocked puts the BufferQueue into the abandoned state, causing
		// all future operations on it to fail. This method rather than the public
		// abandon method should be overridden by child classes to add abandon-
		// time behavior.
		//
		// This method must be called with mMutex locked.
		virtual void abandonLocked();

		virtual void dumpLocked(String8& result, const char* prefix, char* buffer,
		size_t SIZE) const;

		// acquireBufferLocked fetches the next buffer from the BufferQueue and
		// updates the buffer slot for the buffer returned.
		virtual status_t acquireBufferLocked(BufferQueue::BufferItem *item);

		// releaseBufferLocked relinquishes control over a buffer, returning that
		// control to the BufferQueue.
		virtual status_t releaseBufferLocked(int buf, EGLDisplay display,
		EGLSyncKHR eglFence, const sp<Fence>& fence);

		// Slot contains the information and object references that
		// ConsumerBase maintains about a BufferQueue buffer slot.
		struct Slot {
		// mGraphicBuffer is the Gralloc buffer store in the slot or NULL if
		// no Gralloc buffer is in the slot.
		sp<GraphicBuffer> mGraphicBuffer;

		// mFence is a fence which will signal when the buffer associated with
		// this buffer slot is no longer being used by the consumer and can be
		// overwritten. The buffer can be dequeued before the fence signals;
		// the producer is responsible for delaying writes until it signals.
		sp<Fence> mFence;
		};

		// mSlots stores the buffers that have been allocated by the BufferQueue
		// for each buffer slot. It is initialized to null pointers, and gets
		// filled in with the result of BufferQueue::acquire when the
		// client dequeues a buffer from a
		// slot that has not yet been used. The buffer allocated to a slot will also
		// be replaced if the requested buffer usage or geometry differs from that
		// of the buffer allocated to a slot.
		Slot mSlots[BufferQueue::NUM_BUFFER_SLOTS];

		// mAbandoned indicates that the BufferQueue will no longer be used to
		// consume images buffers pushed to it using the ISurfaceTexture
		// interface. It is initialized to false, and set to true in the abandon
		// method. A BufferQueue that has been abandoned will return the NO_INIT
		// error from all IConsumerBase methods capable of returning an error.
		bool mAbandoned;

		// mName is a string used to identify the ConsumerBase in log messages.
		// It can be set by the setName method.
		String8 mName;

		// mFrameAvailableListener is the listener object that will be called when a
		// new frame becomes available. If it is not NULL it will be called from
		// queueBuffer.
		sp<FrameAvailableListener> mFrameAvailableListener;

		// The ConsumerBase has-a BufferQueue and is responsible for creating this object
		// if none is supplied
		sp<BufferQueue> mBufferQueue;

		// mAttached indicates whether the ConsumerBase is currently attached to
		// an OpenGL ES context. For legacy reasons, this is initialized to true,
		// indicating that the ConsumerBase is considered to be attached to
		// whatever context is current at the time of the first updateTexImage call.
		// It is set to false by detachFromContext, and then set to true again by
		// attachToContext.
		bool mAttached;

		// mMutex is the mutex used to prevent concurrent access to the member
		// variables of ConsumerBase objects. It must be locked whenever the
		// member variables are accessed.
		mutable Mutex mMutex;
		};

		// ----------------------------------------------------------------------------
		}; // namespace android

		#endif // ANDROID_GUI_CONSUMERBASE_H

libs/gui/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -4,6 +4,7 @@ include $(CLEAR_VARS)
		LOCAL_SRC_FILES:= \
		BitTube.cpp \
		BufferQueue.cpp \
		ConsumerBase.cpp \
		DisplayEventReceiver.cpp \
		IDisplayEventConnection.cpp \
		ISensorEventConnection.cpp \

libs/gui/BufferQueue.cpp

+22 −30

Original line number	Diff line number	Diff line
		@@ -85,7 +85,6 @@ BufferQueue::BufferQueue(bool allowSynchronousMode, int bufferCount,
		const sp<IGraphicBufferAlloc>& allocator) :
		mDefaultWidth(1),
		mDefaultHeight(1),
		mPixelFormat(PIXEL_FORMAT_RGBA_8888),
		mMinUndequeuedBuffers(bufferCount),
		mMinAsyncBufferSlots(bufferCount + 1),
		mMinSyncBufferSlots(bufferCount),
		@@ -98,7 +97,7 @@ BufferQueue::BufferQueue(bool allowSynchronousMode, int bufferCount,
		mAbandoned(false),
		mFrameCounter(0),
		mBufferHasBeenQueued(false),
		mDefaultBufferFormat(0),
		mDefaultBufferFormat(PIXEL_FORMAT_RGBA_8888),
		mConsumerUsageBits(0),
		mTransformHint(0)
		{
		@@ -125,7 +124,8 @@ status_t BufferQueue::setBufferCountServerLocked(int bufferCount) {
		if (bufferCount > NUM_BUFFER_SLOTS)
		return BAD_VALUE;

		// special-case, nothing to do
		mServerBufferCount = bufferCount;

		if (bufferCount == mBufferCount)
		return OK;

		@@ -133,7 +133,6 @@ status_t BufferQueue::setBufferCountServerLocked(int bufferCount) {
		bufferCount >= mBufferCount) {
		// easy, we just have more buffers
		mBufferCount = bufferCount;
		mServerBufferCount = bufferCount;
		mDequeueCondition.broadcast();
		} else {
		// we're here because we're either
		@@ -150,7 +149,6 @@ status_t BufferQueue::setBufferCountServerLocked(int bufferCount) {
		// own one. the actual resizing will happen during the next
		// dequeueBuffer.

		mServerBufferCount = bufferCount;
		mDequeueCondition.broadcast();
		}
		return OK;
		@@ -260,7 +258,7 @@ int BufferQueue::query(int what, int* outValue)
		value = mDefaultHeight;
		break;
		case NATIVE_WINDOW_FORMAT:
		value = mPixelFormat;
		value = mDefaultBufferFormat;
		break;
		case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
		value = mSynchronousMode ?
		@@ -447,12 +445,6 @@ status_t BufferQueue::dequeueBuffer(int *outBuf, sp<Fence>& outFence,
		h = mDefaultHeight;
		}

		const bool updateFormat = (format != 0);
		if (!updateFormat) {
		// keep the current (or default) format
		format = mPixelFormat;
		}

		// buffer is now in DEQUEUED (but can also be current at the same time,
		// if we're in synchronous mode)
		mSlots[buf].mBufferState = BufferSlot::DEQUEUED;
		@@ -473,9 +465,6 @@ status_t BufferQueue::dequeueBuffer(int *outBuf, sp<Fence>& outFence,
		"failed");
		return error;
		}
		if (updateFormat) {
		mPixelFormat = format;
		}

		mSlots[buf].mAcquireCalled = false;
		mSlots[buf].mGraphicBuffer = graphicBuffer;
		@@ -791,9 +780,9 @@ void BufferQueue::dump(String8& result, const char* prefix,

		snprintf(buffer, SIZE,
		"%s-BufferQueue mBufferCount=%d, mSynchronousMode=%d, default-size=[%dx%d], "
		"mPixelFormat=%d, FIFO(%d)={%s}\n",
		"default-format=%d, FIFO(%d)={%s}\n",
		prefix, mBufferCount, mSynchronousMode, mDefaultWidth,
		mDefaultHeight, mPixelFormat, fifoSize, fifo.string());
		mDefaultHeight, mDefaultBufferFormat, fifoSize, fifo.string());
		result.append(buffer);


		@@ -835,21 +824,22 @@ void BufferQueue::dump(String8& result, const char* prefix,
		}
		}

		void BufferQueue::freeBufferLocked(int i) {
		mSlots[i].mGraphicBuffer = 0;
		if (mSlots[i].mBufferState == BufferSlot::ACQUIRED) {
		mSlots[i].mNeedsCleanupOnRelease = true;
		void BufferQueue::freeBufferLocked(int slot) {
		ST_LOGV("freeBufferLocked: slot=%d", slot);
		mSlots[slot].mGraphicBuffer = 0;
		if (mSlots[slot].mBufferState == BufferSlot::ACQUIRED) {
		mSlots[slot].mNeedsCleanupOnRelease = true;
		}
		mSlots[i].mBufferState = BufferSlot::FREE;
		mSlots[i].mFrameNumber = 0;
		mSlots[i].mAcquireCalled = false;
		mSlots[slot].mBufferState = BufferSlot::FREE;
		mSlots[slot].mFrameNumber = 0;
		mSlots[slot].mAcquireCalled = false;

		// destroy fence as BufferQueue now takes ownership
		if (mSlots[i].mEglFence != EGL_NO_SYNC_KHR) {
		eglDestroySyncKHR(mSlots[i].mEglDisplay, mSlots[i].mEglFence);
		mSlots[i].mEglFence = EGL_NO_SYNC_KHR;
		if (mSlots[slot].mEglFence != EGL_NO_SYNC_KHR) {
		eglDestroySyncKHR(mSlots[slot].mEglDisplay, mSlots[slot].mEglFence);
		mSlots[slot].mEglFence = EGL_NO_SYNC_KHR;
		}
		mSlots[i].mFence.clear();
		mSlots[slot].mFence.clear();
		}

		void BufferQueue::freeAllBuffersLocked() {
		@@ -886,12 +876,14 @@ status_t BufferQueue::acquireBuffer(BufferItem *buffer) {
		buffer->mTimestamp = mSlots[buf].mTimestamp;
		buffer->mBuf = buf;
		buffer->mFence = mSlots[buf].mFence;
		mSlots[buf].mAcquireCalled = true;

		mSlots[buf].mAcquireCalled = true;
		mSlots[buf].mNeedsCleanupOnRelease = false;
		mSlots[buf].mBufferState = BufferSlot::ACQUIRED;
		mSlots[buf].mFence.clear();

		mQueue.erase(front);
		mDequeueCondition.broadcast();
		mSlots[buf].mFence.clear();

		ATRACE_INT(mConsumerName.string(), mQueue.size());
		} else {

libs/gui/ConsumerBase.cpp

0 → 100644

+205 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#define LOG_TAG "ConsumerBase"
		#define ATRACE_TAG ATRACE_TAG_GRAPHICS
		//#define LOG_NDEBUG 0

		#define GL_GLEXT_PROTOTYPES
		#define EGL_EGLEXT_PROTOTYPES

		#include <EGL/egl.h>
		#include <EGL/eglext.h>

		#include <hardware/hardware.h>

		#include <gui/IGraphicBufferAlloc.h>
		#include <gui/ISurfaceComposer.h>
		#include <gui/SurfaceComposerClient.h>
		#include <gui/ConsumerBase.h>

		#include <private/gui/ComposerService.h>

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

		// Macros for including the ConsumerBase name in log messages
		#define CB_LOGV(x, ...) ALOGV("[%s] "x, mName.string(), ##__VA_ARGS__)
		#define CB_LOGD(x, ...) ALOGD("[%s] "x, mName.string(), ##__VA_ARGS__)
		#define CB_LOGI(x, ...) ALOGI("[%s] "x, mName.string(), ##__VA_ARGS__)
		#define CB_LOGW(x, ...) ALOGW("[%s] "x, mName.string(), ##__VA_ARGS__)
		#define CB_LOGE(x, ...) ALOGE("[%s] "x, mName.string(), ##__VA_ARGS__)

		namespace android {

		// Get an ID that's unique within this process.
		static int32_t createProcessUniqueId() {
		static volatile int32_t globalCounter = 0;
		return android_atomic_inc(&globalCounter);
		}

		ConsumerBase::ConsumerBase(const sp<BufferQueue>& bufferQueue) :
		mBufferQueue(bufferQueue) {
		// Choose a name using the PID and a process-unique ID.
		mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());

		// Note that we can't create an sp<...>(this) in a ctor that will not keep a
		// reference once the ctor ends, as that would cause the refcount of 'this'
		// dropping to 0 at the end of the ctor. Since all we need is a wp<...>
		// that's what we create.
		wp<BufferQueue::ConsumerListener> listener;
		sp<BufferQueue::ConsumerListener> proxy;
		listener = static_cast<BufferQueue::ConsumerListener*>(this);
		proxy = new BufferQueue::ProxyConsumerListener(listener);

		status_t err = mBufferQueue->consumerConnect(proxy);
		if (err != NO_ERROR) {
		CB_LOGE("SurfaceTexture: error connecting to BufferQueue: %s (%d)",
		strerror(-err), err);
		} else {
		mBufferQueue->setConsumerName(mName);
		}
		}

		ConsumerBase::~ConsumerBase() {
		CB_LOGV("~ConsumerBase");
		abandon();
		}

		void ConsumerBase::freeBufferLocked(int slotIndex) {
		CB_LOGV("freeBufferLocked: slotIndex=%d", slotIndex);
		mSlots[slotIndex].mGraphicBuffer = 0;
		mSlots[slotIndex].mFence = 0;
		}

		// Used for refactoring, should not be in final interface
		sp<BufferQueue> ConsumerBase::getBufferQueue() const {
		Mutex::Autolock lock(mMutex);
		return mBufferQueue;
		}

		void ConsumerBase::onFrameAvailable() {
		CB_LOGV("onFrameAvailable");

		sp<FrameAvailableListener> listener;
		{ // scope for the lock
		Mutex::Autolock lock(mMutex);
		listener = mFrameAvailableListener;
		}

		if (listener != NULL) {
		CB_LOGV("actually calling onFrameAvailable");
		listener->onFrameAvailable();
		}
		}

		void ConsumerBase::onBuffersReleased() {
		Mutex::Autolock lock(mMutex);

		CB_LOGV("onBuffersReleased");

		if (mAbandoned) {
		// Nothing to do if we're already abandoned.
		return;
		}

		uint32_t mask = 0;
		mBufferQueue->getReleasedBuffers(&mask);
		for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
		if (mask & (1 << i)) {
		freeBufferLocked(i);
		}
		}
		}

		void ConsumerBase::abandon() {
		CB_LOGV("abandon");
		Mutex::Autolock lock(mMutex);

		if (!mAbandoned) {
		abandonLocked();
		mAbandoned = true;
		}
		}

		void ConsumerBase::abandonLocked() {
		CB_LOGV("abandonLocked");
		for (int i =0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
		freeBufferLocked(i);
		}
		// disconnect from the BufferQueue
		mBufferQueue->consumerDisconnect();
		mBufferQueue.clear();
		}

		void ConsumerBase::setFrameAvailableListener(
		const sp<FrameAvailableListener>& listener) {
		CB_LOGV("setFrameAvailableListener");
		Mutex::Autolock lock(mMutex);
		mFrameAvailableListener = listener;
		}

		void ConsumerBase::dump(String8& result) const {
		char buffer[1024];
		dump(result, "", buffer, 1024);
		}

		void ConsumerBase::dump(String8& result, const char* prefix,
		char* buffer, size_t size) const {
		Mutex::Autolock _l(mMutex);
		dumpLocked(result, prefix, buffer, size);
		}

		void ConsumerBase::dumpLocked(String8& result, const char* prefix,
		char* buffer, size_t SIZE) const {
		snprintf(buffer, SIZE, "%smAbandoned=%d\n", prefix, int(mAbandoned));
		result.append(buffer);

		if (!mAbandoned) {
		mBufferQueue->dump(result, prefix, buffer, SIZE);
		}
		}

		status_t ConsumerBase::acquireBufferLocked(BufferQueue::BufferItem *item) {
		status_t err = mBufferQueue->acquireBuffer(item);
		if (err != NO_ERROR) {
		return err;
		}

		if (item->mGraphicBuffer != NULL) {
		mSlots[item->mBuf].mGraphicBuffer = item->mGraphicBuffer;
		}

		CB_LOGV("acquireBufferLocked: -> slot=%d", item->mBuf);

		return OK;
		}

		status_t ConsumerBase::releaseBufferLocked(int slot, EGLDisplay display,
		EGLSyncKHR eglFence, const sp<Fence>& fence) {
		CB_LOGV("releaseBufferLocked: slot=%d", slot);
		status_t err = mBufferQueue->releaseBuffer(slot, display, eglFence, fence);
		if (err == BufferQueue::STALE_BUFFER_SLOT) {
		freeBufferLocked(slot);
		}

		mSlots[slot].mFence.clear();

		return err;
		}

		} // namespace android
		No newline at end of file