1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_GUI_BUFFERQUEUE_H 18 #define ANDROID_GUI_BUFFERQUEUE_H 19 20 #include <gui/BufferQueueDefs.h> 21 #include <gui/IGraphicBufferConsumer.h> 22 #include <gui/IGraphicBufferProducer.h> 23 #include <gui/IConsumerListener.h> 24 25 // These are only required to keep other parts of the framework with incomplete 26 // dependencies building successfully 27 #include <gui/IGraphicBufferAlloc.h> 28 29 namespace android { 30 31 class BufferQueue { 32 public: 33 // BufferQueue will keep track of at most this value of buffers. 34 // Attempts at runtime to increase the number of buffers past this will fail. 35 enum { NUM_BUFFER_SLOTS = BufferQueueDefs::NUM_BUFFER_SLOTS }; 36 // Used as a placeholder slot# when the value isn't pointing to an existing buffer. 37 enum { INVALID_BUFFER_SLOT = IGraphicBufferConsumer::BufferItem::INVALID_BUFFER_SLOT }; 38 // Alias to <IGraphicBufferConsumer.h> -- please scope from there in future code! 39 enum { 40 NO_BUFFER_AVAILABLE = IGraphicBufferConsumer::NO_BUFFER_AVAILABLE, 41 PRESENT_LATER = IGraphicBufferConsumer::PRESENT_LATER, 42 }; 43 44 // When in async mode we reserve two slots in order to guarantee that the 45 // producer and consumer can run asynchronously. 46 enum { MAX_MAX_ACQUIRED_BUFFERS = NUM_BUFFER_SLOTS - 2 }; 47 48 // for backward source compatibility 49 typedef ::android::ConsumerListener ConsumerListener; 50 typedef IGraphicBufferConsumer::BufferItem BufferItem; 51 52 // ProxyConsumerListener is a ConsumerListener implementation that keeps a weak 53 // reference to the actual consumer object. It forwards all calls to that 54 // consumer object so long as it exists. 55 // 56 // This class exists to avoid having a circular reference between the 57 // BufferQueue object and the consumer object. The reason this can't be a weak 58 // reference in the BufferQueue class is because we're planning to expose the 59 // consumer side of a BufferQueue as a binder interface, which doesn't support 60 // weak references. 61 class ProxyConsumerListener : public BnConsumerListener { 62 public: 63 ProxyConsumerListener(const wp<ConsumerListener>& consumerListener); 64 virtual ~ProxyConsumerListener(); 65 virtual void onFrameAvailable(); 66 virtual void onBuffersReleased(); 67 virtual void onSidebandStreamChanged(); 68 private: 69 // mConsumerListener is a weak reference to the IConsumerListener. This is 70 // the raison d'etre of ProxyConsumerListener. 71 wp<ConsumerListener> mConsumerListener; 72 }; 73 74 // BufferQueue manages a pool of gralloc memory slots to be used by 75 // producers and consumers. allocator is used to allocate all the 76 // needed gralloc buffers. 77 static void createBufferQueue(sp<IGraphicBufferProducer>* outProducer, 78 sp<IGraphicBufferConsumer>* outConsumer, 79 const sp<IGraphicBufferAlloc>& allocator = NULL); 80 81 private: 82 BufferQueue(); // Create through createBufferQueue 83 }; 84 85 // ---------------------------------------------------------------------------- 86 }; // namespace android 87 88 #endif // ANDROID_GUI_BUFFERQUEUE_H 89