MonitoredProducer.cpp revision 29a3e90879fd96404c971e7187cd0e05927bbce0
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())); 53} 54 55status_t MonitoredProducer::requestBuffer(int slot, sp<GraphicBuffer>* buf) { 56 return mProducer->requestBuffer(slot, buf); 57} 58 59status_t MonitoredProducer::setBufferCount(int bufferCount) { 60 return mProducer->setBufferCount(bufferCount); 61} 62 63status_t MonitoredProducer::dequeueBuffer(int* slot, sp<Fence>* fence, 64 bool async, uint32_t w, uint32_t h, uint32_t format, uint32_t usage) { 65 return mProducer->dequeueBuffer(slot, fence, async, w, h, format, usage); 66} 67 68status_t MonitoredProducer::detachBuffer(int slot) { 69 return mProducer->detachBuffer(slot); 70} 71 72status_t MonitoredProducer::detachNextBuffer(sp<GraphicBuffer>* outBuffer, 73 sp<Fence>* outFence) { 74 return mProducer->detachNextBuffer(outBuffer, outFence); 75} 76 77status_t MonitoredProducer::attachBuffer(int* outSlot, 78 const sp<GraphicBuffer>& buffer) { 79 return mProducer->attachBuffer(outSlot, buffer); 80} 81 82status_t MonitoredProducer::queueBuffer(int slot, const QueueBufferInput& input, 83 QueueBufferOutput* output) { 84 return mProducer->queueBuffer(slot, input, output); 85} 86 87void MonitoredProducer::cancelBuffer(int slot, const sp<Fence>& fence) { 88 mProducer->cancelBuffer(slot, fence); 89} 90 91int MonitoredProducer::query(int what, int* value) { 92 return mProducer->query(what, value); 93} 94 95status_t MonitoredProducer::connect(const sp<IProducerListener>& listener, 96 int api, bool producerControlledByApp, QueueBufferOutput* output) { 97 return mProducer->connect(listener, api, producerControlledByApp, output); 98} 99 100status_t MonitoredProducer::disconnect(int api) { 101 return mProducer->disconnect(api); 102} 103 104status_t MonitoredProducer::setSidebandStream(const sp<NativeHandle>& stream) { 105 return mProducer->setSidebandStream(stream); 106} 107 108void MonitoredProducer::allocateBuffers(bool async, uint32_t width, 109 uint32_t height, uint32_t format, uint32_t usage) { 110 mProducer->allocateBuffers(async, width, height, format, usage); 111} 112 113IBinder* MonitoredProducer::onAsBinder() { 114 return mProducer->asBinder().get(); 115} 116 117// --------------------------------------------------------------------------- 118}; // namespace android 119