1/* 2 * Copyright 2014 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#include "MessageQueue.h" 18#include "MonitoredProducer.h" 19#include "SurfaceFlinger.h" 20 21namespace android { 22 23MonitoredProducer::MonitoredProducer(const sp<IGraphicBufferProducer>& producer, 24 const sp<SurfaceFlinger>& flinger) : 25 mProducer(producer), 26 mFlinger(flinger) {} 27 28MonitoredProducer::~MonitoredProducer() { 29 // Remove ourselves from SurfaceFlinger's list. We do this asynchronously 30 // because we don't know where this destructor is called from. It could be 31 // called with the mStateLock held, leading to a dead-lock (it actually 32 // happens). 33 class MessageCleanUpList : public MessageBase { 34 public: 35 MessageCleanUpList(const sp<SurfaceFlinger>& flinger, 36 const wp<IBinder>& producer) 37 : mFlinger(flinger), mProducer(producer) {} 38 39 virtual ~MessageCleanUpList() {} 40 41 virtual bool handler() { 42 Mutex::Autolock _l(mFlinger->mStateLock); 43 mFlinger->mGraphicBufferProducerList.remove(mProducer); 44 return true; 45 } 46 47 private: 48 sp<SurfaceFlinger> mFlinger; 49 wp<IBinder> mProducer; 50 }; 51 52 mFlinger->postMessageAsync(new MessageCleanUpList(mFlinger, asBinder(this))); 53} 54 55status_t MonitoredProducer::requestBuffer(int slot, sp<GraphicBuffer>* buf) { 56 return mProducer->requestBuffer(slot, buf); 57} 58 59status_t MonitoredProducer::setMaxDequeuedBufferCount( 60 int maxDequeuedBuffers) { 61 return mProducer->setMaxDequeuedBufferCount(maxDequeuedBuffers); 62} 63 64status_t MonitoredProducer::setAsyncMode(bool async) { 65 return mProducer->setAsyncMode(async); 66} 67 68status_t MonitoredProducer::dequeueBuffer(int* slot, sp<Fence>* fence, 69 uint32_t w, uint32_t h, PixelFormat format, uint32_t usage) { 70 return mProducer->dequeueBuffer(slot, fence, w, h, format, usage); 71} 72 73status_t MonitoredProducer::detachBuffer(int slot) { 74 return mProducer->detachBuffer(slot); 75} 76 77status_t MonitoredProducer::detachNextBuffer(sp<GraphicBuffer>* outBuffer, 78 sp<Fence>* outFence) { 79 return mProducer->detachNextBuffer(outBuffer, outFence); 80} 81 82status_t MonitoredProducer::attachBuffer(int* outSlot, 83 const sp<GraphicBuffer>& buffer) { 84 return mProducer->attachBuffer(outSlot, buffer); 85} 86 87status_t MonitoredProducer::queueBuffer(int slot, const QueueBufferInput& input, 88 QueueBufferOutput* output) { 89 return mProducer->queueBuffer(slot, input, output); 90} 91 92status_t MonitoredProducer::cancelBuffer(int slot, const sp<Fence>& fence) { 93 return mProducer->cancelBuffer(slot, fence); 94} 95 96int MonitoredProducer::query(int what, int* value) { 97 return mProducer->query(what, value); 98} 99 100status_t MonitoredProducer::connect(const sp<IProducerListener>& listener, 101 int api, bool producerControlledByApp, QueueBufferOutput* output) { 102 return mProducer->connect(listener, api, producerControlledByApp, output); 103} 104 105status_t MonitoredProducer::disconnect(int api) { 106 return mProducer->disconnect(api); 107} 108 109status_t MonitoredProducer::setSidebandStream(const sp<NativeHandle>& stream) { 110 return mProducer->setSidebandStream(stream); 111} 112 113void MonitoredProducer::allocateBuffers(uint32_t width, uint32_t height, 114 PixelFormat format, uint32_t usage) { 115 mProducer->allocateBuffers(width, height, format, usage); 116} 117 118status_t MonitoredProducer::allowAllocation(bool allow) { 119 return mProducer->allowAllocation(allow); 120} 121 122status_t MonitoredProducer::setGenerationNumber(uint32_t generationNumber) { 123 return mProducer->setGenerationNumber(generationNumber); 124} 125 126String8 MonitoredProducer::getConsumerName() const { 127 return mProducer->getConsumerName(); 128} 129 130uint64_t MonitoredProducer::getNextFrameNumber() const { 131 return mProducer->getNextFrameNumber(); 132} 133 134status_t MonitoredProducer::setSharedBufferMode(bool sharedBufferMode) { 135 return mProducer->setSharedBufferMode(sharedBufferMode); 136} 137 138status_t MonitoredProducer::setAutoRefresh(bool autoRefresh) { 139 return mProducer->setAutoRefresh(autoRefresh); 140} 141 142status_t MonitoredProducer::setDequeueTimeout(nsecs_t timeout) { 143 return mProducer->setDequeueTimeout(timeout); 144} 145 146status_t MonitoredProducer::getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer, 147 sp<Fence>* outFence, float outTransformMatrix[16]) { 148 return mProducer->getLastQueuedBuffer(outBuffer, outFence, 149 outTransformMatrix); 150} 151 152status_t MonitoredProducer::getUniqueId(uint64_t* outId) const { 153 return mProducer->getUniqueId(outId); 154} 155 156IBinder* MonitoredProducer::onAsBinder() { 157 return IInterface::asBinder(mProducer).get(); 158} 159 160// --------------------------------------------------------------------------- 161}; // namespace android 162