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 sp<LambdaMessage> cleanUpListMessage = 37 new LambdaMessage([flinger = mFlinger, asBinder = wp<IBinder>(onAsBinder())]() { 38 Mutex::Autolock lock(flinger->mStateLock); 39 flinger->mGraphicBufferProducerList.erase(asBinder); 40 }); 41 42 mFlinger->postMessageAsync(cleanUpListMessage); 43} 44 45status_t MonitoredProducer::requestBuffer(int slot, sp<GraphicBuffer>* buf) { 46 return mProducer->requestBuffer(slot, buf); 47} 48 49status_t MonitoredProducer::setMaxDequeuedBufferCount( 50 int maxDequeuedBuffers) { 51 return mProducer->setMaxDequeuedBufferCount(maxDequeuedBuffers); 52} 53 54status_t MonitoredProducer::setAsyncMode(bool async) { 55 return mProducer->setAsyncMode(async); 56} 57 58status_t MonitoredProducer::dequeueBuffer(int* slot, sp<Fence>* fence, uint32_t w, uint32_t h, 59 PixelFormat format, uint64_t usage, 60 uint64_t* outBufferAge, 61 FrameEventHistoryDelta* outTimestamps) { 62 return mProducer->dequeueBuffer(slot, fence, w, h, format, usage, outBufferAge, outTimestamps); 63} 64 65status_t MonitoredProducer::detachBuffer(int slot) { 66 return mProducer->detachBuffer(slot); 67} 68 69status_t MonitoredProducer::detachNextBuffer(sp<GraphicBuffer>* outBuffer, 70 sp<Fence>* outFence) { 71 return mProducer->detachNextBuffer(outBuffer, outFence); 72} 73 74status_t MonitoredProducer::attachBuffer(int* outSlot, 75 const sp<GraphicBuffer>& buffer) { 76 return mProducer->attachBuffer(outSlot, buffer); 77} 78 79status_t MonitoredProducer::queueBuffer(int slot, const QueueBufferInput& input, 80 QueueBufferOutput* output) { 81 return mProducer->queueBuffer(slot, input, output); 82} 83 84status_t MonitoredProducer::cancelBuffer(int slot, const sp<Fence>& fence) { 85 return mProducer->cancelBuffer(slot, fence); 86} 87 88int MonitoredProducer::query(int what, int* value) { 89 return mProducer->query(what, value); 90} 91 92status_t MonitoredProducer::connect(const sp<IProducerListener>& listener, 93 int api, bool producerControlledByApp, QueueBufferOutput* output) { 94 return mProducer->connect(listener, api, producerControlledByApp, output); 95} 96 97status_t MonitoredProducer::disconnect(int api, DisconnectMode mode) { 98 return mProducer->disconnect(api, mode); 99} 100 101status_t MonitoredProducer::setSidebandStream(const sp<NativeHandle>& stream) { 102 return mProducer->setSidebandStream(stream); 103} 104 105void MonitoredProducer::allocateBuffers(uint32_t width, uint32_t height, 106 PixelFormat format, uint64_t usage) { 107 mProducer->allocateBuffers(width, height, format, usage); 108} 109 110status_t MonitoredProducer::allowAllocation(bool allow) { 111 return mProducer->allowAllocation(allow); 112} 113 114status_t MonitoredProducer::setGenerationNumber(uint32_t generationNumber) { 115 return mProducer->setGenerationNumber(generationNumber); 116} 117 118String8 MonitoredProducer::getConsumerName() const { 119 return mProducer->getConsumerName(); 120} 121 122status_t MonitoredProducer::setSharedBufferMode(bool sharedBufferMode) { 123 return mProducer->setSharedBufferMode(sharedBufferMode); 124} 125 126status_t MonitoredProducer::setAutoRefresh(bool autoRefresh) { 127 return mProducer->setAutoRefresh(autoRefresh); 128} 129 130status_t MonitoredProducer::setDequeueTimeout(nsecs_t timeout) { 131 return mProducer->setDequeueTimeout(timeout); 132} 133 134status_t MonitoredProducer::getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer, 135 sp<Fence>* outFence, float outTransformMatrix[16]) { 136 return mProducer->getLastQueuedBuffer(outBuffer, outFence, 137 outTransformMatrix); 138} 139 140void MonitoredProducer::getFrameTimestamps(FrameEventHistoryDelta* outDelta) { 141 mProducer->getFrameTimestamps(outDelta); 142} 143 144status_t MonitoredProducer::getUniqueId(uint64_t* outId) const { 145 return mProducer->getUniqueId(outId); 146} 147 148status_t MonitoredProducer::getConsumerUsage(uint64_t* outUsage) const { 149 return mProducer->getConsumerUsage(outUsage); 150} 151 152IBinder* MonitoredProducer::onAsBinder() { 153 return this; 154} 155 156sp<Layer> MonitoredProducer::getLayer() const { 157 return mLayer.promote(); 158} 159 160// --------------------------------------------------------------------------- 161}; // namespace android 162