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