BufferQueue.cpp revision f522af7eb6048c2efae77d7b94960bc49c003e0e
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 59void BufferQueue::createBufferQueue(sp<IGraphicBufferProducer>* outProducer, 60 sp<IGraphicBufferConsumer>* outConsumer, 61 const sp<IGraphicBufferAlloc>& allocator) { 62 LOG_ALWAYS_FATAL_IF(outProducer == NULL, 63 "BufferQueue: outProducer must not be NULL"); 64 LOG_ALWAYS_FATAL_IF(outConsumer == NULL, 65 "BufferQueue: outConsumer must not be NULL"); 66 67 sp<BufferQueueCore> core(new BufferQueueCore(allocator)); 68 *outProducer = new BufferQueueProducer(core); 69 *outConsumer = new BufferQueueConsumer(core); 70} 71 72BufferQueue::BufferQueue(const sp<IGraphicBufferAlloc>& allocator) : 73 mProducer(), 74 mConsumer() 75{ 76 sp<BufferQueueCore> core(new BufferQueueCore(allocator)); 77 mProducer = new BufferQueueProducer(core); 78 mConsumer = new BufferQueueConsumer(core); 79} 80 81BufferQueue::~BufferQueue() {} 82 83void BufferQueue::binderDied(const wp<IBinder>& who) { 84 mProducer->binderDied(who); 85} 86 87int BufferQueue::query(int what, int* outValue) { 88 return mProducer->query(what, outValue); 89} 90 91status_t BufferQueue::setBufferCount(int bufferCount) { 92 return mProducer->setBufferCount(bufferCount); 93} 94 95status_t BufferQueue::requestBuffer(int slot, sp<GraphicBuffer>* buf) { 96 return mProducer->requestBuffer(slot, buf); 97} 98 99status_t BufferQueue::dequeueBuffer(int *outBuf, sp<Fence>* outFence, bool async, 100 uint32_t w, uint32_t h, uint32_t format, uint32_t usage) { 101 return mProducer->dequeueBuffer(outBuf, outFence, async, w, h, format, usage); 102} 103 104status_t BufferQueue::detachProducerBuffer(int slot) { 105 return mProducer->detachBuffer(slot); 106} 107 108status_t BufferQueue::attachProducerBuffer(int* slot, 109 const sp<GraphicBuffer>& buffer) { 110 return mProducer->attachBuffer(slot, buffer); 111} 112 113status_t BufferQueue::queueBuffer(int buf, 114 const QueueBufferInput& input, QueueBufferOutput* output) { 115 return mProducer->queueBuffer(buf, input, output); 116} 117 118void BufferQueue::cancelBuffer(int buf, const sp<Fence>& fence) { 119 mProducer->cancelBuffer(buf, fence); 120} 121 122status_t BufferQueue::connect(const sp<IBinder>& token, 123 int api, bool producerControlledByApp, QueueBufferOutput* output) { 124 return mProducer->connect(token, api, producerControlledByApp, output); 125} 126 127status_t BufferQueue::disconnect(int api) { 128 return mProducer->disconnect(api); 129} 130 131status_t BufferQueue::acquireBuffer(BufferItem* buffer, nsecs_t presentWhen) { 132 return mConsumer->acquireBuffer(buffer, presentWhen); 133} 134 135status_t BufferQueue::detachConsumerBuffer(int slot) { 136 return mConsumer->detachBuffer(slot); 137} 138 139status_t BufferQueue::attachConsumerBuffer(int* slot, 140 const sp<GraphicBuffer>& buffer) { 141 return mConsumer->attachBuffer(slot, buffer); 142} 143 144status_t BufferQueue::releaseBuffer( 145 int buf, uint64_t frameNumber, EGLDisplay display, 146 EGLSyncKHR eglFence, const sp<Fence>& fence) { 147 return mConsumer->releaseBuffer(buf, frameNumber, fence, display, eglFence); 148} 149 150status_t BufferQueue::consumerConnect(const sp<IConsumerListener>& consumerListener, 151 bool controlledByApp) { 152 return mConsumer->connect(consumerListener, controlledByApp); 153} 154 155status_t BufferQueue::consumerDisconnect() { 156 return mConsumer->disconnect(); 157} 158 159status_t BufferQueue::getReleasedBuffers(uint32_t* slotMask) { 160 return mConsumer->getReleasedBuffers(slotMask); 161} 162 163status_t BufferQueue::setDefaultBufferSize(uint32_t w, uint32_t h) { 164 return mConsumer->setDefaultBufferSize(w, h); 165} 166 167status_t BufferQueue::setDefaultMaxBufferCount(int bufferCount) { 168 return mConsumer->setDefaultMaxBufferCount(bufferCount); 169} 170 171status_t BufferQueue::disableAsyncBuffer() { 172 return mConsumer->disableAsyncBuffer(); 173} 174 175status_t BufferQueue::setMaxAcquiredBufferCount(int maxAcquiredBuffers) { 176 return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers); 177} 178 179void BufferQueue::setConsumerName(const String8& name) { 180 mConsumer->setConsumerName(name); 181} 182 183status_t BufferQueue::setDefaultBufferFormat(uint32_t defaultFormat) { 184 return mConsumer->setDefaultBufferFormat(defaultFormat); 185} 186 187status_t BufferQueue::setConsumerUsageBits(uint32_t usage) { 188 return mConsumer->setConsumerUsageBits(usage); 189} 190 191status_t BufferQueue::setTransformHint(uint32_t hint) { 192 return mConsumer->setTransformHint(hint); 193} 194 195void BufferQueue::dump(String8& result, const char* prefix) const { 196 mConsumer->dump(result, prefix); 197} 198 199}; // namespace android 200