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