BufferQueueProducer.cpp revision 9e8143ec78a0bf3779f12000b67f21b8fba6e2a7 
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 <inttypes.h>
18
19#define LOG_TAG "BufferQueueProducer"
20#define ATRACE_TAG ATRACE_TAG_GRAPHICS
21//#define LOG_NDEBUG 0
22
23#if DEBUG_ONLY_CODE
24#define VALIDATE_CONSISTENCY() do { mCore->validateConsistencyLocked(); } while (0)
25#else
26#define VALIDATE_CONSISTENCY()
27#endif
28
29#define EGL_EGLEXT_PROTOTYPES
30
31#include <gui/BufferItem.h>
32#include <gui/BufferQueueCore.h>
33#include <gui/BufferQueueProducer.h>
34#include <gui/GLConsumer.h>
35#include <gui/IConsumerListener.h>
36#include <gui/IGraphicBufferAlloc.h>
37#include <gui/IProducerListener.h>
38
39#include <utils/Log.h>
40#include <utils/Trace.h>
41
42namespace android {
43
44BufferQueueProducer::BufferQueueProducer(const sp<BufferQueueCore>& core) :
45    mCore(core),
46    mSlots(core->mSlots),
47    mConsumerName(),
48    mStickyTransform(0),
49    mLastQueueBufferFence(Fence::NO_FENCE),
50    mCallbackMutex(),
51    mNextCallbackTicket(0),
52    mCurrentCallbackTicket(0),
53    mCallbackCondition(),
54    mDequeueTimeout(-1) {}
55
56BufferQueueProducer::~BufferQueueProducer() {}
57
58status_t BufferQueueProducer::requestBuffer(int slot, sp<GraphicBuffer>* buf) {
59    ATRACE_CALL();
60    BQ_LOGV("requestBuffer: slot %d", slot);
61    Mutex::Autolock lock(mCore->mMutex);
62
63    if (mCore->mIsAbandoned) {
64        BQ_LOGE("requestBuffer: BufferQueue has been abandoned");
65        return NO_INIT;
66    }
67
68    if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) {
69        BQ_LOGE("requestBuffer: BufferQueue has no connected producer");
70        return NO_INIT;
71    }
72
73    if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
74        BQ_LOGE("requestBuffer: slot index %d out of range [0, %d)",
75                slot, BufferQueueDefs::NUM_BUFFER_SLOTS);
76        return BAD_VALUE;
77    } else if (!mSlots[slot].mBufferState.isDequeued()) {
78        BQ_LOGE("requestBuffer: slot %d is not owned by the producer "
79                "(state = %s)", slot, mSlots[slot].mBufferState.string());
80        return BAD_VALUE;
81    }
82
83    mSlots[slot].mRequestBufferCalled = true;
84    *buf = mSlots[slot].mGraphicBuffer;
85    return NO_ERROR;
86}
87
88status_t BufferQueueProducer::setMaxDequeuedBufferCount(
89        int maxDequeuedBuffers) {
90    ATRACE_CALL();
91    BQ_LOGV("setMaxDequeuedBufferCount: maxDequeuedBuffers = %d",
92            maxDequeuedBuffers);
93
94    sp<IConsumerListener> listener;
95    { // Autolock scope
96        Mutex::Autolock lock(mCore->mMutex);
97        mCore->waitWhileAllocatingLocked();
98
99        if (mCore->mIsAbandoned) {
100            BQ_LOGE("setMaxDequeuedBufferCount: BufferQueue has been "
101                    "abandoned");
102            return NO_INIT;
103        }
104
105        if (maxDequeuedBuffers == mCore->mMaxDequeuedBufferCount) {
106            return NO_ERROR;
107        }
108
109        // The new maxDequeuedBuffer count should not be violated by the number
110        // of currently dequeued buffers
111        int dequeuedCount = 0;
112        for (int s : mCore->mActiveBuffers) {
113            if (mSlots[s].mBufferState.isDequeued()) {
114                dequeuedCount++;
115            }
116        }
117        if (dequeuedCount > maxDequeuedBuffers) {
118            BQ_LOGE("setMaxDequeuedBufferCount: the requested maxDequeuedBuffer"
119                    "count (%d) exceeds the current dequeued buffer count (%d)",
120                    maxDequeuedBuffers, dequeuedCount);
121            return BAD_VALUE;
122        }
123
124        int bufferCount = mCore->getMinUndequeuedBufferCountLocked();
125        bufferCount += maxDequeuedBuffers;
126
127        if (bufferCount > BufferQueueDefs::NUM_BUFFER_SLOTS) {
128            BQ_LOGE("setMaxDequeuedBufferCount: bufferCount %d too large "
129                    "(max %d)", bufferCount, BufferQueueDefs::NUM_BUFFER_SLOTS);
130            return BAD_VALUE;
131        }
132
133        const int minBufferSlots = mCore->getMinMaxBufferCountLocked();
134        if (bufferCount < minBufferSlots) {
135            BQ_LOGE("setMaxDequeuedBufferCount: requested buffer count %d is "
136                    "less than minimum %d", bufferCount, minBufferSlots);
137            return BAD_VALUE;
138        }
139
140        if (bufferCount > mCore->mMaxBufferCount) {
141            BQ_LOGE("setMaxDequeuedBufferCount: %d dequeued buffers would "
142                    "exceed the maxBufferCount (%d) (maxAcquired %d async %d "
143                    "mDequeuedBufferCannotBlock %d)", maxDequeuedBuffers,
144                    mCore->mMaxBufferCount, mCore->mMaxAcquiredBufferCount,
145                    mCore->mAsyncMode, mCore->mDequeueBufferCannotBlock);
146            return BAD_VALUE;
147        }
148
149        int delta = maxDequeuedBuffers - mCore->mMaxDequeuedBufferCount;
150        if (!mCore->adjustAvailableSlotsLocked(delta)) {
151            return BAD_VALUE;
152        }
153        mCore->mMaxDequeuedBufferCount = maxDequeuedBuffers;
154        VALIDATE_CONSISTENCY();
155        if (delta < 0) {
156            listener = mCore->mConsumerListener;
157        }
158        mCore->mDequeueCondition.broadcast();
159    } // Autolock scope
160
161    // Call back without lock held
162    if (listener != NULL) {
163        listener->onBuffersReleased();
164    }
165
166    return NO_ERROR;
167}
168
169status_t BufferQueueProducer::setAsyncMode(bool async) {
170    ATRACE_CALL();
171    BQ_LOGV("setAsyncMode: async = %d", async);
172
173    sp<IConsumerListener> listener;
174    { // Autolock scope
175        Mutex::Autolock lock(mCore->mMutex);
176        mCore->waitWhileAllocatingLocked();
177
178        if (mCore->mIsAbandoned) {
179            BQ_LOGE("setAsyncMode: BufferQueue has been abandoned");
180            return NO_INIT;
181        }
182
183        if (async == mCore->mAsyncMode) {
184            return NO_ERROR;
185        }
186
187        if ((mCore->mMaxAcquiredBufferCount + mCore->mMaxDequeuedBufferCount +
188                (async || mCore->mDequeueBufferCannotBlock ? 1 : 0)) >
189                mCore->mMaxBufferCount) {
190            BQ_LOGE("setAsyncMode(%d): this call would cause the "
191                    "maxBufferCount (%d) to be exceeded (maxAcquired %d "
192                    "maxDequeued %d mDequeueBufferCannotBlock %d)", async,
193                    mCore->mMaxBufferCount, mCore->mMaxAcquiredBufferCount,
194                    mCore->mMaxDequeuedBufferCount,
195                    mCore->mDequeueBufferCannotBlock);
196            return BAD_VALUE;
197        }
198
199        int delta = mCore->getMaxBufferCountLocked(async,
200                mCore->mDequeueBufferCannotBlock, mCore->mMaxBufferCount)
201                - mCore->getMaxBufferCountLocked();
202
203        if (!mCore->adjustAvailableSlotsLocked(delta)) {
204            BQ_LOGE("setAsyncMode: BufferQueue failed to adjust the number of "
205                    "available slots. Delta = %d", delta);
206            return BAD_VALUE;
207        }
208        mCore->mAsyncMode = async;
209        VALIDATE_CONSISTENCY();
210        mCore->mDequeueCondition.broadcast();
211        if (delta < 0) {
212            listener = mCore->mConsumerListener;
213        }
214    } // Autolock scope
215
216    // Call back without lock held
217    if (listener != NULL) {
218        listener->onBuffersReleased();
219    }
220    return NO_ERROR;
221}
222
223int BufferQueueProducer::getFreeBufferLocked() const {
224    if (mCore->mFreeBuffers.empty()) {
225        return BufferQueueCore::INVALID_BUFFER_SLOT;
226    }
227    int slot = mCore->mFreeBuffers.front();
228    mCore->mFreeBuffers.pop_front();
229    return slot;
230}
231
232int BufferQueueProducer::getFreeSlotLocked() const {
233    if (mCore->mFreeSlots.empty()) {
234        return BufferQueueCore::INVALID_BUFFER_SLOT;
235    }
236    int slot = *(mCore->mFreeSlots.begin());
237    mCore->mFreeSlots.erase(slot);
238    return slot;
239}
240
241status_t BufferQueueProducer::waitForFreeSlotThenRelock(FreeSlotCaller caller,
242        int* found) const {
243    auto callerString = (caller == FreeSlotCaller::Dequeue) ?
244            "dequeueBuffer" : "attachBuffer";
245    bool tryAgain = true;
246    while (tryAgain) {
247        if (mCore->mIsAbandoned) {
248            BQ_LOGE("%s: BufferQueue has been abandoned", callerString);
249            return NO_INIT;
250        }
251
252        int dequeuedCount = 0;
253        int acquiredCount = 0;
254        for (int s : mCore->mActiveBuffers) {
255            if (mSlots[s].mBufferState.isDequeued()) {
256                ++dequeuedCount;
257            }
258            if (mSlots[s].mBufferState.isAcquired()) {
259                ++acquiredCount;
260            }
261        }
262
263        // Producers are not allowed to dequeue more than
264        // mMaxDequeuedBufferCount buffers.
265        // This check is only done if a buffer has already been queued
266        if (mCore->mBufferHasBeenQueued &&
267                dequeuedCount >= mCore->mMaxDequeuedBufferCount) {
268            BQ_LOGE("%s: attempting to exceed the max dequeued buffer count "
269                    "(%d)", callerString, mCore->mMaxDequeuedBufferCount);
270            return INVALID_OPERATION;
271        }
272
273        *found = BufferQueueCore::INVALID_BUFFER_SLOT;
274
275        // If we disconnect and reconnect quickly, we can be in a state where
276        // our slots are empty but we have many buffers in the queue. This can
277        // cause us to run out of memory if we outrun the consumer. Wait here if
278        // it looks like we have too many buffers queued up.
279        const int maxBufferCount = mCore->getMaxBufferCountLocked();
280        bool tooManyBuffers = mCore->mQueue.size()
281                            > static_cast<size_t>(maxBufferCount);
282        if (tooManyBuffers) {
283            BQ_LOGV("%s: queue size is %zu, waiting", callerString,
284                    mCore->mQueue.size());
285        } else {
286            // If in shared buffer mode and a shared buffer exists, always
287            // return it.
288            if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot !=
289                    BufferQueueCore::INVALID_BUFFER_SLOT) {
290                *found = mCore->mSharedBufferSlot;
291            } else {
292                if (caller == FreeSlotCaller::Dequeue) {
293                    // If we're calling this from dequeue, prefer free buffers
294                    int slot = getFreeBufferLocked();
295                    if (slot != BufferQueueCore::INVALID_BUFFER_SLOT) {
296                        *found = slot;
297                    } else if (mCore->mAllowAllocation) {
298                        *found = getFreeSlotLocked();
299                    }
300                } else {
301                    // If we're calling this from attach, prefer free slots
302                    int slot = getFreeSlotLocked();
303                    if (slot != BufferQueueCore::INVALID_BUFFER_SLOT) {
304                        *found = slot;
305                    } else {
306                        *found = getFreeBufferLocked();
307                    }
308                }
309            }
310        }
311
312        // If no buffer is found, or if the queue has too many buffers
313        // outstanding, wait for a buffer to be acquired or released, or for the
314        // max buffer count to change.
315        tryAgain = (*found == BufferQueueCore::INVALID_BUFFER_SLOT) ||
316                   tooManyBuffers;
317        if (tryAgain) {
318            // Return an error if we're in non-blocking mode (producer and
319            // consumer are controlled by the application).
320            // However, the consumer is allowed to briefly acquire an extra
321            // buffer (which could cause us to have to wait here), which is
322            // okay, since it is only used to implement an atomic acquire +
323            // release (e.g., in GLConsumer::updateTexImage())
324            if ((mCore->mDequeueBufferCannotBlock || mCore->mAsyncMode) &&
325                    (acquiredCount <= mCore->mMaxAcquiredBufferCount)) {
326                return WOULD_BLOCK;
327            }
328            if (mDequeueTimeout >= 0) {
329                status_t result = mCore->mDequeueCondition.waitRelative(
330                        mCore->mMutex, mDequeueTimeout);
331                if (result == TIMED_OUT) {
332                    return result;
333                }
334            } else {
335                mCore->mDequeueCondition.wait(mCore->mMutex);
336            }
337        }
338    } // while (tryAgain)
339
340    return NO_ERROR;
341}
342
343status_t BufferQueueProducer::dequeueBuffer(int *outSlot,
344        sp<android::Fence> *outFence, uint32_t width, uint32_t height,
345        PixelFormat format, uint32_t usage) {
346    ATRACE_CALL();
347    { // Autolock scope
348        Mutex::Autolock lock(mCore->mMutex);
349        mConsumerName = mCore->mConsumerName;
350
351        if (mCore->mIsAbandoned) {
352            BQ_LOGE("dequeueBuffer: BufferQueue has been abandoned");
353            return NO_INIT;
354        }
355
356        if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) {
357            BQ_LOGE("dequeueBuffer: BufferQueue has no connected producer");
358            return NO_INIT;
359        }
360    } // Autolock scope
361
362    BQ_LOGV("dequeueBuffer: w=%u h=%u format=%#x, usage=%#x", width, height,
363            format, usage);
364
365    if ((width && !height) || (!width && height)) {
366        BQ_LOGE("dequeueBuffer: invalid size: w=%u h=%u", width, height);
367        return BAD_VALUE;
368    }
369
370    status_t returnFlags = NO_ERROR;
371    EGLDisplay eglDisplay = EGL_NO_DISPLAY;
372    EGLSyncKHR eglFence = EGL_NO_SYNC_KHR;
373    bool attachedByConsumer = false;
374
375    { // Autolock scope
376        Mutex::Autolock lock(mCore->mMutex);
377        mCore->waitWhileAllocatingLocked();
378
379        if (format == 0) {
380            format = mCore->mDefaultBufferFormat;
381        }
382
383        // Enable the usage bits the consumer requested
384        usage |= mCore->mConsumerUsageBits;
385
386        const bool useDefaultSize = !width && !height;
387        if (useDefaultSize) {
388            width = mCore->mDefaultWidth;
389            height = mCore->mDefaultHeight;
390        }
391
392        int found = BufferItem::INVALID_BUFFER_SLOT;
393        while (found == BufferItem::INVALID_BUFFER_SLOT) {
394            status_t status = waitForFreeSlotThenRelock(FreeSlotCaller::Dequeue,
395                    &found);
396            if (status != NO_ERROR) {
397                return status;
398            }
399
400            // This should not happen
401            if (found == BufferQueueCore::INVALID_BUFFER_SLOT) {
402                BQ_LOGE("dequeueBuffer: no available buffer slots");
403                return -EBUSY;
404            }
405
406            const sp<GraphicBuffer>& buffer(mSlots[found].mGraphicBuffer);
407
408            // If we are not allowed to allocate new buffers,
409            // waitForFreeSlotThenRelock must have returned a slot containing a
410            // buffer. If this buffer would require reallocation to meet the
411            // requested attributes, we free it and attempt to get another one.
412            if (!mCore->mAllowAllocation) {
413                if (buffer->needsReallocation(width, height, format, usage)) {
414                    if (mCore->mSharedBufferSlot == found) {
415                        BQ_LOGE("dequeueBuffer: cannot re-allocate a shared"
416                                "buffer");
417                        return BAD_VALUE;
418                    }
419                    mCore->mFreeSlots.insert(found);
420                    mCore->clearBufferSlotLocked(found);
421                    found = BufferItem::INVALID_BUFFER_SLOT;
422                    continue;
423                }
424            }
425        }
426
427        const sp<GraphicBuffer>& buffer(mSlots[found].mGraphicBuffer);
428        if (mCore->mSharedBufferSlot == found &&
429                buffer->needsReallocation(width,  height, format, usage)) {
430            BQ_LOGE("dequeueBuffer: cannot re-allocate a shared"
431                    "buffer");
432
433            return BAD_VALUE;
434        }
435
436        if (mCore->mSharedBufferSlot != found) {
437            mCore->mActiveBuffers.insert(found);
438        }
439        *outSlot = found;
440        ATRACE_BUFFER_INDEX(found);
441
442        attachedByConsumer = mSlots[found].mNeedsReallocation;
443        mSlots[found].mNeedsReallocation = false;
444
445        mSlots[found].mBufferState.dequeue();
446
447        if ((buffer == NULL) ||
448                buffer->needsReallocation(width, height, format, usage))
449        {
450            mSlots[found].mAcquireCalled = false;
451            mSlots[found].mGraphicBuffer = NULL;
452            mSlots[found].mRequestBufferCalled = false;
453            mSlots[found].mEglDisplay = EGL_NO_DISPLAY;
454            mSlots[found].mEglFence = EGL_NO_SYNC_KHR;
455            mSlots[found].mFence = Fence::NO_FENCE;
456            mCore->mBufferAge = 0;
457            mCore->mIsAllocating = true;
458
459            returnFlags |= BUFFER_NEEDS_REALLOCATION;
460        } else {
461            // We add 1 because that will be the frame number when this buffer
462            // is queued
463            mCore->mBufferAge =
464                    mCore->mFrameCounter + 1 - mSlots[found].mFrameNumber;
465        }
466
467        BQ_LOGV("dequeueBuffer: setting buffer age to %" PRIu64,
468                mCore->mBufferAge);
469
470        if (CC_UNLIKELY(mSlots[found].mFence == NULL)) {
471            BQ_LOGE("dequeueBuffer: about to return a NULL fence - "
472                    "slot=%d w=%d h=%d format=%u",
473                    found, buffer->width, buffer->height, buffer->format);
474        }
475
476        eglDisplay = mSlots[found].mEglDisplay;
477        eglFence = mSlots[found].mEglFence;
478        // Don't return a fence in shared buffer mode, except for the first
479        // frame.
480        *outFence = (mCore->mSharedBufferMode &&
481                mCore->mSharedBufferSlot == found) ?
482                Fence::NO_FENCE : mSlots[found].mFence;
483        mSlots[found].mEglFence = EGL_NO_SYNC_KHR;
484        mSlots[found].mFence = Fence::NO_FENCE;
485
486        // If shared buffer mode has just been enabled, cache the slot of the
487        // first buffer that is dequeued and mark it as the shared buffer.
488        if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot ==
489                BufferQueueCore::INVALID_BUFFER_SLOT) {
490            mCore->mSharedBufferSlot = found;
491            mSlots[found].mBufferState.mShared = true;
492        }
493    } // Autolock scope
494
495    if (returnFlags & BUFFER_NEEDS_REALLOCATION) {
496        status_t error;
497        BQ_LOGV("dequeueBuffer: allocating a new buffer for slot %d", *outSlot);
498        sp<GraphicBuffer> graphicBuffer(mCore->mAllocator->createGraphicBuffer(
499                width, height, format, usage, &error));
500        { // Autolock scope
501            Mutex::Autolock lock(mCore->mMutex);
502
503            if (graphicBuffer != NULL && !mCore->mIsAbandoned) {
504                graphicBuffer->setGenerationNumber(mCore->mGenerationNumber);
505                mSlots[*outSlot].mGraphicBuffer = graphicBuffer;
506            }
507
508            mCore->mIsAllocating = false;
509            mCore->mIsAllocatingCondition.broadcast();
510
511            if (graphicBuffer == NULL) {
512                BQ_LOGE("dequeueBuffer: createGraphicBuffer failed");
513                return error;
514            }
515
516            if (mCore->mIsAbandoned) {
517                BQ_LOGE("dequeueBuffer: BufferQueue has been abandoned");
518                return NO_INIT;
519            }
520
521            VALIDATE_CONSISTENCY();
522        } // Autolock scope
523    }
524
525    if (attachedByConsumer) {
526        returnFlags |= BUFFER_NEEDS_REALLOCATION;
527    }
528
529    if (eglFence != EGL_NO_SYNC_KHR) {
530        EGLint result = eglClientWaitSyncKHR(eglDisplay, eglFence, 0,
531                1000000000);
532        // If something goes wrong, log the error, but return the buffer without
533        // synchronizing access to it. It's too late at this point to abort the
534        // dequeue operation.
535        if (result == EGL_FALSE) {
536            BQ_LOGE("dequeueBuffer: error %#x waiting for fence",
537                    eglGetError());
538        } else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
539            BQ_LOGE("dequeueBuffer: timeout waiting for fence");
540        }
541        eglDestroySyncKHR(eglDisplay, eglFence);
542    }
543
544    BQ_LOGV("dequeueBuffer: returning slot=%d/%" PRIu64 " buf=%p flags=%#x",
545            *outSlot,
546            mSlots[*outSlot].mFrameNumber,
547            mSlots[*outSlot].mGraphicBuffer->handle, returnFlags);
548
549    return returnFlags;
550}
551
552status_t BufferQueueProducer::detachBuffer(int slot) {
553    ATRACE_CALL();
554    ATRACE_BUFFER_INDEX(slot);
555    BQ_LOGV("detachBuffer: slot %d", slot);
556    Mutex::Autolock lock(mCore->mMutex);
557
558    if (mCore->mIsAbandoned) {
559        BQ_LOGE("detachBuffer: BufferQueue has been abandoned");
560        return NO_INIT;
561    }
562
563    if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) {
564        BQ_LOGE("detachBuffer: BufferQueue has no connected producer");
565        return NO_INIT;
566    }
567
568    if (mCore->mSharedBufferMode || mCore->mSharedBufferSlot == slot) {
569        BQ_LOGE("detachBuffer: cannot detach a buffer in shared buffer mode");
570        return BAD_VALUE;
571    }
572
573    if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
574        BQ_LOGE("detachBuffer: slot index %d out of range [0, %d)",
575                slot, BufferQueueDefs::NUM_BUFFER_SLOTS);
576        return BAD_VALUE;
577    } else if (!mSlots[slot].mBufferState.isDequeued()) {
578        BQ_LOGE("detachBuffer: slot %d is not owned by the producer "
579                "(state = %s)", slot, mSlots[slot].mBufferState.string());
580        return BAD_VALUE;
581    } else if (!mSlots[slot].mRequestBufferCalled) {
582        BQ_LOGE("detachBuffer: buffer in slot %d has not been requested",
583                slot);
584        return BAD_VALUE;
585    }
586
587    mSlots[slot].mBufferState.detachProducer();
588    mCore->mActiveBuffers.erase(slot);
589    mCore->mFreeSlots.insert(slot);
590    mCore->clearBufferSlotLocked(slot);
591    mCore->mDequeueCondition.broadcast();
592    VALIDATE_CONSISTENCY();
593
594    return NO_ERROR;
595}
596
597status_t BufferQueueProducer::detachNextBuffer(sp<GraphicBuffer>* outBuffer,
598        sp<Fence>* outFence) {
599    ATRACE_CALL();
600
601    if (outBuffer == NULL) {
602        BQ_LOGE("detachNextBuffer: outBuffer must not be NULL");
603        return BAD_VALUE;
604    } else if (outFence == NULL) {
605        BQ_LOGE("detachNextBuffer: outFence must not be NULL");
606        return BAD_VALUE;
607    }
608
609    Mutex::Autolock lock(mCore->mMutex);
610
611    if (mCore->mIsAbandoned) {
612        BQ_LOGE("detachNextBuffer: BufferQueue has been abandoned");
613        return NO_INIT;
614    }
615
616    if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) {
617        BQ_LOGE("detachNextBuffer: BufferQueue has no connected producer");
618        return NO_INIT;
619    }
620
621    if (mCore->mSharedBufferMode) {
622        BQ_LOGE("detachNextBuffer: cannot detach a buffer in shared buffer "
623            "mode");
624        return BAD_VALUE;
625    }
626
627    mCore->waitWhileAllocatingLocked();
628
629    if (mCore->mFreeBuffers.empty()) {
630        return NO_MEMORY;
631    }
632
633    int found = mCore->mFreeBuffers.front();
634    mCore->mFreeBuffers.remove(found);
635    mCore->mFreeSlots.insert(found);
636
637    BQ_LOGV("detachNextBuffer detached slot %d", found);
638
639    *outBuffer = mSlots[found].mGraphicBuffer;
640    *outFence = mSlots[found].mFence;
641    mCore->clearBufferSlotLocked(found);
642    VALIDATE_CONSISTENCY();
643
644    return NO_ERROR;
645}
646
647status_t BufferQueueProducer::attachBuffer(int* outSlot,
648        const sp<android::GraphicBuffer>& buffer) {
649    ATRACE_CALL();
650
651    if (outSlot == NULL) {
652        BQ_LOGE("attachBuffer: outSlot must not be NULL");
653        return BAD_VALUE;
654    } else if (buffer == NULL) {
655        BQ_LOGE("attachBuffer: cannot attach NULL buffer");
656        return BAD_VALUE;
657    }
658
659    Mutex::Autolock lock(mCore->mMutex);
660
661    if (mCore->mIsAbandoned) {
662        BQ_LOGE("attachBuffer: BufferQueue has been abandoned");
663        return NO_INIT;
664    }
665
666    if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) {
667        BQ_LOGE("attachBuffer: BufferQueue has no connected producer");
668        return NO_INIT;
669    }
670
671    if (mCore->mSharedBufferMode) {
672        BQ_LOGE("attachBuffer: cannot attach a buffer in shared buffer mode");
673        return BAD_VALUE;
674    }
675
676    if (buffer->getGenerationNumber() != mCore->mGenerationNumber) {
677        BQ_LOGE("attachBuffer: generation number mismatch [buffer %u] "
678                "[queue %u]", buffer->getGenerationNumber(),
679                mCore->mGenerationNumber);
680        return BAD_VALUE;
681    }
682
683    mCore->waitWhileAllocatingLocked();
684
685    status_t returnFlags = NO_ERROR;
686    int found;
687    status_t status = waitForFreeSlotThenRelock(FreeSlotCaller::Attach, &found);
688    if (status != NO_ERROR) {
689        return status;
690    }
691
692    // This should not happen
693    if (found == BufferQueueCore::INVALID_BUFFER_SLOT) {
694        BQ_LOGE("attachBuffer: no available buffer slots");
695        return -EBUSY;
696    }
697
698    *outSlot = found;
699    ATRACE_BUFFER_INDEX(*outSlot);
700    BQ_LOGV("attachBuffer: returning slot %d flags=%#x",
701            *outSlot, returnFlags);
702
703    mSlots[*outSlot].mGraphicBuffer = buffer;
704    mSlots[*outSlot].mBufferState.attachProducer();
705    mSlots[*outSlot].mEglFence = EGL_NO_SYNC_KHR;
706    mSlots[*outSlot].mFence = Fence::NO_FENCE;
707    mSlots[*outSlot].mRequestBufferCalled = true;
708    mSlots[*outSlot].mAcquireCalled = false;
709    mCore->mActiveBuffers.insert(found);
710    VALIDATE_CONSISTENCY();
711
712    return returnFlags;
713}
714
715status_t BufferQueueProducer::queueBuffer(int slot,
716        const QueueBufferInput &input, QueueBufferOutput *output) {
717    ATRACE_CALL();
718    ATRACE_BUFFER_INDEX(slot);
719
720    int64_t timestamp;
721    bool isAutoTimestamp;
722    android_dataspace dataSpace;
723    Rect crop(Rect::EMPTY_RECT);
724    int scalingMode;
725    uint32_t transform;
726    uint32_t stickyTransform;
727    sp<Fence> fence;
728    input.deflate(&timestamp, &isAutoTimestamp, &dataSpace, &crop, &scalingMode,
729            &transform, &fence, &stickyTransform);
730    Region surfaceDamage = input.getSurfaceDamage();
731
732    if (fence == NULL) {
733        BQ_LOGE("queueBuffer: fence is NULL");
734        return BAD_VALUE;
735    }
736
737    switch (scalingMode) {
738        case NATIVE_WINDOW_SCALING_MODE_FREEZE:
739        case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW:
740        case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP:
741        case NATIVE_WINDOW_SCALING_MODE_NO_SCALE_CROP:
742            break;
743        default:
744            BQ_LOGE("queueBuffer: unknown scaling mode %d", scalingMode);
745            return BAD_VALUE;
746    }
747
748    sp<IConsumerListener> frameAvailableListener;
749    sp<IConsumerListener> frameReplacedListener;
750    int callbackTicket = 0;
751    BufferItem item;
752    { // Autolock scope
753        Mutex::Autolock lock(mCore->mMutex);
754
755        if (mCore->mIsAbandoned) {
756            BQ_LOGE("queueBuffer: BufferQueue has been abandoned");
757            return NO_INIT;
758        }
759
760        if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) {
761            BQ_LOGE("queueBuffer: BufferQueue has no connected producer");
762            return NO_INIT;
763        }
764
765        if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
766            BQ_LOGE("queueBuffer: slot index %d out of range [0, %d)",
767                    slot, BufferQueueDefs::NUM_BUFFER_SLOTS);
768            return BAD_VALUE;
769        } else if (!mSlots[slot].mBufferState.isDequeued()) {
770            BQ_LOGE("queueBuffer: slot %d is not owned by the producer "
771                    "(state = %s)", slot, mSlots[slot].mBufferState.string());
772            return BAD_VALUE;
773        } else if (!mSlots[slot].mRequestBufferCalled) {
774            BQ_LOGE("queueBuffer: slot %d was queued without requesting "
775                    "a buffer", slot);
776            return BAD_VALUE;
777        }
778
779        // If shared buffer mode has just been enabled, cache the slot of the
780        // first buffer that is queued and mark it as the shared buffer.
781        if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot ==
782                BufferQueueCore::INVALID_BUFFER_SLOT) {
783            mCore->mSharedBufferSlot = slot;
784            mSlots[slot].mBufferState.mShared = true;
785        }
786
787        BQ_LOGV("queueBuffer: slot=%d/%" PRIu64 " time=%" PRIu64 " dataSpace=%d"
788                " crop=[%d,%d,%d,%d] transform=%#x scale=%s",
789                slot, mCore->mFrameCounter + 1, timestamp, dataSpace,
790                crop.left, crop.top, crop.right, crop.bottom, transform,
791                BufferItem::scalingModeName(static_cast<uint32_t>(scalingMode)));
792
793        const sp<GraphicBuffer>& graphicBuffer(mSlots[slot].mGraphicBuffer);
794        Rect bufferRect(graphicBuffer->getWidth(), graphicBuffer->getHeight());
795        Rect croppedRect(Rect::EMPTY_RECT);
796        crop.intersect(bufferRect, &croppedRect);
797        if (croppedRect != crop) {
798            BQ_LOGE("queueBuffer: crop rect is not contained within the "
799                    "buffer in slot %d", slot);
800            return BAD_VALUE;
801        }
802
803        // Override UNKNOWN dataspace with consumer default
804        if (dataSpace == HAL_DATASPACE_UNKNOWN) {
805            dataSpace = mCore->mDefaultBufferDataSpace;
806        }
807
808        mSlots[slot].mFence = fence;
809        mSlots[slot].mBufferState.queue();
810
811        ++mCore->mFrameCounter;
812        mSlots[slot].mFrameNumber = mCore->mFrameCounter;
813
814        item.mAcquireCalled = mSlots[slot].mAcquireCalled;
815        item.mGraphicBuffer = mSlots[slot].mGraphicBuffer;
816        item.mCrop = crop;
817        item.mTransform = transform &
818                ~static_cast<uint32_t>(NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY);
819        item.mTransformToDisplayInverse =
820                (transform & NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY) != 0;
821        item.mScalingMode = static_cast<uint32_t>(scalingMode);
822        item.mTimestamp = timestamp;
823        item.mIsAutoTimestamp = isAutoTimestamp;
824        item.mDataSpace = dataSpace;
825        item.mFrameNumber = mCore->mFrameCounter;
826        item.mSlot = slot;
827        item.mFence = fence;
828        item.mIsDroppable = mCore->mAsyncMode ||
829                mCore->mDequeueBufferCannotBlock ||
830                (mCore->mSharedBufferMode && mCore->mSharedBufferSlot == slot);
831        item.mSurfaceDamage = surfaceDamage;
832        item.mQueuedBuffer = true;
833        item.mAutoRefresh = mCore->mSharedBufferMode && mCore->mAutoRefresh;
834
835        mStickyTransform = stickyTransform;
836
837        // Cache the shared buffer data so that the BufferItem can be recreated.
838        if (mCore->mSharedBufferMode) {
839            mCore->mSharedBufferCache.crop = crop;
840            mCore->mSharedBufferCache.transform = transform;
841            mCore->mSharedBufferCache.scalingMode = static_cast<uint32_t>(
842                    scalingMode);
843            mCore->mSharedBufferCache.dataspace = dataSpace;
844        }
845
846        if (mCore->mQueue.empty()) {
847            // When the queue is empty, we can ignore mDequeueBufferCannotBlock
848            // and simply queue this buffer
849            mCore->mQueue.push_back(item);
850            frameAvailableListener = mCore->mConsumerListener;
851        } else {
852            // When the queue is not empty, we need to look at the last buffer
853            // in the queue to see if we need to replace it
854            const BufferItem& last = mCore->mQueue.itemAt(
855                    mCore->mQueue.size() - 1);
856            if (last.mIsDroppable) {
857
858                if (!last.mIsStale) {
859                    mSlots[last.mSlot].mBufferState.freeQueued();
860
861                    // After leaving shared buffer mode, the shared buffer will
862                    // still be around. Mark it as no longer shared if this
863                    // operation causes it to be free.
864                    if (!mCore->mSharedBufferMode &&
865                            mSlots[last.mSlot].mBufferState.isFree()) {
866                        mSlots[last.mSlot].mBufferState.mShared = false;
867                    }
868                    // Don't put the shared buffer on the free list.
869                    if (!mSlots[last.mSlot].mBufferState.isShared()) {
870                        mCore->mActiveBuffers.erase(last.mSlot);
871                        mCore->mFreeBuffers.push_back(last.mSlot);
872                    }
873                }
874
875                // Overwrite the droppable buffer with the incoming one
876                mCore->mQueue.editItemAt(mCore->mQueue.size() - 1) = item;
877                frameReplacedListener = mCore->mConsumerListener;
878            } else {
879                mCore->mQueue.push_back(item);
880                frameAvailableListener = mCore->mConsumerListener;
881            }
882        }
883
884        mCore->mBufferHasBeenQueued = true;
885        mCore->mDequeueCondition.broadcast();
886        mCore->mLastQueuedSlot = slot;
887
888        output->inflate(mCore->mDefaultWidth, mCore->mDefaultHeight,
889                mCore->mTransformHint,
890                static_cast<uint32_t>(mCore->mQueue.size()));
891
892        ATRACE_INT(mCore->mConsumerName.string(), mCore->mQueue.size());
893        mCore->mOccupancyTracker.registerOccupancyChange(mCore->mQueue.size());
894
895        // Take a ticket for the callback functions
896        callbackTicket = mNextCallbackTicket++;
897
898        VALIDATE_CONSISTENCY();
899    } // Autolock scope
900
901    // Don't send the GraphicBuffer through the callback, and don't send
902    // the slot number, since the consumer shouldn't need it
903    item.mGraphicBuffer.clear();
904    item.mSlot = BufferItem::INVALID_BUFFER_SLOT;
905
906    // Call back without the main BufferQueue lock held, but with the callback
907    // lock held so we can ensure that callbacks occur in order
908    {
909        Mutex::Autolock lock(mCallbackMutex);
910        while (callbackTicket != mCurrentCallbackTicket) {
911            mCallbackCondition.wait(mCallbackMutex);
912        }
913
914        if (frameAvailableListener != NULL) {
915            frameAvailableListener->onFrameAvailable(item);
916        } else if (frameReplacedListener != NULL) {
917            frameReplacedListener->onFrameReplaced(item);
918        }
919
920        ++mCurrentCallbackTicket;
921        mCallbackCondition.broadcast();
922    }
923
924    // Wait without lock held
925    if (mCore->mConnectedApi == NATIVE_WINDOW_API_EGL) {
926        // Waiting here allows for two full buffers to be queued but not a
927        // third. In the event that frames take varying time, this makes a
928        // small trade-off in favor of latency rather than throughput.
929        mLastQueueBufferFence->waitForever("Throttling EGL Production");
930    }
931    mLastQueueBufferFence = fence;
932    mLastQueuedCrop = item.mCrop;
933    mLastQueuedTransform = item.mTransform;
934
935    return NO_ERROR;
936}
937
938status_t BufferQueueProducer::cancelBuffer(int slot, const sp<Fence>& fence) {
939    ATRACE_CALL();
940    BQ_LOGV("cancelBuffer: slot %d", slot);
941    Mutex::Autolock lock(mCore->mMutex);
942
943    if (mCore->mIsAbandoned) {
944        BQ_LOGE("cancelBuffer: BufferQueue has been abandoned");
945        return NO_INIT;
946    }
947
948    if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) {
949        BQ_LOGE("cancelBuffer: BufferQueue has no connected producer");
950        return NO_INIT;
951    }
952
953    if (mCore->mSharedBufferMode) {
954        BQ_LOGE("cancelBuffer: cannot cancel a buffer in shared buffer mode");
955        return BAD_VALUE;
956    }
957
958    if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
959        BQ_LOGE("cancelBuffer: slot index %d out of range [0, %d)",
960                slot, BufferQueueDefs::NUM_BUFFER_SLOTS);
961        return BAD_VALUE;
962    } else if (!mSlots[slot].mBufferState.isDequeued()) {
963        BQ_LOGE("cancelBuffer: slot %d is not owned by the producer "
964                "(state = %s)", slot, mSlots[slot].mBufferState.string());
965        return BAD_VALUE;
966    } else if (fence == NULL) {
967        BQ_LOGE("cancelBuffer: fence is NULL");
968        return BAD_VALUE;
969    }
970
971    mSlots[slot].mBufferState.cancel();
972
973    // After leaving shared buffer mode, the shared buffer will still be around.
974    // Mark it as no longer shared if this operation causes it to be free.
975    if (!mCore->mSharedBufferMode && mSlots[slot].mBufferState.isFree()) {
976        mSlots[slot].mBufferState.mShared = false;
977    }
978
979    // Don't put the shared buffer on the free list.
980    if (!mSlots[slot].mBufferState.isShared()) {
981        mCore->mActiveBuffers.erase(slot);
982        mCore->mFreeBuffers.push_back(slot);
983    }
984
985    mSlots[slot].mFence = fence;
986    mCore->mDequeueCondition.broadcast();
987    VALIDATE_CONSISTENCY();
988
989    return NO_ERROR;
990}
991
992int BufferQueueProducer::query(int what, int *outValue) {
993    ATRACE_CALL();
994    Mutex::Autolock lock(mCore->mMutex);
995
996    if (outValue == NULL) {
997        BQ_LOGE("query: outValue was NULL");
998        return BAD_VALUE;
999    }
1000
1001    if (mCore->mIsAbandoned) {
1002        BQ_LOGE("query: BufferQueue has been abandoned");
1003        return NO_INIT;
1004    }
1005
1006    int value;
1007    switch (what) {
1008        case NATIVE_WINDOW_WIDTH:
1009            value = static_cast<int32_t>(mCore->mDefaultWidth);
1010            break;
1011        case NATIVE_WINDOW_HEIGHT:
1012            value = static_cast<int32_t>(mCore->mDefaultHeight);
1013            break;
1014        case NATIVE_WINDOW_FORMAT:
1015            value = static_cast<int32_t>(mCore->mDefaultBufferFormat);
1016            break;
1017        case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
1018            value = mCore->getMinUndequeuedBufferCountLocked();
1019            break;
1020        case NATIVE_WINDOW_STICKY_TRANSFORM:
1021            value = static_cast<int32_t>(mStickyTransform);
1022            break;
1023        case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND:
1024            value = (mCore->mQueue.size() > 1);
1025            break;
1026        case NATIVE_WINDOW_CONSUMER_USAGE_BITS:
1027            value = static_cast<int32_t>(mCore->mConsumerUsageBits);
1028            break;
1029        case NATIVE_WINDOW_DEFAULT_DATASPACE:
1030            value = static_cast<int32_t>(mCore->mDefaultBufferDataSpace);
1031            break;
1032        case NATIVE_WINDOW_BUFFER_AGE:
1033            if (mCore->mBufferAge > INT32_MAX) {
1034                value = 0;
1035            } else {
1036                value = static_cast<int32_t>(mCore->mBufferAge);
1037            }
1038            break;
1039        default:
1040            return BAD_VALUE;
1041    }
1042
1043    BQ_LOGV("query: %d? %d", what, value);
1044    *outValue = value;
1045    return NO_ERROR;
1046}
1047
1048status_t BufferQueueProducer::connect(const sp<IProducerListener>& listener,
1049        int api, bool producerControlledByApp, QueueBufferOutput *output) {
1050    ATRACE_CALL();
1051    Mutex::Autolock lock(mCore->mMutex);
1052    mConsumerName = mCore->mConsumerName;
1053    BQ_LOGV("connect: api=%d producerControlledByApp=%s", api,
1054            producerControlledByApp ? "true" : "false");
1055
1056    if (mCore->mIsAbandoned) {
1057        BQ_LOGE("connect: BufferQueue has been abandoned");
1058        return NO_INIT;
1059    }
1060
1061    if (mCore->mConsumerListener == NULL) {
1062        BQ_LOGE("connect: BufferQueue has no consumer");
1063        return NO_INIT;
1064    }
1065
1066    if (output == NULL) {
1067        BQ_LOGE("connect: output was NULL");
1068        return BAD_VALUE;
1069    }
1070
1071    if (mCore->mConnectedApi != BufferQueueCore::NO_CONNECTED_API) {
1072        BQ_LOGE("connect: already connected (cur=%d req=%d)",
1073                mCore->mConnectedApi, api);
1074        return BAD_VALUE;
1075    }
1076
1077    int delta = mCore->getMaxBufferCountLocked(mCore->mAsyncMode,
1078            mDequeueTimeout < 0 ?
1079            mCore->mConsumerControlledByApp && producerControlledByApp : false,
1080            mCore->mMaxBufferCount) -
1081            mCore->getMaxBufferCountLocked();
1082    if (!mCore->adjustAvailableSlotsLocked(delta)) {
1083        BQ_LOGE("connect: BufferQueue failed to adjust the number of available "
1084                "slots. Delta = %d", delta);
1085        return BAD_VALUE;
1086    }
1087
1088    int status = NO_ERROR;
1089    switch (api) {
1090        case NATIVE_WINDOW_API_EGL:
1091        case NATIVE_WINDOW_API_CPU:
1092        case NATIVE_WINDOW_API_MEDIA:
1093        case NATIVE_WINDOW_API_CAMERA:
1094            mCore->mConnectedApi = api;
1095            output->inflate(mCore->mDefaultWidth, mCore->mDefaultHeight,
1096                    mCore->mTransformHint,
1097                    static_cast<uint32_t>(mCore->mQueue.size()));
1098
1099            // Set up a death notification so that we can disconnect
1100            // automatically if the remote producer dies
1101            if (listener != NULL &&
1102                    IInterface::asBinder(listener)->remoteBinder() != NULL) {
1103                status = IInterface::asBinder(listener)->linkToDeath(
1104                        static_cast<IBinder::DeathRecipient*>(this));
1105                if (status != NO_ERROR) {
1106                    BQ_LOGE("connect: linkToDeath failed: %s (%d)",
1107                            strerror(-status), status);
1108                }
1109            }
1110            mCore->mConnectedProducerListener = listener;
1111            break;
1112        default:
1113            BQ_LOGE("connect: unknown API %d", api);
1114            status = BAD_VALUE;
1115            break;
1116    }
1117
1118    mCore->mBufferHasBeenQueued = false;
1119    mCore->mDequeueBufferCannotBlock = false;
1120    if (mDequeueTimeout < 0) {
1121        mCore->mDequeueBufferCannotBlock =
1122                mCore->mConsumerControlledByApp && producerControlledByApp;
1123    }
1124
1125    mCore->mAllowAllocation = true;
1126    VALIDATE_CONSISTENCY();
1127    return status;
1128}
1129
1130status_t BufferQueueProducer::disconnect(int api) {
1131    ATRACE_CALL();
1132    BQ_LOGV("disconnect: api %d", api);
1133
1134    int status = NO_ERROR;
1135    sp<IConsumerListener> listener;
1136    { // Autolock scope
1137        Mutex::Autolock lock(mCore->mMutex);
1138        mCore->waitWhileAllocatingLocked();
1139
1140        if (mCore->mIsAbandoned) {
1141            // It's not really an error to disconnect after the surface has
1142            // been abandoned; it should just be a no-op.
1143            return NO_ERROR;
1144        }
1145
1146        if (api == BufferQueueCore::CURRENTLY_CONNECTED_API) {
1147            api = mCore->mConnectedApi;
1148            // If we're asked to disconnect the currently connected api but
1149            // nobody is connected, it's not really an error.
1150            if (api == BufferQueueCore::NO_CONNECTED_API) {
1151                return NO_ERROR;
1152            }
1153        }
1154
1155        switch (api) {
1156            case NATIVE_WINDOW_API_EGL:
1157            case NATIVE_WINDOW_API_CPU:
1158            case NATIVE_WINDOW_API_MEDIA:
1159            case NATIVE_WINDOW_API_CAMERA:
1160                if (mCore->mConnectedApi == api) {
1161                    mCore->freeAllBuffersLocked();
1162
1163                    // Remove our death notification callback if we have one
1164                    if (mCore->mConnectedProducerListener != NULL) {
1165                        sp<IBinder> token =
1166                                IInterface::asBinder(mCore->mConnectedProducerListener);
1167                        // This can fail if we're here because of the death
1168                        // notification, but we just ignore it
1169                        token->unlinkToDeath(
1170                                static_cast<IBinder::DeathRecipient*>(this));
1171                    }
1172                    mCore->mSharedBufferSlot =
1173                            BufferQueueCore::INVALID_BUFFER_SLOT;
1174                    mCore->mConnectedProducerListener = NULL;
1175                    mCore->mConnectedApi = BufferQueueCore::NO_CONNECTED_API;
1176                    mCore->mSidebandStream.clear();
1177                    mCore->mDequeueCondition.broadcast();
1178                    listener = mCore->mConsumerListener;
1179                } else if (mCore->mConnectedApi != BufferQueueCore::NO_CONNECTED_API) {
1180                    BQ_LOGE("disconnect: still connected to another API "
1181                            "(cur=%d req=%d)", mCore->mConnectedApi, api);
1182                    status = BAD_VALUE;
1183                }
1184                break;
1185            default:
1186                BQ_LOGE("disconnect: unknown API %d", api);
1187                status = BAD_VALUE;
1188                break;
1189        }
1190    } // Autolock scope
1191
1192    // Call back without lock held
1193    if (listener != NULL) {
1194        listener->onBuffersReleased();
1195    }
1196
1197    return status;
1198}
1199
1200status_t BufferQueueProducer::setSidebandStream(const sp<NativeHandle>& stream) {
1201    sp<IConsumerListener> listener;
1202    { // Autolock scope
1203        Mutex::Autolock _l(mCore->mMutex);
1204        mCore->mSidebandStream = stream;
1205        listener = mCore->mConsumerListener;
1206    } // Autolock scope
1207
1208    if (listener != NULL) {
1209        listener->onSidebandStreamChanged();
1210    }
1211    return NO_ERROR;
1212}
1213
1214void BufferQueueProducer::allocateBuffers(uint32_t width, uint32_t height,
1215        PixelFormat format, uint32_t usage) {
1216    ATRACE_CALL();
1217    while (true) {
1218        size_t newBufferCount = 0;
1219        uint32_t allocWidth = 0;
1220        uint32_t allocHeight = 0;
1221        PixelFormat allocFormat = PIXEL_FORMAT_UNKNOWN;
1222        uint32_t allocUsage = 0;
1223        { // Autolock scope
1224            Mutex::Autolock lock(mCore->mMutex);
1225            mCore->waitWhileAllocatingLocked();
1226
1227            if (!mCore->mAllowAllocation) {
1228                BQ_LOGE("allocateBuffers: allocation is not allowed for this "
1229                        "BufferQueue");
1230                return;
1231            }
1232
1233            newBufferCount = mCore->mFreeSlots.size();
1234            if (newBufferCount == 0) {
1235                return;
1236            }
1237
1238            allocWidth = width > 0 ? width : mCore->mDefaultWidth;
1239            allocHeight = height > 0 ? height : mCore->mDefaultHeight;
1240            allocFormat = format != 0 ? format : mCore->mDefaultBufferFormat;
1241            allocUsage = usage | mCore->mConsumerUsageBits;
1242
1243            mCore->mIsAllocating = true;
1244        } // Autolock scope
1245
1246        Vector<sp<GraphicBuffer>> buffers;
1247        for (size_t i = 0; i <  newBufferCount; ++i) {
1248            status_t result = NO_ERROR;
1249            sp<GraphicBuffer> graphicBuffer(mCore->mAllocator->createGraphicBuffer(
1250                    allocWidth, allocHeight, allocFormat, allocUsage, &result));
1251            if (result != NO_ERROR) {
1252                BQ_LOGE("allocateBuffers: failed to allocate buffer (%u x %u, format"
1253                        " %u, usage %u)", width, height, format, usage);
1254                Mutex::Autolock lock(mCore->mMutex);
1255                mCore->mIsAllocating = false;
1256                mCore->mIsAllocatingCondition.broadcast();
1257                return;
1258            }
1259            buffers.push_back(graphicBuffer);
1260        }
1261
1262        { // Autolock scope
1263            Mutex::Autolock lock(mCore->mMutex);
1264            uint32_t checkWidth = width > 0 ? width : mCore->mDefaultWidth;
1265            uint32_t checkHeight = height > 0 ? height : mCore->mDefaultHeight;
1266            PixelFormat checkFormat = format != 0 ?
1267                    format : mCore->mDefaultBufferFormat;
1268            uint32_t checkUsage = usage | mCore->mConsumerUsageBits;
1269            if (checkWidth != allocWidth || checkHeight != allocHeight ||
1270                checkFormat != allocFormat || checkUsage != allocUsage) {
1271                // Something changed while we released the lock. Retry.
1272                BQ_LOGV("allocateBuffers: size/format/usage changed while allocating. Retrying.");
1273                mCore->mIsAllocating = false;
1274                mCore->mIsAllocatingCondition.broadcast();
1275                continue;
1276            }
1277
1278            for (size_t i = 0; i < newBufferCount; ++i) {
1279                if (mCore->mFreeSlots.empty()) {
1280                    BQ_LOGV("allocateBuffers: a slot was occupied while "
1281                            "allocating. Dropping allocated buffer.");
1282                    continue;
1283                }
1284                auto slot = mCore->mFreeSlots.begin();
1285                mCore->clearBufferSlotLocked(*slot); // Clean up the slot first
1286                mSlots[*slot].mGraphicBuffer = buffers[i];
1287                mSlots[*slot].mFence = Fence::NO_FENCE;
1288
1289                // freeBufferLocked puts this slot on the free slots list. Since
1290                // we then attached a buffer, move the slot to free buffer list.
1291                mCore->mFreeBuffers.push_front(*slot);
1292
1293                BQ_LOGV("allocateBuffers: allocated a new buffer in slot %d",
1294                        *slot);
1295
1296                // Make sure the erase is done after all uses of the slot
1297                // iterator since it will be invalid after this point.
1298                mCore->mFreeSlots.erase(slot);
1299            }
1300
1301            mCore->mIsAllocating = false;
1302            mCore->mIsAllocatingCondition.broadcast();
1303            VALIDATE_CONSISTENCY();
1304        } // Autolock scope
1305    }
1306}
1307
1308status_t BufferQueueProducer::allowAllocation(bool allow) {
1309    ATRACE_CALL();
1310    BQ_LOGV("allowAllocation: %s", allow ? "true" : "false");
1311
1312    Mutex::Autolock lock(mCore->mMutex);
1313    mCore->mAllowAllocation = allow;
1314    return NO_ERROR;
1315}
1316
1317status_t BufferQueueProducer::setGenerationNumber(uint32_t generationNumber) {
1318    ATRACE_CALL();
1319    BQ_LOGV("setGenerationNumber: %u", generationNumber);
1320
1321    Mutex::Autolock lock(mCore->mMutex);
1322    mCore->mGenerationNumber = generationNumber;
1323    return NO_ERROR;
1324}
1325
1326String8 BufferQueueProducer::getConsumerName() const {
1327    ATRACE_CALL();
1328    BQ_LOGV("getConsumerName: %s", mConsumerName.string());
1329    return mConsumerName;
1330}
1331
1332uint64_t BufferQueueProducer::getNextFrameNumber() const {
1333    ATRACE_CALL();
1334
1335    Mutex::Autolock lock(mCore->mMutex);
1336    uint64_t nextFrameNumber = mCore->mFrameCounter + 1;
1337    return nextFrameNumber;
1338}
1339
1340status_t BufferQueueProducer::setSharedBufferMode(bool sharedBufferMode) {
1341    ATRACE_CALL();
1342    BQ_LOGV("setSharedBufferMode: %d", sharedBufferMode);
1343
1344    Mutex::Autolock lock(mCore->mMutex);
1345    if (!sharedBufferMode) {
1346        mCore->mSharedBufferSlot = BufferQueueCore::INVALID_BUFFER_SLOT;
1347    }
1348    mCore->mSharedBufferMode = sharedBufferMode;
1349    return NO_ERROR;
1350}
1351
1352status_t BufferQueueProducer::setAutoRefresh(bool autoRefresh) {
1353    ATRACE_CALL();
1354    BQ_LOGV("setAutoRefresh: %d", autoRefresh);
1355
1356    Mutex::Autolock lock(mCore->mMutex);
1357
1358    mCore->mAutoRefresh = autoRefresh;
1359    return NO_ERROR;
1360}
1361
1362status_t BufferQueueProducer::setDequeueTimeout(nsecs_t timeout) {
1363    ATRACE_CALL();
1364    BQ_LOGV("setDequeueTimeout: %" PRId64, timeout);
1365
1366    Mutex::Autolock lock(mCore->mMutex);
1367    int delta = mCore->getMaxBufferCountLocked(mCore->mAsyncMode, false,
1368            mCore->mMaxBufferCount) - mCore->getMaxBufferCountLocked();
1369    if (!mCore->adjustAvailableSlotsLocked(delta)) {
1370        BQ_LOGE("setDequeueTimeout: BufferQueue failed to adjust the number of "
1371                "available slots. Delta = %d", delta);
1372        return BAD_VALUE;
1373    }
1374
1375    mDequeueTimeout = timeout;
1376    mCore->mDequeueBufferCannotBlock = false;
1377
1378    VALIDATE_CONSISTENCY();
1379    return NO_ERROR;
1380}
1381
1382status_t BufferQueueProducer::getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,
1383        sp<Fence>* outFence, float outTransformMatrix[16]) {
1384    ATRACE_CALL();
1385    BQ_LOGV("getLastQueuedBuffer");
1386
1387    Mutex::Autolock lock(mCore->mMutex);
1388    if (mCore->mLastQueuedSlot == BufferItem::INVALID_BUFFER_SLOT) {
1389        *outBuffer = nullptr;
1390        *outFence = Fence::NO_FENCE;
1391        return NO_ERROR;
1392    }
1393
1394    *outBuffer = mSlots[mCore->mLastQueuedSlot].mGraphicBuffer;
1395    *outFence = mLastQueueBufferFence;
1396
1397    // Currently only SurfaceFlinger internally ever changes
1398    // GLConsumer's filtering mode, so we just use 'true' here as
1399    // this is slightly specialized for the current client of this API,
1400    // which does want filtering.
1401    GLConsumer::computeTransformMatrix(outTransformMatrix,
1402            mSlots[mCore->mLastQueuedSlot].mGraphicBuffer, mLastQueuedCrop,
1403            mLastQueuedTransform, true /* filter */);
1404
1405    return NO_ERROR;
1406}
1407
1408bool BufferQueueProducer::getFrameTimestamps(uint64_t frameNumber,
1409        FrameTimestamps* outTimestamps) const {
1410    ATRACE_CALL();
1411    BQ_LOGV("getFrameTimestamps, %" PRIu64, frameNumber);
1412    sp<IConsumerListener> listener;
1413
1414    {
1415        Mutex::Autolock lock(mCore->mMutex);
1416        listener = mCore->mConsumerListener;
1417    }
1418    if (listener != NULL) {
1419        return listener->getFrameTimestamps(frameNumber, outTimestamps);
1420    }
1421    return false;
1422}
1423
1424void BufferQueueProducer::binderDied(const wp<android::IBinder>& /* who */) {
1425    // If we're here, it means that a producer we were connected to died.
1426    // We're guaranteed that we are still connected to it because we remove
1427    // this callback upon disconnect. It's therefore safe to read mConnectedApi
1428    // without synchronization here.
1429    int api = mCore->mConnectedApi;
1430    disconnect(api);
1431}
1432
1433} // namespace android
1434