BufferQueue.cpp revision 399184a4cd728ea1421fb0bc1722274a29e38f4a 
1/*
2 * Copyright (C) 2012 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#define LOG_TAG "BufferQueue"
18#define ATRACE_TAG ATRACE_TAG_GRAPHICS
19//#define LOG_NDEBUG 0
20
21#include <gui/BufferQueue.h>
22#include <gui/BufferQueueCore.h>
23
24namespace android {
25
26BufferQueue::ProxyConsumerListener::ProxyConsumerListener(
27        const wp<ConsumerListener>& consumerListener):
28        mConsumerListener(consumerListener) {}
29
30BufferQueue::ProxyConsumerListener::~ProxyConsumerListener() {}
31
32void BufferQueue::ProxyConsumerListener::onFrameAvailable() {
33    sp<ConsumerListener> listener(mConsumerListener.promote());
34    if (listener != NULL) {
35        listener->onFrameAvailable();
36    }
37}
38
39void BufferQueue::ProxyConsumerListener::onBuffersReleased() {
40    sp<ConsumerListener> listener(mConsumerListener.promote());
41    if (listener != NULL) {
42        listener->onBuffersReleased();
43    }
44}
45
46BufferQueue::BufferQueue(const sp<IGraphicBufferAlloc>& allocator) :
47    mProducer(),
48    mConsumer()
49{
50    sp<BufferQueueCore> core(new BufferQueueCore(allocator));
51    mProducer = new BufferQueueProducer(core);
52    mConsumer = new BufferQueueConsumer(core);
53}
54
55BufferQueue::~BufferQueue() {}
56
57void BufferQueue::binderDied(const wp<IBinder>& who) {
58    mProducer->binderDied(who);
59}
60
61int BufferQueue::query(int what, int* outValue) {
62    return mProducer->query(what, outValue);
63}
64
65status_t BufferQueue::setBufferCount(int bufferCount) {
66    return mProducer->setBufferCount(bufferCount);
67}
68
69status_t BufferQueue::requestBuffer(int slot, sp<GraphicBuffer>* buf) {
70    return mProducer->requestBuffer(slot, buf);
71}
72
73status_t BufferQueue::dequeueBuffer(int *outBuf, sp<Fence>* outFence, bool async,
74        uint32_t w, uint32_t h, uint32_t format, uint32_t usage) {
75    return mProducer->dequeueBuffer(outBuf, outFence, async, w, h, format, usage);
76}
77
78status_t BufferQueue::queueBuffer(int buf,
79        const QueueBufferInput& input, QueueBufferOutput* output) {
80    return mProducer->queueBuffer(buf, input, output);
81}
82
83void BufferQueue::cancelBuffer(int buf, const sp<Fence>& fence) {
84    mProducer->cancelBuffer(buf, fence);
85}
86
87status_t BufferQueue::connect(const sp<IBinder>& token,
88        int api, bool producerControlledByApp, QueueBufferOutput* output) {
89    return mProducer->connect(token, api, producerControlledByApp, output);
90}
91
92status_t BufferQueue::disconnect(int api) {
93    return mProducer->disconnect(api);
94}
95
96status_t BufferQueue::setSidebandStream(const sp<NativeHandle>& stream) {
97    return mProducer->setSidebandStream(stream);
98}
99
100status_t BufferQueue::acquireBuffer(BufferItem* buffer, nsecs_t presentWhen) {
101    return mConsumer->acquireBuffer(buffer, presentWhen);
102}
103
104status_t BufferQueue::releaseBuffer(
105        int buf, uint64_t frameNumber, EGLDisplay display,
106        EGLSyncKHR eglFence, const sp<Fence>& fence) {
107    return mConsumer->releaseBuffer(buf, frameNumber, fence, display, eglFence);
108}
109
110status_t BufferQueue::consumerConnect(const sp<IConsumerListener>& consumerListener,
111        bool controlledByApp) {
112    return mConsumer->connect(consumerListener, controlledByApp);
113}
114
115status_t BufferQueue::consumerDisconnect() {
116    return mConsumer->disconnect();
117}
118
119status_t BufferQueue::getReleasedBuffers(uint32_t* slotMask) {
120    return mConsumer->getReleasedBuffers(slotMask);
121}
122
123status_t BufferQueue::setDefaultBufferSize(uint32_t w, uint32_t h) {
124    return mConsumer->setDefaultBufferSize(w, h);
125}
126
127status_t BufferQueue::setDefaultMaxBufferCount(int bufferCount) {
128    return mConsumer->setDefaultMaxBufferCount(bufferCount);
129}
130
131status_t BufferQueue::disableAsyncBuffer() {
132    return mConsumer->disableAsyncBuffer();
133}
134
135status_t BufferQueue::setMaxAcquiredBufferCount(int maxAcquiredBuffers) {
136    return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers);
137}
138
139void BufferQueue::setConsumerName(const String8& name) {
140    mConsumer->setConsumerName(name);
141}
142
143status_t BufferQueue::setDefaultBufferFormat(uint32_t defaultFormat) {
144    return mConsumer->setDefaultBufferFormat(defaultFormat);
145}
146
147status_t BufferQueue::setConsumerUsageBits(uint32_t usage) {
148    return mConsumer->setConsumerUsageBits(usage);
149}
150
151status_t BufferQueue::setTransformHint(uint32_t hint) {
152    return mConsumer->setTransformHint(hint);
153}
154
155sp<NativeHandle> BufferQueue::getSidebandStream() const {
156    return mConsumer->getSidebandStream();
157}
158
159void BufferQueue::dump(String8& result, const char* prefix) const {
160    mConsumer->dump(result, prefix);
161}
162
163void BufferQueue::ProxyConsumerListener::onSidebandStreamChanged() {
164    sp<ConsumerListener> listener(mConsumerListener.promote());
165    if (listener != NULL) {
166        listener->onSidebandStreamChanged();
167    }
168}
169
170}; // namespace android
171