diff --git a/include/gui/BufferQueue.h b/include/gui/BufferQueue.h index 891383daa..3297b1044 100644 --- a/include/gui/BufferQueue.h +++ b/include/gui/BufferQueue.h @@ -17,55 +17,18 @@ #ifndef ANDROID_GUI_BUFFERQUEUE_H #define ANDROID_GUI_BUFFERQUEUE_H -#include -#include +#include +#include +#include #include // These are only required to keep other parts of the framework with incomplete // dependencies building successfully #include -#include - namespace android { -// BQProducer and BQConsumer are thin shim classes to allow methods with the -// same signature in both IGraphicBufferProducer and IGraphicBufferConsumer. -// This will stop being an issue when we deprecate creating BufferQueues -// directly (as opposed to using the *Producer and *Consumer interfaces). -class BQProducer : public BnGraphicBufferProducer { -public: - virtual status_t detachProducerBuffer(int slot) = 0; - virtual status_t attachProducerBuffer(int* slot, - const sp& buffer) = 0; - - virtual status_t detachBuffer(int slot) { - return detachProducerBuffer(slot); - } - - virtual status_t attachBuffer(int* slot, const sp& buffer) { - return attachProducerBuffer(slot, buffer); - } -}; - -class BQConsumer : public BnGraphicBufferConsumer { -public: - virtual status_t detachConsumerBuffer(int slot) = 0; - virtual status_t attachConsumerBuffer(int* slot, - const sp& buffer) = 0; - - virtual status_t detachBuffer(int slot) { - return detachConsumerBuffer(slot); - } - - virtual status_t attachBuffer(int* slot, const sp& buffer) { - return attachConsumerBuffer(slot, buffer); - } -}; - -class BufferQueue : public BQProducer, - public BQConsumer, - private IBinder::DeathRecipient { +class BufferQueue { public: // BufferQueue will keep track of at most this value of buffers. // Attempts at runtime to increase the number of buffers past this will fail. @@ -84,6 +47,7 @@ public: // for backward source compatibility typedef ::android::ConsumerListener ConsumerListener; + typedef IGraphicBufferConsumer::BufferItem BufferItem; // ProxyConsumerListener is a ConsumerListener implementation that keeps a weak // reference to the actual consumer object. It forwards all calls to that @@ -110,272 +74,12 @@ public: // BufferQueue manages a pool of gralloc memory slots to be used by // producers and consumers. allocator is used to allocate all the // needed gralloc buffers. - BufferQueue(const sp& allocator = NULL); - static void createBufferQueue(sp* outProducer, sp* outConsumer, const sp& allocator = NULL); - virtual ~BufferQueue(); - - /* - * IBinder::DeathRecipient interface - */ - - virtual void binderDied(const wp& who); - - /* - * IGraphicBufferProducer interface - */ - - // Query native window attributes. The "what" values are enumerated in - // window.h (e.g. NATIVE_WINDOW_FORMAT). - virtual int query(int what, int* value); - - // setBufferCount updates the number of available buffer slots. If this - // method succeeds, buffer slots will be both unallocated and owned by - // the BufferQueue object (i.e. they are not owned by the producer or - // consumer). - // - // This will fail if the producer has dequeued any buffers, or if - // bufferCount is invalid. bufferCount must generally be a value - // between the minimum undequeued buffer count (exclusive) and NUM_BUFFER_SLOTS - // (inclusive). It may also be set to zero (the default) to indicate - // that the producer does not wish to set a value. The minimum value - // can be obtained by calling query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, - // ...). - // - // This may only be called by the producer. The consumer will be told - // to discard buffers through the onBuffersReleased callback. - virtual status_t setBufferCount(int bufferCount); - - // requestBuffer returns the GraphicBuffer for slot N. - // - // In normal operation, this is called the first time slot N is returned - // by dequeueBuffer. It must be called again if dequeueBuffer returns - // flags indicating that previously-returned buffers are no longer valid. - virtual status_t requestBuffer(int slot, sp* buf); - - // dequeueBuffer gets the next buffer slot index for the producer to use. - // If a buffer slot is available then that slot index is written to the - // location pointed to by the buf argument and a status of OK is returned. - // If no slot is available then a status of -EBUSY is returned and buf is - // unmodified. - // - // The fence parameter will be updated to hold the fence associated with - // the buffer. The contents of the buffer must not be overwritten until the - // fence signals. If the fence is Fence::NO_FENCE, the buffer may be - // written immediately. - // - // The width and height parameters must be no greater than the minimum of - // GL_MAX_VIEWPORT_DIMS and GL_MAX_TEXTURE_SIZE (see: glGetIntegerv). - // An error due to invalid dimensions might not be reported until - // updateTexImage() is called. If width and height are both zero, the - // default values specified by setDefaultBufferSize() are used instead. - // - // The pixel formats are enumerated in graphics.h, e.g. - // HAL_PIXEL_FORMAT_RGBA_8888. If the format is 0, the default format - // will be used. - // - // The usage argument specifies gralloc buffer usage flags. The values - // are enumerated in gralloc.h, e.g. GRALLOC_USAGE_HW_RENDER. These - // will be merged with the usage flags specified by setConsumerUsageBits. - // - // The return value may be a negative error value or a non-negative - // collection of flags. If the flags are set, the return values are - // valid, but additional actions must be performed. - // - // If IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION is set, the - // producer must discard cached GraphicBuffer references for the slot - // returned in buf. - // If IGraphicBufferProducer::RELEASE_ALL_BUFFERS is set, the producer - // must discard cached GraphicBuffer references for all slots. - // - // In both cases, the producer will need to call requestBuffer to get a - // GraphicBuffer handle for the returned slot. - virtual status_t dequeueBuffer(int *buf, sp* fence, bool async, - uint32_t width, uint32_t height, uint32_t format, uint32_t usage); - - // See IGraphicBufferProducer::detachBuffer - virtual status_t detachProducerBuffer(int slot); - - // See IGraphicBufferProducer::detachNextBuffer - virtual status_t detachNextBuffer(sp* outBuffer, - sp* outFence); - - // See IGraphicBufferProducer::attachBuffer - virtual status_t attachProducerBuffer(int* slot, - const sp& buffer); - - // queueBuffer returns a filled buffer to the BufferQueue. - // - // Additional data is provided in the QueueBufferInput struct. Notably, - // a timestamp must be provided for the buffer. The timestamp is in - // nanoseconds, and must be monotonically increasing. Its other semantics - // (zero point, etc) are producer-specific and should be documented by the - // producer. - // - // The caller may provide a fence that signals when all rendering - // operations have completed. Alternatively, NO_FENCE may be used, - // indicating that the buffer is ready immediately. - // - // Some values are returned in the output struct: the current settings - // for default width and height, the current transform hint, and the - // number of queued buffers. - virtual status_t queueBuffer(int buf, - const QueueBufferInput& input, QueueBufferOutput* output); - - // cancelBuffer returns a dequeued buffer to the BufferQueue, but doesn't - // queue it for use by the consumer. - // - // The buffer will not be overwritten until the fence signals. The fence - // will usually be the one obtained from dequeueBuffer. - virtual void cancelBuffer(int buf, const sp& fence); - - // See IGraphicBufferProducer::connect - virtual status_t connect(const sp& listener, - int api, bool producerControlledByApp, QueueBufferOutput* output); - - // disconnect attempts to disconnect a producer API from the BufferQueue. - // Calling this method will cause any subsequent calls to other - // IGraphicBufferProducer methods to fail except for getAllocator and connect. - // Successfully calling connect after this will allow the other methods to - // succeed again. - // - // This method will fail if the the BufferQueue is not currently - // connected to the specified producer API. - virtual status_t disconnect(int api); - - // Attaches a sideband buffer stream to the BufferQueue. - // - // A sideband stream is a device-specific mechanism for passing buffers - // from the producer to the consumer without using dequeueBuffer/ - // queueBuffer. If a sideband stream is present, the consumer can choose - // whether to acquire buffers from the sideband stream or from the queued - // buffers. - // - // Passing NULL or a different stream handle will detach the previous - // handle if any. - virtual status_t setSidebandStream(const sp& stream); - - /* - * IGraphicBufferConsumer interface - */ - - // acquireBuffer attempts to acquire ownership of the next pending buffer in - // the BufferQueue. If no buffer is pending then it returns NO_BUFFER_AVAILABLE. If a - // buffer is successfully acquired, the information about the buffer is - // returned in BufferItem. If the buffer returned had previously been - // acquired then the BufferItem::mGraphicBuffer field of buffer is set to - // NULL and it is assumed that the consumer still holds a reference to the - // buffer. - // - // If presentWhen is nonzero, it indicates the time when the buffer will - // be displayed on screen. If the buffer's timestamp is farther in the - // future, the buffer won't be acquired, and PRESENT_LATER will be - // returned. The presentation time is in nanoseconds, and the time base - // is CLOCK_MONOTONIC. - virtual status_t acquireBuffer(BufferItem* buffer, nsecs_t presentWhen); - - // See IGraphicBufferConsumer::detachBuffer - virtual status_t detachConsumerBuffer(int slot); - - // See IGraphicBufferConsumer::attachBuffer - virtual status_t attachConsumerBuffer(int* slot, - const sp& buffer); - - // releaseBuffer releases a buffer slot from the consumer back to the - // BufferQueue. This may be done while the buffer's contents are still - // being accessed. The fence will signal when the buffer is no longer - // in use. frameNumber is used to indentify the exact buffer returned. - // - // If releaseBuffer returns STALE_BUFFER_SLOT, then the consumer must free - // any references to the just-released buffer that it might have, as if it - // had received a onBuffersReleased() call with a mask set for the released - // buffer. - // - // Note that the dependencies on EGL will be removed once we switch to using - // the Android HW Sync HAL. - virtual status_t releaseBuffer(int buf, uint64_t frameNumber, - EGLDisplay display, EGLSyncKHR fence, - const sp& releaseFence); - - // consumerConnect connects a consumer to the BufferQueue. Only one - // consumer may be connected, and when that consumer disconnects the - // BufferQueue is placed into the "abandoned" state, causing most - // interactions with the BufferQueue by the producer to fail. - // controlledByApp indicates whether the consumer is controlled by - // the application. - // - // consumer may not be NULL. - virtual status_t consumerConnect(const sp& consumer, bool controlledByApp); - - // consumerDisconnect disconnects a consumer from the BufferQueue. All - // buffers will be freed and the BufferQueue is placed in the "abandoned" - // state, causing most interactions with the BufferQueue by the producer to - // fail. - virtual status_t consumerDisconnect(); - - // getReleasedBuffers sets the value pointed to by slotMask to a bit mask - // indicating which buffer slots have been released by the BufferQueue - // but have not yet been released by the consumer. - // - // This should be called from the onBuffersReleased() callback. - virtual status_t getReleasedBuffers(uint64_t* slotMask); - - // setDefaultBufferSize is used to set the size of buffers returned by - // dequeueBuffer when a width and height of zero is requested. Default - // is 1x1. - virtual status_t setDefaultBufferSize(uint32_t w, uint32_t h); - - // setDefaultMaxBufferCount sets the default value for the maximum buffer - // count (the initial default is 2). If the producer has requested a - // buffer count using setBufferCount, the default buffer count will only - // take effect if the producer sets the count back to zero. - // - // The count must be between 2 and NUM_BUFFER_SLOTS, inclusive. - virtual status_t setDefaultMaxBufferCount(int bufferCount); - - // disableAsyncBuffer disables the extra buffer used in async mode - // (when both producer and consumer have set their "isControlledByApp" - // flag) and has dequeueBuffer() return WOULD_BLOCK instead. - // - // This can only be called before consumerConnect(). - virtual status_t disableAsyncBuffer(); - - // setMaxAcquiredBufferCount sets the maximum number of buffers that can - // be acquired by the consumer at one time (default 1). This call will - // fail if a producer is connected to the BufferQueue. - virtual status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers); - - // setConsumerName sets the name used in logging - virtual void setConsumerName(const String8& name); - - // setDefaultBufferFormat allows the BufferQueue to create - // GraphicBuffers of a defaultFormat if no format is specified - // in dequeueBuffer. Formats are enumerated in graphics.h; the - // initial default is HAL_PIXEL_FORMAT_RGBA_8888. - virtual status_t setDefaultBufferFormat(uint32_t defaultFormat); - - // setConsumerUsageBits will turn on additional usage bits for dequeueBuffer. - // These are merged with the bits passed to dequeueBuffer. The values are - // enumerated in gralloc.h, e.g. GRALLOC_USAGE_HW_RENDER; the default is 0. - virtual status_t setConsumerUsageBits(uint32_t usage); - - // setTransformHint bakes in rotation to buffers so overlays can be used. - // The values are enumerated in window.h, e.g. - // NATIVE_WINDOW_TRANSFORM_ROT_90. The default is 0 (no transform). - virtual status_t setTransformHint(uint32_t hint); - - // Retrieve the BufferQueue's sideband stream, if any. - virtual sp getSidebandStream() const; - - // dump our state in a String - virtual void dump(String8& result, const char* prefix) const; - private: - sp mProducer; - sp mConsumer; + BufferQueue(); // Create through createBufferQueue }; // ---------------------------------------------------------------------------- diff --git a/libs/gui/BufferQueue.cpp b/libs/gui/BufferQueue.cpp index b07e11560..c49a8868f 100644 --- a/libs/gui/BufferQueue.cpp +++ b/libs/gui/BufferQueue.cpp @@ -19,7 +19,9 @@ //#define LOG_NDEBUG 0 #include +#include #include +#include namespace android { @@ -43,6 +45,13 @@ void BufferQueue::ProxyConsumerListener::onBuffersReleased() { } } +void BufferQueue::ProxyConsumerListener::onSidebandStreamChanged() { + sp listener(mConsumerListener.promote()); + if (listener != NULL) { + listener->onSidebandStreamChanged(); + } +} + void BufferQueue::createBufferQueue(sp* outProducer, sp* outConsumer, const sp& allocator) { @@ -67,151 +76,4 @@ void BufferQueue::createBufferQueue(sp* outProducer, *outConsumer = consumer; } -BufferQueue::BufferQueue(const sp& allocator) : - mProducer(), - mConsumer() -{ - sp core(new BufferQueueCore(allocator)); - mProducer = new BufferQueueProducer(core); - mConsumer = new BufferQueueConsumer(core); -} - -BufferQueue::~BufferQueue() {} - -void BufferQueue::binderDied(const wp& who) { - mProducer->binderDied(who); -} - -int BufferQueue::query(int what, int* outValue) { - return mProducer->query(what, outValue); -} - -status_t BufferQueue::setBufferCount(int bufferCount) { - return mProducer->setBufferCount(bufferCount); -} - -status_t BufferQueue::requestBuffer(int slot, sp* buf) { - return mProducer->requestBuffer(slot, buf); -} - -status_t BufferQueue::dequeueBuffer(int *outBuf, sp* outFence, bool async, - uint32_t w, uint32_t h, uint32_t format, uint32_t usage) { - return mProducer->dequeueBuffer(outBuf, outFence, async, w, h, format, usage); -} - -status_t BufferQueue::detachProducerBuffer(int slot) { - return mProducer->detachBuffer(slot); -} - -status_t BufferQueue::detachNextBuffer(sp* outBuffer, - sp* outFence) { - return mProducer->detachNextBuffer(outBuffer, outFence); -} - -status_t BufferQueue::attachProducerBuffer(int* slot, - const sp& buffer) { - return mProducer->attachBuffer(slot, buffer); -} - -status_t BufferQueue::queueBuffer(int buf, - const QueueBufferInput& input, QueueBufferOutput* output) { - return mProducer->queueBuffer(buf, input, output); -} - -void BufferQueue::cancelBuffer(int buf, const sp& fence) { - mProducer->cancelBuffer(buf, fence); -} - -status_t BufferQueue::connect(const sp& listener, - int api, bool producerControlledByApp, QueueBufferOutput* output) { - return mProducer->connect(listener, api, producerControlledByApp, output); -} - -status_t BufferQueue::disconnect(int api) { - return mProducer->disconnect(api); -} - -status_t BufferQueue::setSidebandStream(const sp& stream) { - return mProducer->setSidebandStream(stream); -} - -status_t BufferQueue::acquireBuffer(BufferItem* buffer, nsecs_t presentWhen) { - return mConsumer->acquireBuffer(buffer, presentWhen); -} - -status_t BufferQueue::detachConsumerBuffer(int slot) { - return mConsumer->detachBuffer(slot); -} - -status_t BufferQueue::attachConsumerBuffer(int* slot, - const sp& buffer) { - return mConsumer->attachBuffer(slot, buffer); -} - -status_t BufferQueue::releaseBuffer( - int buf, uint64_t frameNumber, EGLDisplay display, - EGLSyncKHR eglFence, const sp& fence) { - return mConsumer->releaseBuffer(buf, frameNumber, fence, display, eglFence); -} - -status_t BufferQueue::consumerConnect(const sp& consumerListener, - bool controlledByApp) { - return mConsumer->connect(consumerListener, controlledByApp); -} - -status_t BufferQueue::consumerDisconnect() { - return mConsumer->disconnect(); -} - -status_t BufferQueue::getReleasedBuffers(uint64_t* slotMask) { - return mConsumer->getReleasedBuffers(slotMask); -} - -status_t BufferQueue::setDefaultBufferSize(uint32_t w, uint32_t h) { - return mConsumer->setDefaultBufferSize(w, h); -} - -status_t BufferQueue::setDefaultMaxBufferCount(int bufferCount) { - return mConsumer->setDefaultMaxBufferCount(bufferCount); -} - -status_t BufferQueue::disableAsyncBuffer() { - return mConsumer->disableAsyncBuffer(); -} - -status_t BufferQueue::setMaxAcquiredBufferCount(int maxAcquiredBuffers) { - return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers); -} - -void BufferQueue::setConsumerName(const String8& name) { - mConsumer->setConsumerName(name); -} - -status_t BufferQueue::setDefaultBufferFormat(uint32_t defaultFormat) { - return mConsumer->setDefaultBufferFormat(defaultFormat); -} - -status_t BufferQueue::setConsumerUsageBits(uint32_t usage) { - return mConsumer->setConsumerUsageBits(usage); -} - -status_t BufferQueue::setTransformHint(uint32_t hint) { - return mConsumer->setTransformHint(hint); -} - -sp BufferQueue::getSidebandStream() const { - return mConsumer->getSidebandStream(); -} - -void BufferQueue::dump(String8& result, const char* prefix) const { - mConsumer->dump(result, prefix); -} - -void BufferQueue::ProxyConsumerListener::onSidebandStreamChanged() { - sp listener(mConsumerListener.promote()); - if (listener != NULL) { - listener->onSidebandStreamChanged(); - } -} - }; // namespace android