BufferQueue.cpp revision 9f3053de78630815d60cf48a2cf2348cc5867c45
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#define LOG_TAG "BufferQueue" 18#define ATRACE_TAG ATRACE_TAG_GRAPHICS 19//#define LOG_NDEBUG 0 20 21#include <gui/BufferQueue.h> 22#include <gui/BufferQueueCore.h> 23 24namespace android { 25 26BufferQueue::ProxyConsumerListener::ProxyConsumerListener( 27 const wp<ConsumerListener>& consumerListener): 28 mConsumerListener(consumerListener) {} 29 30BufferQueue::ProxyConsumerListener::~ProxyConsumerListener() {} 31 32void BufferQueue::ProxyConsumerListener::onFrameAvailable() { 33 sp<ConsumerListener> listener(mConsumerListener.promote()); 34 if (listener != NULL) { 35 listener->onFrameAvailable(); 36 } 37} 38 39void BufferQueue::ProxyConsumerListener::onBuffersReleased() { 40 sp<ConsumerListener> listener(mConsumerListener.promote()); 41 if (listener != NULL) { 42 listener->onBuffersReleased(); 43 } 44} 45 46void BufferQueue::createBufferQueue(sp<BnGraphicBufferProducer>* outProducer, 47 sp<BnGraphicBufferConsumer>* outConsumer, 48 const sp<IGraphicBufferAlloc>& allocator) { 49 LOG_ALWAYS_FATAL_IF(outProducer == NULL, 50 "BufferQueue: outProducer must not be NULL"); 51 LOG_ALWAYS_FATAL_IF(outConsumer == NULL, 52 "BufferQueue: outConsumer must not be NULL"); 53 54 sp<BufferQueueCore> core(new BufferQueueCore(allocator)); 55 *outProducer = new BufferQueueProducer(core); 56 *outConsumer = new BufferQueueConsumer(core); 57} 58 59BufferQueue::BufferQueue(const sp<IGraphicBufferAlloc>& allocator) : 60 mProducer(), 61 mConsumer() 62{ 63 sp<BufferQueueCore> core(new BufferQueueCore(allocator)); 64 mProducer = new BufferQueueProducer(core); 65 mConsumer = new BufferQueueConsumer(core); 66} 67 68BufferQueue::~BufferQueue() {} 69 70void BufferQueue::binderDied(const wp<IBinder>& who) { 71 mProducer->binderDied(who); 72} 73 74int BufferQueue::query(int what, int* outValue) { 75 return mProducer->query(what, outValue); 76} 77 78status_t BufferQueue::setBufferCount(int bufferCount) { 79 return mProducer->setBufferCount(bufferCount); 80} 81 82status_t BufferQueue::requestBuffer(int slot, sp<GraphicBuffer>* buf) { 83 return mProducer->requestBuffer(slot, buf); 84} 85 86status_t BufferQueue::dequeueBuffer(int *outBuf, sp<Fence>* outFence, bool async, 87 uint32_t w, uint32_t h, uint32_t format, uint32_t usage) { 88 return mProducer->dequeueBuffer(outBuf, outFence, async, w, h, format, usage); 89} 90 91status_t BufferQueue::detachProducerBuffer(int slot) { 92 return mProducer->detachBuffer(slot); 93} 94 95status_t BufferQueue::attachProducerBuffer(int* slot, 96 const sp<GraphicBuffer>& buffer) { 97 return mProducer->attachBuffer(slot, buffer); 98} 99 100status_t BufferQueue::queueBuffer(int buf, 101 const QueueBufferInput& input, QueueBufferOutput* output) { 102 return mProducer->queueBuffer(buf, input, output); 103} 104 105void BufferQueue::cancelBuffer(int buf, const sp<Fence>& fence) { 106 mProducer->cancelBuffer(buf, fence); 107} 108 109status_t BufferQueue::connect(const sp<IBinder>& token, 110 int api, bool producerControlledByApp, QueueBufferOutput* output) { 111 return mProducer->connect(token, api, producerControlledByApp, output); 112} 113 114status_t BufferQueue::disconnect(int api) { 115 return mProducer->disconnect(api); 116} 117 118status_t BufferQueue::acquireBuffer(BufferItem* buffer, nsecs_t presentWhen) { 119 return mConsumer->acquireBuffer(buffer, presentWhen); 120} 121 122status_t BufferQueue::detachConsumerBuffer(int slot) { 123 return mConsumer->detachBuffer(slot); 124} 125 126status_t BufferQueue::attachConsumerBuffer(int* slot, 127 const sp<GraphicBuffer>& buffer) { 128 return mConsumer->attachBuffer(slot, buffer); 129} 130 131status_t BufferQueue::releaseBuffer( 132 int buf, uint64_t frameNumber, EGLDisplay display, 133 EGLSyncKHR eglFence, const sp<Fence>& fence) { 134 return mConsumer->releaseBuffer(buf, frameNumber, fence, display, eglFence); 135} 136 137status_t BufferQueue::consumerConnect(const sp<IConsumerListener>& consumerListener, 138 bool controlledByApp) { 139 return mConsumer->connect(consumerListener, controlledByApp); 140} 141 142status_t BufferQueue::consumerDisconnect() { 143 return mConsumer->disconnect(); 144} 145 146status_t BufferQueue::getReleasedBuffers(uint32_t* slotMask) { 147 return mConsumer->getReleasedBuffers(slotMask); 148} 149 150status_t BufferQueue::setDefaultBufferSize(uint32_t w, uint32_t h) { 151 return mConsumer->setDefaultBufferSize(w, h); 152} 153 154status_t BufferQueue::setDefaultMaxBufferCount(int bufferCount) { 155 return mConsumer->setDefaultMaxBufferCount(bufferCount); 156} 157 158status_t BufferQueue::disableAsyncBuffer() { 159 return mConsumer->disableAsyncBuffer(); 160} 161 162status_t BufferQueue::setMaxAcquiredBufferCount(int maxAcquiredBuffers) { 163 return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers); 164} 165 166void BufferQueue::setConsumerName(const String8& name) { 167 mConsumer->setConsumerName(name); 168} 169 170status_t BufferQueue::setDefaultBufferFormat(uint32_t defaultFormat) { 171 return mConsumer->setDefaultBufferFormat(defaultFormat); 172} 173 174status_t BufferQueue::setConsumerUsageBits(uint32_t usage) { 175 return mConsumer->setConsumerUsageBits(usage); 176} 177 178status_t BufferQueue::setTransformHint(uint32_t hint) { 179 return mConsumer->setTransformHint(hint); 180} 181 182void BufferQueue::dump(String8& result, const char* prefix) const { 183 mConsumer->dump(result, prefix); 184} 185 186}; // namespace android 187