ConsumerBase.cpp revision 3546a3f08ad84099db4006d651c656d58d2ed566 
1/*
2 * Copyright (C) 2010 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 <inttypes.h>
18
19#define LOG_TAG "ConsumerBase"
20#define ATRACE_TAG ATRACE_TAG_GRAPHICS
21//#define LOG_NDEBUG 0
22
23#define EGL_EGLEXT_PROTOTYPES
24
25#include <EGL/egl.h>
26#include <EGL/eglext.h>
27
28#include <hardware/hardware.h>
29
30#include <gui/BufferItem.h>
31#include <gui/IGraphicBufferAlloc.h>
32#include <gui/ISurfaceComposer.h>
33#include <gui/SurfaceComposerClient.h>
34#include <gui/ConsumerBase.h>
35
36#include <private/gui/ComposerService.h>
37
38#include <utils/Log.h>
39#include <utils/String8.h>
40#include <utils/Trace.h>
41
42// Macros for including the ConsumerBase name in log messages
43#define CB_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
44//#define CB_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
45//#define CB_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)
46//#define CB_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)
47#define CB_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__)
48
49namespace android {
50
51// Get an ID that's unique within this process.
52static int32_t createProcessUniqueId() {
53    static volatile int32_t globalCounter = 0;
54    return android_atomic_inc(&globalCounter);
55}
56
57ConsumerBase::ConsumerBase(const sp<IGraphicBufferConsumer>& bufferQueue, bool controlledByApp) :
58        mAbandoned(false),
59        mConsumer(bufferQueue),
60        mPrevFinalReleaseFence(Fence::NO_FENCE) {
61    // Choose a name using the PID and a process-unique ID.
62    mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());
63
64    // Note that we can't create an sp<...>(this) in a ctor that will not keep a
65    // reference once the ctor ends, as that would cause the refcount of 'this'
66    // dropping to 0 at the end of the ctor.  Since all we need is a wp<...>
67    // that's what we create.
68    wp<ConsumerListener> listener = static_cast<ConsumerListener*>(this);
69    sp<IConsumerListener> proxy = new BufferQueue::ProxyConsumerListener(listener);
70
71    status_t err = mConsumer->consumerConnect(proxy, controlledByApp);
72    if (err != NO_ERROR) {
73        CB_LOGE("ConsumerBase: error connecting to BufferQueue: %s (%d)",
74                strerror(-err), err);
75    } else {
76        mConsumer->setConsumerName(mName);
77    }
78}
79
80ConsumerBase::~ConsumerBase() {
81    CB_LOGV("~ConsumerBase");
82    Mutex::Autolock lock(mMutex);
83
84    // Verify that abandon() has been called before we get here.  This should
85    // be done by ConsumerBase::onLastStrongRef(), but it's possible for a
86    // derived class to override that method and not call
87    // ConsumerBase::onLastStrongRef().
88    LOG_ALWAYS_FATAL_IF(!mAbandoned, "[%s] ~ConsumerBase was called, but the "
89        "consumer is not abandoned!", mName.string());
90}
91
92void ConsumerBase::onLastStrongRef(const void* id __attribute__((unused))) {
93    abandon();
94}
95
96void ConsumerBase::freeBufferLocked(int slotIndex) {
97    CB_LOGV("freeBufferLocked: slotIndex=%d", slotIndex);
98    mSlots[slotIndex].mGraphicBuffer = 0;
99    mSlots[slotIndex].mFence = Fence::NO_FENCE;
100    mSlots[slotIndex].mFrameNumber = 0;
101}
102
103void ConsumerBase::onFrameAvailable(const BufferItem& item) {
104    CB_LOGV("onFrameAvailable");
105
106    sp<FrameAvailableListener> listener;
107    { // scope for the lock
108        Mutex::Autolock lock(mMutex);
109        listener = mFrameAvailableListener.promote();
110    }
111
112    if (listener != NULL) {
113        CB_LOGV("actually calling onFrameAvailable");
114        listener->onFrameAvailable(item);
115    }
116}
117
118void ConsumerBase::onFrameReplaced(const BufferItem &item) {
119    CB_LOGV("onFrameReplaced");
120
121    sp<FrameAvailableListener> listener;
122    {
123        Mutex::Autolock lock(mMutex);
124        listener = mFrameAvailableListener.promote();
125    }
126
127    if (listener != NULL) {
128        CB_LOGV("actually calling onFrameReplaced");
129        listener->onFrameReplaced(item);
130    }
131}
132
133void ConsumerBase::onBuffersReleased() {
134    Mutex::Autolock lock(mMutex);
135
136    CB_LOGV("onBuffersReleased");
137
138    if (mAbandoned) {
139        // Nothing to do if we're already abandoned.
140        return;
141    }
142
143    uint64_t mask = 0;
144    mConsumer->getReleasedBuffers(&mask);
145    for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
146        if (mask & (1ULL << i)) {
147            freeBufferLocked(i);
148        }
149    }
150}
151
152void ConsumerBase::onSidebandStreamChanged() {
153}
154
155void ConsumerBase::abandon() {
156    CB_LOGV("abandon");
157    Mutex::Autolock lock(mMutex);
158
159    if (!mAbandoned) {
160        abandonLocked();
161        mAbandoned = true;
162    }
163}
164
165void ConsumerBase::abandonLocked() {
166    CB_LOGV("abandonLocked");
167    if (mAbandoned) {
168        CB_LOGE("abandonLocked: ConsumerBase is abandoned!");
169        return;
170    }
171    for (int i =0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
172        freeBufferLocked(i);
173    }
174    // disconnect from the BufferQueue
175    mConsumer->consumerDisconnect();
176    mConsumer.clear();
177}
178
179bool ConsumerBase::isAbandoned() {
180    Mutex::Autolock _l(mMutex);
181    return mAbandoned;
182}
183
184void ConsumerBase::setFrameAvailableListener(
185        const wp<FrameAvailableListener>& listener) {
186    CB_LOGV("setFrameAvailableListener");
187    Mutex::Autolock lock(mMutex);
188    mFrameAvailableListener = listener;
189}
190
191status_t ConsumerBase::detachBuffer(int slot) {
192    CB_LOGV("detachBuffer");
193    Mutex::Autolock lock(mMutex);
194
195    if (mAbandoned) {
196        CB_LOGE("detachBuffer: ConsumerBase is abandoned!");
197        return NO_INIT;
198    }
199
200    status_t result = mConsumer->detachBuffer(slot);
201    if (result != NO_ERROR) {
202        CB_LOGE("Failed to detach buffer: %d", result);
203        return result;
204    }
205
206    freeBufferLocked(slot);
207
208    return result;
209}
210
211status_t ConsumerBase::setDefaultBufferSize(uint32_t width, uint32_t height) {
212    Mutex::Autolock _l(mMutex);
213    if (mAbandoned) {
214        CB_LOGE("setDefaultBufferSize: ConsumerBase is abandoned!");
215        return NO_INIT;
216    }
217    return mConsumer->setDefaultBufferSize(width, height);
218}
219
220status_t ConsumerBase::setDefaultBufferFormat(PixelFormat defaultFormat) {
221    Mutex::Autolock _l(mMutex);
222    if (mAbandoned) {
223        CB_LOGE("setDefaultBufferFormat: ConsumerBase is abandoned!");
224        return NO_INIT;
225    }
226    return mConsumer->setDefaultBufferFormat(defaultFormat);
227}
228
229status_t ConsumerBase::setDefaultBufferDataSpace(
230        android_dataspace defaultDataSpace) {
231    Mutex::Autolock _l(mMutex);
232    if (mAbandoned) {
233        CB_LOGE("setDefaultBufferDataSpace: ConsumerBase is abandoned!");
234        return NO_INIT;
235    }
236    return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
237}
238
239status_t ConsumerBase::getOccupancyHistory(bool forceFlush,
240        std::vector<OccupancyTracker::Segment>* outHistory) {
241    Mutex::Autolock _l(mMutex);
242    if (mAbandoned) {
243        CB_LOGE("getOccupancyHistory: ConsumerBase is abandoned!");
244        return NO_INIT;
245    }
246    return mConsumer->getOccupancyHistory(forceFlush, outHistory);
247}
248
249status_t ConsumerBase::discardFreeBuffers() {
250    Mutex::Autolock _l(mMutex);
251    if (mAbandoned) {
252        CB_LOGE("discardFreeBuffers: ConsumerBase is abandoned!");
253        return NO_INIT;
254    }
255    return mConsumer->discardFreeBuffers();
256}
257
258void ConsumerBase::dumpState(String8& result) const {
259    dumpState(result, "");
260}
261
262void ConsumerBase::dumpState(String8& result, const char* prefix) const {
263    Mutex::Autolock _l(mMutex);
264    dumpLocked(result, prefix);
265}
266
267void ConsumerBase::dumpLocked(String8& result, const char* prefix) const {
268    result.appendFormat("%smAbandoned=%d\n", prefix, int(mAbandoned));
269
270    if (!mAbandoned) {
271        mConsumer->dumpState(result, prefix);
272    }
273}
274
275status_t ConsumerBase::acquireBufferLocked(BufferItem *item,
276        nsecs_t presentWhen, uint64_t maxFrameNumber) {
277    if (mAbandoned) {
278        CB_LOGE("acquireBufferLocked: ConsumerBase is abandoned!");
279        return NO_INIT;
280    }
281
282    status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber);
283    if (err != NO_ERROR) {
284        return err;
285    }
286
287    if (item->mGraphicBuffer != NULL) {
288        mSlots[item->mSlot].mGraphicBuffer = item->mGraphicBuffer;
289    }
290
291    mSlots[item->mSlot].mFrameNumber = item->mFrameNumber;
292    mSlots[item->mSlot].mFence = item->mFence;
293
294    CB_LOGV("acquireBufferLocked: -> slot=%d/%" PRIu64,
295            item->mSlot, item->mFrameNumber);
296
297    return OK;
298}
299
300status_t ConsumerBase::addReleaseFence(int slot,
301        const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
302    Mutex::Autolock lock(mMutex);
303    return addReleaseFenceLocked(slot, graphicBuffer, fence);
304}
305
306status_t ConsumerBase::addReleaseFenceLocked(int slot,
307        const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
308    CB_LOGV("addReleaseFenceLocked: slot=%d", slot);
309
310    // If consumer no longer tracks this graphicBuffer, we can safely
311    // drop this fence, as it will never be received by the producer.
312    if (!stillTracking(slot, graphicBuffer)) {
313        return OK;
314    }
315
316    if (!mSlots[slot].mFence.get()) {
317        mSlots[slot].mFence = fence;
318        return OK;
319    }
320
321    auto signaled = mSlots[slot].mFence->hasSignaled();
322
323    if (!signaled) {
324        CB_LOGE("fence has invalid state");
325        return BAD_VALUE;
326    }
327
328    if (*signaled) {
329        mSlots[slot].mFence = fence;
330    } else {
331        char fenceName[32] = {};
332        snprintf(fenceName, 32, "%.28s:%d", mName.string(), slot);
333        sp<Fence> mergedFence = Fence::merge(
334                fenceName, mSlots[slot].mFence, fence);
335        if (!mergedFence.get()) {
336            CB_LOGE("failed to merge release fences");
337            // synchronization is broken, the best we can do is hope fences
338            // signal in order so the new fence will act like a union
339            mSlots[slot].mFence = fence;
340            return BAD_VALUE;
341        }
342        mSlots[slot].mFence = mergedFence;
343    }
344
345    return OK;
346}
347
348status_t ConsumerBase::releaseBufferLocked(
349        int slot, const sp<GraphicBuffer> graphicBuffer,
350        EGLDisplay display, EGLSyncKHR eglFence) {
351    if (mAbandoned) {
352        CB_LOGE("releaseBufferLocked: ConsumerBase is abandoned!");
353        return NO_INIT;
354    }
355    // If consumer no longer tracks this graphicBuffer (we received a new
356    // buffer on the same slot), the buffer producer is definitely no longer
357    // tracking it.
358    if (!stillTracking(slot, graphicBuffer)) {
359        return OK;
360    }
361
362    CB_LOGV("releaseBufferLocked: slot=%d/%" PRIu64,
363            slot, mSlots[slot].mFrameNumber);
364    status_t err = mConsumer->releaseBuffer(slot, mSlots[slot].mFrameNumber,
365            display, eglFence, mSlots[slot].mFence);
366    if (err == IGraphicBufferConsumer::STALE_BUFFER_SLOT) {
367        freeBufferLocked(slot);
368    }
369
370    mPrevFinalReleaseFence = mSlots[slot].mFence;
371    mSlots[slot].mFence = Fence::NO_FENCE;
372
373    return err;
374}
375
376bool ConsumerBase::stillTracking(int slot,
377        const sp<GraphicBuffer> graphicBuffer) {
378    if (slot < 0 || slot >= BufferQueue::NUM_BUFFER_SLOTS) {
379        return false;
380    }
381    return (mSlots[slot].mGraphicBuffer != NULL &&
382            mSlots[slot].mGraphicBuffer->handle == graphicBuffer->handle);
383}
384
385} // namespace android
386