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
21 namespace android {
22
MonitoredProducer(const sp<IGraphicBufferProducer> & producer,const sp<SurfaceFlinger> & flinger)23 MonitoredProducer::MonitoredProducer(const sp<IGraphicBufferProducer>& producer,
24 const sp<SurfaceFlinger>& flinger) :
25 mProducer(producer),
26 mFlinger(flinger) {}
27
~MonitoredProducer()28 MonitoredProducer::~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
requestBuffer(int slot,sp<GraphicBuffer> * buf)55 status_t MonitoredProducer::requestBuffer(int slot, sp<GraphicBuffer>* buf) {
56 return mProducer->requestBuffer(slot, buf);
57 }
58
setBufferCount(int bufferCount)59 status_t MonitoredProducer::setBufferCount(int bufferCount) {
60 return mProducer->setBufferCount(bufferCount);
61 }
62
dequeueBuffer(int * slot,sp<Fence> * fence,bool async,uint32_t w,uint32_t h,PixelFormat format,uint32_t usage)63 status_t MonitoredProducer::dequeueBuffer(int* slot, sp<Fence>* fence,
64 bool async, uint32_t w, uint32_t h, PixelFormat format, uint32_t usage) {
65 return mProducer->dequeueBuffer(slot, fence, async, w, h, format, usage);
66 }
67
detachBuffer(int slot)68 status_t MonitoredProducer::detachBuffer(int slot) {
69 return mProducer->detachBuffer(slot);
70 }
71
detachNextBuffer(sp<GraphicBuffer> * outBuffer,sp<Fence> * outFence)72 status_t MonitoredProducer::detachNextBuffer(sp<GraphicBuffer>* outBuffer,
73 sp<Fence>* outFence) {
74 return mProducer->detachNextBuffer(outBuffer, outFence);
75 }
76
attachBuffer(int * outSlot,const sp<GraphicBuffer> & buffer)77 status_t MonitoredProducer::attachBuffer(int* outSlot,
78 const sp<GraphicBuffer>& buffer) {
79 return mProducer->attachBuffer(outSlot, buffer);
80 }
81
queueBuffer(int slot,const QueueBufferInput & input,QueueBufferOutput * output)82 status_t MonitoredProducer::queueBuffer(int slot, const QueueBufferInput& input,
83 QueueBufferOutput* output) {
84 return mProducer->queueBuffer(slot, input, output);
85 }
86
cancelBuffer(int slot,const sp<Fence> & fence)87 void MonitoredProducer::cancelBuffer(int slot, const sp<Fence>& fence) {
88 mProducer->cancelBuffer(slot, fence);
89 }
90
query(int what,int * value)91 int MonitoredProducer::query(int what, int* value) {
92 return mProducer->query(what, value);
93 }
94
connect(const sp<IProducerListener> & listener,int api,bool producerControlledByApp,QueueBufferOutput * output)95 status_t MonitoredProducer::connect(const sp<IProducerListener>& listener,
96 int api, bool producerControlledByApp, QueueBufferOutput* output) {
97 return mProducer->connect(listener, api, producerControlledByApp, output);
98 }
99
disconnect(int api)100 status_t MonitoredProducer::disconnect(int api) {
101 return mProducer->disconnect(api);
102 }
103
setSidebandStream(const sp<NativeHandle> & stream)104 status_t MonitoredProducer::setSidebandStream(const sp<NativeHandle>& stream) {
105 return mProducer->setSidebandStream(stream);
106 }
107
allocateBuffers(bool async,uint32_t width,uint32_t height,PixelFormat format,uint32_t usage)108 void MonitoredProducer::allocateBuffers(bool async, uint32_t width,
109 uint32_t height, PixelFormat format, uint32_t usage) {
110 mProducer->allocateBuffers(async, width, height, format, usage);
111 }
112
allowAllocation(bool allow)113 status_t MonitoredProducer::allowAllocation(bool allow) {
114 return mProducer->allowAllocation(allow);
115 }
116
setGenerationNumber(uint32_t generationNumber)117 status_t MonitoredProducer::setGenerationNumber(uint32_t generationNumber) {
118 return mProducer->setGenerationNumber(generationNumber);
119 }
120
getConsumerName() const121 String8 MonitoredProducer::getConsumerName() const {
122 return mProducer->getConsumerName();
123 }
124
onAsBinder()125 IBinder* MonitoredProducer::onAsBinder() {
126 return IInterface::asBinder(mProducer).get();
127 }
128
129 // ---------------------------------------------------------------------------
130 }; // namespace android
131