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