libs/gui/BufferQueue.cpp

   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 #define GL_GLEXT_PROTOTYPES
  22 #define EGL_EGLEXT_PROTOTYPES
  23
  24 #include <EGL/egl.h>
  25 #include <EGL/eglext.h>
  26
  27 #include <gui/BufferQueue.h>
  28 #include <gui/ISurfaceComposer.h>
  29 #include <private/gui/ComposerService.h>
  30
  31 #include <utils/Log.h>
  32 #include <utils/Trace.h>
  33
  34 // Macros for including the BufferQueue name in log messages
  35 #define ST_LOGV(x, ...) ALOGV("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
  36 #define ST_LOGD(x, ...) ALOGD("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
  37 #define ST_LOGI(x, ...) ALOGI("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
  38 #define ST_LOGW(x, ...) ALOGW("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
  39 #define ST_LOGE(x, ...) ALOGE("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
  40
  41 #define ATRACE_BUFFER_INDEX(index)                                            \
  42     if (ATRACE_ENABLED()) {                                                   \
  43         char ___traceBuf[1024];                                               \
  44         snprintf(___traceBuf, 1024, "%s: %d", mConsumerName.string(),         \
  45                 (index));                                                     \
  46         android::ScopedTrace ___bufTracer(ATRACE_TAG, ___traceBuf);           \
  47     }
  48
  49 namespace android {
  50
  51 // Get an ID that's unique within this process.
  52 static int32_t createProcessUniqueId() {
  53     static volatile int32_t globalCounter = 0;
  54     return android_atomic_inc(&globalCounter);
  55 }
  56
  57 static const char* scalingModeName(int scalingMode) {
  58     switch (scalingMode) {
  59         case NATIVE_WINDOW_SCALING_MODE_FREEZE: return "FREEZE";
  60         case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW: return "SCALE_TO_WINDOW";
  61         case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP: return "SCALE_CROP";
  62         default: return "Unknown";
  63     }
  64 }
  65
  66 BufferQueue::BufferQueue(bool allowSynchronousMode,
  67         const sp<IGraphicBufferAlloc>& allocator) :
  68     mDefaultWidth(1),
  69     mDefaultHeight(1),
  70     mMaxAcquiredBufferCount(1),
  71     mDefaultMaxBufferCount(2),
  72     mOverrideMaxBufferCount(0),
  73     mSynchronousMode(false),
  74     mAllowSynchronousMode(allowSynchronousMode),
  75     mConnectedApi(NO_CONNECTED_API),
  76     mAbandoned(false),
  77     mFrameCounter(0),
  78     mBufferHasBeenQueued(false),
  79     mDefaultBufferFormat(PIXEL_FORMAT_RGBA_8888),
  80     mConsumerUsageBits(0),
  81     mTransformHint(0)
  82 {
  83     // Choose a name using the PID and a process-unique ID.
  84     mConsumerName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());
  85
  86     ST_LOGV("BufferQueue");
  87     if (allocator == NULL) {
  88         sp<ISurfaceComposer> composer(ComposerService::getComposerService());
  89         mGraphicBufferAlloc = composer->createGraphicBufferAlloc();
  90         if (mGraphicBufferAlloc == 0) {
  91             ST_LOGE("createGraphicBufferAlloc() failed in BufferQueue()");
  92         }
  93     } else {
  94         mGraphicBufferAlloc = allocator;
  95     }
  96 }
  97
  98 BufferQueue::~BufferQueue() {
  99     ST_LOGV("~BufferQueue");
 100 }
 101
 102 status_t BufferQueue::setDefaultMaxBufferCountLocked(int count) {
 103     if (count < 2 || count > NUM_BUFFER_SLOTS)
 104         return BAD_VALUE;
 105
 106     mDefaultMaxBufferCount = count;
 107     mDequeueCondition.broadcast();
 108
 109     return NO_ERROR;
 110 }
 111
 112 bool BufferQueue::isSynchronousMode() const {
 113     Mutex::Autolock lock(mMutex);
 114     return mSynchronousMode;
 115 }
 116
 117 void BufferQueue::setConsumerName(const String8& name) {
 118     Mutex::Autolock lock(mMutex);
 119     mConsumerName = name;
 120 }
 121
 122 status_t BufferQueue::setDefaultBufferFormat(uint32_t defaultFormat) {
 123     Mutex::Autolock lock(mMutex);
 124     mDefaultBufferFormat = defaultFormat;
 125     return NO_ERROR;
 126 }
 127
 128 status_t BufferQueue::setConsumerUsageBits(uint32_t usage) {
 129     Mutex::Autolock lock(mMutex);
 130     mConsumerUsageBits = usage;
 131     return NO_ERROR;
 132 }
 133
 134 status_t BufferQueue::setTransformHint(uint32_t hint) {
 135     ST_LOGV("setTransformHint: %02x", hint);
 136     Mutex::Autolock lock(mMutex);
 137     mTransformHint = hint;
 138     return NO_ERROR;
 139 }
 140
 141 status_t BufferQueue::setBufferCount(int bufferCount) {
 142     ST_LOGV("setBufferCount: count=%d", bufferCount);
 143
 144     sp<ConsumerListener> listener;
 145     {
 146         Mutex::Autolock lock(mMutex);
 147
 148         if (mAbandoned) {
 149             ST_LOGE("setBufferCount: BufferQueue has been abandoned!");
 150             return NO_INIT;
 151         }
 152         if (bufferCount > NUM_BUFFER_SLOTS) {
 153             ST_LOGE("setBufferCount: bufferCount too large (max %d)",
 154                     NUM_BUFFER_SLOTS);
 155             return BAD_VALUE;
 156         }
 157
 158         // Error out if the user has dequeued buffers
 159         int maxBufferCount = getMaxBufferCountLocked();
 160         for (int i=0 ; i<maxBufferCount; i++) {
 161             if (mSlots[i].mBufferState == BufferSlot::DEQUEUED) {
 162                 ST_LOGE("setBufferCount: client owns some buffers");
 163                 return -EINVAL;
 164             }
 165         }
 166
 167         const int minBufferSlots = getMinMaxBufferCountLocked();
 168         if (bufferCount == 0) {
 169             mOverrideMaxBufferCount = 0;
 170             mDequeueCondition.broadcast();
 171             return NO_ERROR;
 172         }
 173
 174         if (bufferCount < minBufferSlots) {
 175             ST_LOGE("setBufferCount: requested buffer count (%d) is less than "
 176                     "minimum (%d)", bufferCount, minBufferSlots);
 177             return BAD_VALUE;
 178         }
 179
 180         // here we're guaranteed that the client doesn't have dequeued buffers
 181         // and will release all of its buffer references.
 182         //
 183         // XXX: Should this use drainQueueAndFreeBuffersLocked instead?
 184         freeAllBuffersLocked();
 185         mOverrideMaxBufferCount = bufferCount;
 186         mBufferHasBeenQueued = false;
 187         mDequeueCondition.broadcast();
 188         listener = mConsumerListener;
 189     } // scope for lock
 190
 191     if (listener != NULL) {
 192         listener->onBuffersReleased();
 193     }
 194
 195     return NO_ERROR;
 196 }
 197
 198 int BufferQueue::query(int what, int* outValue)
 199 {
 200     ATRACE_CALL();
 201     Mutex::Autolock lock(mMutex);
 202
 203     if (mAbandoned) {
 204         ST_LOGE("query: BufferQueue has been abandoned!");
 205         return NO_INIT;
 206     }
 207
 208     int value;
 209     switch (what) {
 210     case NATIVE_WINDOW_WIDTH:
 211         value = mDefaultWidth;
 212         break;
 213     case NATIVE_WINDOW_HEIGHT:
 214         value = mDefaultHeight;
 215         break;
 216     case NATIVE_WINDOW_FORMAT:
 217         value = mDefaultBufferFormat;
 218         break;
 219     case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
 220         value = getMinUndequeuedBufferCountLocked();
 221         break;
 222     case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND:
 223         value = (mQueue.size() >= 2);
 224         break;
 225     default:
 226         return BAD_VALUE;
 227     }
 228     outValue[0] = value;
 229     return NO_ERROR;
 230 }
 231
 232 status_t BufferQueue::requestBuffer(int slot, sp<GraphicBuffer>* buf) {
 233     ATRACE_CALL();
 234     ST_LOGV("requestBuffer: slot=%d", slot);
 235     Mutex::Autolock lock(mMutex);
 236     if (mAbandoned) {
 237         ST_LOGE("requestBuffer: BufferQueue has been abandoned!");
 238         return NO_INIT;
 239     }
 240     int maxBufferCount = getMaxBufferCountLocked();
 241     if (slot < 0 || maxBufferCount <= slot) {
 242         ST_LOGE("requestBuffer: slot index out of range [0, %d]: %d",
 243                 maxBufferCount, slot);
 244         return BAD_VALUE;
 245     } else if (mSlots[slot].mBufferState != BufferSlot::DEQUEUED) {
 246         // XXX: I vaguely recall there was some reason this can be valid, but
 247         // for the life of me I can't recall under what circumstances that's
 248         // the case.
 249         ST_LOGE("requestBuffer: slot %d is not owned by the client (state=%d)",
 250                 slot, mSlots[slot].mBufferState);
 251         return BAD_VALUE;
 252     }
 253     mSlots[slot].mRequestBufferCalled = true;
 254     *buf = mSlots[slot].mGraphicBuffer;
 255     return NO_ERROR;
 256 }
 257
 258 status_t BufferQueue::dequeueBuffer(int *outBuf, sp<Fence>* outFence,
 259         uint32_t w, uint32_t h, uint32_t format, uint32_t usage) {
 260     ATRACE_CALL();
 261     ST_LOGV("dequeueBuffer: w=%d h=%d fmt=%#x usage=%#x", w, h, format, usage);
 262
 263     if ((w && !h) || (!w && h)) {
 264         ST_LOGE("dequeueBuffer: invalid size: w=%u, h=%u", w, h);
 265         return BAD_VALUE;
 266     }
 267
 268     status_t returnFlags(OK);
 269     EGLDisplay dpy = EGL_NO_DISPLAY;
 270     EGLSyncKHR eglFence = EGL_NO_SYNC_KHR;
 271
 272     { // Scope for the lock
 273         Mutex::Autolock lock(mMutex);
 274
 275         if (format == 0) {
 276             format = mDefaultBufferFormat;
 277         }
 278         // turn on usage bits the consumer requested
 279         usage |= mConsumerUsageBits;
 280
 281         int found = -1;
 282         int dequeuedCount = 0;
 283         bool tryAgain = true;
 284         while (tryAgain) {
 285             if (mAbandoned) {
 286                 ST_LOGE("dequeueBuffer: BufferQueue has been abandoned!");
 287                 return NO_INIT;
 288             }
 289
 290             const int maxBufferCount = getMaxBufferCountLocked();
 291
 292             // Free up any buffers that are in slots beyond the max buffer
 293             // count.
 294             for (int i = maxBufferCount; i < NUM_BUFFER_SLOTS; i++) {
 295                 assert(mSlots[i].mBufferState == BufferSlot::FREE);
 296                 if (mSlots[i].mGraphicBuffer != NULL) {
 297                     freeBufferLocked(i);
 298                     returnFlags |= IGraphicBufferProducer::RELEASE_ALL_BUFFERS;
 299                 }
 300             }
 301
 302             // look for a free buffer to give to the client
 303             found = INVALID_BUFFER_SLOT;
 304             dequeuedCount = 0;
 305             for (int i = 0; i < maxBufferCount; i++) {
 306                 const int state = mSlots[i].mBufferState;
 307                 if (state == BufferSlot::DEQUEUED) {
 308                     dequeuedCount++;
 309                 }
 310
 311                 if (state == BufferSlot::FREE) {
 312                     /* We return the oldest of the free buffers to avoid
 313                      * stalling the producer if possible.  This is because
 314                      * the consumer may still have pending reads of the
 315                      * buffers in flight.
 316                      */
 317                     if ((found < 0) ||
 318                             mSlots[i].mFrameNumber < mSlots[found].mFrameNumber) {
 319                         found = i;
 320                     }
 321                 }
 322             }
 323
 324             // clients are not allowed to dequeue more than one buffer
 325             // if they didn't set a buffer count.
 326             if (!mOverrideMaxBufferCount && dequeuedCount) {
 327                 ST_LOGE("dequeueBuffer: can't dequeue multiple buffers without "
 328                         "setting the buffer count");
 329                 return -EINVAL;
 330             }
 331
 332             // See whether a buffer has been queued since the last
 333             // setBufferCount so we know whether to perform the min undequeued
 334             // buffers check below.
 335             if (mBufferHasBeenQueued) {
 336                 // make sure the client is not trying to dequeue more buffers
 337                 // than allowed.
 338                 const int newUndequeuedCount = maxBufferCount - (dequeuedCount+1);
 339                 const int minUndequeuedCount = getMinUndequeuedBufferCountLocked();
 340                 if (newUndequeuedCount < minUndequeuedCount) {
 341                     ST_LOGE("dequeueBuffer: min undequeued buffer count (%d) "
 342                             "exceeded (dequeued=%d undequeudCount=%d)",
 343                             minUndequeuedCount, dequeuedCount,
 344                             newUndequeuedCount);
 345                     return -EBUSY;
 346                 }
 347             }
 348
 349             // If no buffer is found, wait for a buffer to be released or for
 350             // the max buffer count to change.
 351             tryAgain = found == INVALID_BUFFER_SLOT;
 352             if (tryAgain) {
 353                 mDequeueCondition.wait(mMutex);
 354             }
 355         }
 356
 357
 358         if (found == INVALID_BUFFER_SLOT) {
 359             // This should not happen.
 360             ST_LOGE("dequeueBuffer: no available buffer slots");
 361             return -EBUSY;
 362         }
 363
 364         const int buf = found;
 365         *outBuf = found;
 366
 367         ATRACE_BUFFER_INDEX(buf);
 368
 369         const bool useDefaultSize = !w && !h;
 370         if (useDefaultSize) {
 371             // use the default size
 372             w = mDefaultWidth;
 373             h = mDefaultHeight;
 374         }
 375
 376         mSlots[buf].mBufferState = BufferSlot::DEQUEUED;
 377
 378         const sp<GraphicBuffer>& buffer(mSlots[buf].mGraphicBuffer);
 379         if ((buffer == NULL) ||
 380             (uint32_t(buffer->width)  != w) ||
 381             (uint32_t(buffer->height) != h) ||
 382             (uint32_t(buffer->format) != format) ||
 383             ((uint32_t(buffer->usage) & usage) != usage))
 384         {
 385             mSlots[buf].mAcquireCalled = false;
 386             mSlots[buf].mGraphicBuffer = NULL;
 387             mSlots[buf].mRequestBufferCalled = false;
 388             mSlots[buf].mEglFence = EGL_NO_SYNC_KHR;
 389             mSlots[buf].mFence = Fence::NO_FENCE;
 390             mSlots[buf].mEglDisplay = EGL_NO_DISPLAY;
 391
 392             returnFlags |= IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION;
 393         }
 394
 395         dpy = mSlots[buf].mEglDisplay;
 396         eglFence = mSlots[buf].mEglFence;
 397         *outFence = mSlots[buf].mFence;
 398         mSlots[buf].mEglFence = EGL_NO_SYNC_KHR;
 399         mSlots[buf].mFence = Fence::NO_FENCE;
 400     }  // end lock scope
 401
 402     if (returnFlags & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) {
 403         status_t error;
 404         sp<GraphicBuffer> graphicBuffer(
 405                 mGraphicBufferAlloc->createGraphicBuffer(
 406                         w, h, format, usage, &error));
 407         if (graphicBuffer == 0) {
 408             ST_LOGE("dequeueBuffer: SurfaceComposer::createGraphicBuffer "
 409                     "failed");
 410             return error;
 411         }
 412
 413         { // Scope for the lock
 414             Mutex::Autolock lock(mMutex);
 415
 416             if (mAbandoned) {
 417                 ST_LOGE("dequeueBuffer: BufferQueue has been abandoned!");
 418                 return NO_INIT;
 419             }
 420
 421             mSlots[*outBuf].mGraphicBuffer = graphicBuffer;
 422         }
 423     }
 424
 425     if (eglFence != EGL_NO_SYNC_KHR) {
 426         EGLint result = eglClientWaitSyncKHR(dpy, eglFence, 0, 1000000000);
 427         // If something goes wrong, log the error, but return the buffer without
 428         // synchronizing access to it.  It's too late at this point to abort the
 429         // dequeue operation.
 430         if (result == EGL_FALSE) {
 431             ST_LOGE("dequeueBuffer: error waiting for fence: %#x", eglGetError());
 432         } else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
 433             ST_LOGE("dequeueBuffer: timeout waiting for fence");
 434         }
 435         eglDestroySyncKHR(dpy, eglFence);
 436     }
 437
 438     ST_LOGV("dequeueBuffer: returning slot=%d buf=%p flags=%#x", *outBuf,
 439             mSlots[*outBuf].mGraphicBuffer->handle, returnFlags);
 440
 441     return returnFlags;
 442 }
 443
 444 status_t BufferQueue::setSynchronousMode(bool enabled) {
 445     ATRACE_CALL();
 446     ST_LOGV("setSynchronousMode: enabled=%d", enabled);
 447     Mutex::Autolock lock(mMutex);
 448
 449     if (mAbandoned) {
 450         ST_LOGE("setSynchronousMode: BufferQueue has been abandoned!");
 451         return NO_INIT;
 452     }
 453
 454     status_t err = OK;
 455     if (!mAllowSynchronousMode && enabled)
 456         return err;
 457
 458     if (!enabled) {
 459         // going to asynchronous mode, drain the queue
 460         err = drainQueueLocked();
 461         if (err != NO_ERROR)
 462             return err;
 463     }
 464
 465     if (mSynchronousMode != enabled) {
 466         // - if we're going to asynchronous mode, the queue is guaranteed to be
 467         // empty here
 468         // - if the client set the number of buffers, we're guaranteed that
 469         // we have at least 3 (because we don't allow less)
 470         mSynchronousMode = enabled;
 471         mDequeueCondition.broadcast();
 472     }
 473     return err;
 474 }
 475
 476 status_t BufferQueue::queueBuffer(int buf,
 477         const QueueBufferInput& input, QueueBufferOutput* output) {
 478     ATRACE_CALL();
 479     ATRACE_BUFFER_INDEX(buf);
 480
 481     Rect crop;
 482     uint32_t transform;
 483     int scalingMode;
 484     int64_t timestamp;
 485     sp<Fence> fence;
 486
 487     input.deflate(&timestamp, &crop, &scalingMode, &transform, &fence);
 488
 489     if (fence == NULL) {
 490         ST_LOGE("queueBuffer: fence is NULL");
 491         return BAD_VALUE;
 492     }
 493
 494     ST_LOGV("queueBuffer: slot=%d time=%#llx crop=[%d,%d,%d,%d] tr=%#x "
 495             "scale=%s",
 496             buf, timestamp, crop.left, crop.top, crop.right, crop.bottom,
 497             transform, scalingModeName(scalingMode));
 498
 499     sp<ConsumerListener> listener;
 500
 501     { // scope for the lock
 502         Mutex::Autolock lock(mMutex);
 503         if (mAbandoned) {
 504             ST_LOGE("queueBuffer: BufferQueue has been abandoned!");
 505             return NO_INIT;
 506         }
 507         int maxBufferCount = getMaxBufferCountLocked();
 508         if (buf < 0 || buf >= maxBufferCount) {
 509             ST_LOGE("queueBuffer: slot index out of range [0, %d]: %d",
 510                     maxBufferCount, buf);
 511             return -EINVAL;
 512         } else if (mSlots[buf].mBufferState != BufferSlot::DEQUEUED) {
 513             ST_LOGE("queueBuffer: slot %d is not owned by the client "
 514                     "(state=%d)", buf, mSlots[buf].mBufferState);
 515             return -EINVAL;
 516         } else if (!mSlots[buf].mRequestBufferCalled) {
 517             ST_LOGE("queueBuffer: slot %d was enqueued without requesting a "
 518                     "buffer", buf);
 519             return -EINVAL;
 520         }
 521
 522         const sp<GraphicBuffer>& graphicBuffer(mSlots[buf].mGraphicBuffer);
 523         Rect bufferRect(graphicBuffer->getWidth(), graphicBuffer->getHeight());
 524         Rect croppedCrop;
 525         crop.intersect(bufferRect, &croppedCrop);
 526         if (croppedCrop != crop) {
 527             ST_LOGE("queueBuffer: crop rect is not contained within the "
 528                     "buffer in slot %d", buf);
 529             return -EINVAL;
 530         }
 531
 532         if (mSynchronousMode) {
 533             // In synchronous mode we queue all buffers in a FIFO.
 534             mQueue.push_back(buf);
 535
 536             // Synchronous mode always signals that an additional frame should
 537             // be consumed.
 538             listener = mConsumerListener;
 539         } else {
 540             // In asynchronous mode we only keep the most recent buffer.
 541             if (mQueue.empty()) {
 542                 mQueue.push_back(buf);
 543
 544                 // Asynchronous mode only signals that a frame should be
 545                 // consumed if no previous frame was pending. If a frame were
 546                 // pending then the consumer would have already been notified.
 547                 listener = mConsumerListener;
 548             } else {
 549                 Fifo::iterator front(mQueue.begin());
 550                 // buffer currently queued is freed
 551                 mSlots[*front].mBufferState = BufferSlot::FREE;
 552                 // and we record the new buffer index in the queued list
 553                 *front = buf;
 554             }
 555         }
 556
 557         mSlots[buf].mTimestamp = timestamp;
 558         mSlots[buf].mCrop = crop;
 559         mSlots[buf].mTransform = transform;
 560         mSlots[buf].mFence = fence;
 561
 562         switch (scalingMode) {
 563             case NATIVE_WINDOW_SCALING_MODE_FREEZE:
 564             case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW:
 565             case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP:
 566                 break;
 567             default:
 568                 ST_LOGE("unknown scaling mode: %d (ignoring)", scalingMode);
 569                 scalingMode = mSlots[buf].mScalingMode;
 570                 break;
 571         }
 572
 573         mSlots[buf].mBufferState = BufferSlot::QUEUED;
 574         mSlots[buf].mScalingMode = scalingMode;
 575         mFrameCounter++;
 576         mSlots[buf].mFrameNumber = mFrameCounter;
 577
 578         mBufferHasBeenQueued = true;
 579         mDequeueCondition.broadcast();
 580
 581         output->inflate(mDefaultWidth, mDefaultHeight, mTransformHint,
 582                 mQueue.size());
 583
 584         ATRACE_INT(mConsumerName.string(), mQueue.size());
 585     } // scope for the lock
 586
 587     // call back without lock held
 588     if (listener != 0) {
 589         listener->onFrameAvailable();
 590     }
 591     return NO_ERROR;
 592 }
 593
 594 void BufferQueue::cancelBuffer(int buf, const sp<Fence>& fence) {
 595     ATRACE_CALL();
 596     ST_LOGV("cancelBuffer: slot=%d", buf);
 597     Mutex::Autolock lock(mMutex);
 598
 599     if (mAbandoned) {
 600         ST_LOGW("cancelBuffer: BufferQueue has been abandoned!");
 601         return;
 602     }
 603
 604     int maxBufferCount = getMaxBufferCountLocked();
 605     if (buf < 0 || buf >= maxBufferCount) {
 606         ST_LOGE("cancelBuffer: slot index out of range [0, %d]: %d",
 607                 maxBufferCount, buf);
 608         return;
 609     } else if (mSlots[buf].mBufferState != BufferSlot::DEQUEUED) {
 610         ST_LOGE("cancelBuffer: slot %d is not owned by the client (state=%d)",
 611                 buf, mSlots[buf].mBufferState);
 612         return;
 613     } else if (fence == NULL) {
 614         ST_LOGE("cancelBuffer: fence is NULL");
 615         return;
 616     }
 617     mSlots[buf].mBufferState = BufferSlot::FREE;
 618     mSlots[buf].mFrameNumber = 0;
 619     mSlots[buf].mFence = fence;
 620     mDequeueCondition.broadcast();
 621 }
 622
 623 status_t BufferQueue::connect(int api, QueueBufferOutput* output) {
 624     ATRACE_CALL();
 625     ST_LOGV("connect: api=%d", api);
 626     Mutex::Autolock lock(mMutex);
 627
 628     if (mAbandoned) {
 629         ST_LOGE("connect: BufferQueue has been abandoned!");
 630         return NO_INIT;
 631     }
 632
 633     if (mConsumerListener == NULL) {
 634         ST_LOGE("connect: BufferQueue has no consumer!");
 635         return NO_INIT;
 636     }
 637
 638     int err = NO_ERROR;
 639     switch (api) {
 640         case NATIVE_WINDOW_API_EGL:
 641         case NATIVE_WINDOW_API_CPU:
 642         case NATIVE_WINDOW_API_MEDIA:
 643         case NATIVE_WINDOW_API_CAMERA:
 644             if (mConnectedApi != NO_CONNECTED_API) {
 645                 ST_LOGE("connect: already connected (cur=%d, req=%d)",
 646                         mConnectedApi, api);
 647                 err = -EINVAL;
 648             } else {
 649                 mConnectedApi = api;
 650                 output->inflate(mDefaultWidth, mDefaultHeight, mTransformHint,
 651                         mQueue.size());
 652             }
 653             break;
 654         default:
 655             err = -EINVAL;
 656             break;
 657     }
 658
 659     mBufferHasBeenQueued = false;
 660
 661     return err;
 662 }
 663
 664 status_t BufferQueue::disconnect(int api) {
 665     ATRACE_CALL();
 666     ST_LOGV("disconnect: api=%d", api);
 667
 668     int err = NO_ERROR;
 669     sp<ConsumerListener> listener;
 670
 671     { // Scope for the lock
 672         Mutex::Autolock lock(mMutex);
 673
 674         if (mAbandoned) {
 675             // it is not really an error to disconnect after the surface
 676             // has been abandoned, it should just be a no-op.
 677             return NO_ERROR;
 678         }
 679
 680         switch (api) {
 681             case NATIVE_WINDOW_API_EGL:
 682             case NATIVE_WINDOW_API_CPU:
 683             case NATIVE_WINDOW_API_MEDIA:
 684             case NATIVE_WINDOW_API_CAMERA:
 685                 if (mConnectedApi == api) {
 686                     drainQueueAndFreeBuffersLocked();
 687                     mConnectedApi = NO_CONNECTED_API;
 688                     mDequeueCondition.broadcast();
 689                     listener = mConsumerListener;
 690                 } else {
 691                     ST_LOGE("disconnect: connected to another api (cur=%d, req=%d)",
 692                             mConnectedApi, api);
 693                     err = -EINVAL;
 694                 }
 695                 break;
 696             default:
 697                 ST_LOGE("disconnect: unknown API %d", api);
 698                 err = -EINVAL;
 699                 break;
 700         }
 701     }
 702
 703     if (listener != NULL) {
 704         listener->onBuffersReleased();
 705     }
 706
 707     return err;
 708 }
 709
 710 void BufferQueue::dump(String8& result) const
 711 {
 712     char buffer[1024];
 713     BufferQueue::dump(result, "", buffer, 1024);
 714 }
 715
 716 void BufferQueue::dump(String8& result, const char* prefix,
 717         char* buffer, size_t SIZE) const
 718 {
 719     Mutex::Autolock _l(mMutex);
 720
 721     String8 fifo;
 722     int fifoSize = 0;
 723     Fifo::const_iterator i(mQueue.begin());
 724     while (i != mQueue.end()) {
 725        snprintf(buffer, SIZE, "%02d ", *i++);
 726        fifoSize++;
 727        fifo.append(buffer);
 728     }
 729
 730     int maxBufferCount = getMaxBufferCountLocked();
 731
 732     snprintf(buffer, SIZE,
 733             "%s-BufferQueue maxBufferCount=%d, mSynchronousMode=%d, default-size=[%dx%d], "
 734             "default-format=%d, transform-hint=%02x, FIFO(%d)={%s}\n",
 735             prefix, maxBufferCount, mSynchronousMode, mDefaultWidth,
 736             mDefaultHeight, mDefaultBufferFormat, mTransformHint,
 737             fifoSize, fifo.string());
 738     result.append(buffer);
 739
 740
 741     struct {
 742         const char * operator()(int state) const {
 743             switch (state) {
 744                 case BufferSlot::DEQUEUED: return "DEQUEUED";
 745                 case BufferSlot::QUEUED: return "QUEUED";
 746                 case BufferSlot::FREE: return "FREE";
 747                 case BufferSlot::ACQUIRED: return "ACQUIRED";
 748                 default: return "Unknown";
 749             }
 750         }
 751     } stateName;
 752
 753     for (int i=0 ; i<maxBufferCount ; i++) {
 754         const BufferSlot& slot(mSlots[i]);
 755         snprintf(buffer, SIZE,
 756                 "%s%s[%02d] "
 757                 "state=%-8s, crop=[%d,%d,%d,%d], "
 758                 "xform=0x%02x, time=%#llx, scale=%s",
 759                 prefix, (slot.mBufferState == BufferSlot::ACQUIRED)?">":" ", i,
 760                 stateName(slot.mBufferState),
 761                 slot.mCrop.left, slot.mCrop.top, slot.mCrop.right,
 762                 slot.mCrop.bottom, slot.mTransform, slot.mTimestamp,
 763                 scalingModeName(slot.mScalingMode)
 764         );
 765         result.append(buffer);
 766
 767         const sp<GraphicBuffer>& buf(slot.mGraphicBuffer);
 768         if (buf != NULL) {
 769             snprintf(buffer, SIZE,
 770                     ", %p [%4ux%4u:%4u,%3X]",
 771                     buf->handle, buf->width, buf->height, buf->stride,
 772                     buf->format);
 773             result.append(buffer);
 774         }
 775         result.append("\n");
 776     }
 777 }
 778
 779 void BufferQueue::freeBufferLocked(int slot) {
 780     ST_LOGV("freeBufferLocked: slot=%d", slot);
 781     mSlots[slot].mGraphicBuffer = 0;
 782     if (mSlots[slot].mBufferState == BufferSlot::ACQUIRED) {
 783         mSlots[slot].mNeedsCleanupOnRelease = true;
 784     }
 785     mSlots[slot].mBufferState = BufferSlot::FREE;
 786     mSlots[slot].mFrameNumber = 0;
 787     mSlots[slot].mAcquireCalled = false;
 788
 789     // destroy fence as BufferQueue now takes ownership
 790     if (mSlots[slot].mEglFence != EGL_NO_SYNC_KHR) {
 791         eglDestroySyncKHR(mSlots[slot].mEglDisplay, mSlots[slot].mEglFence);
 792         mSlots[slot].mEglFence = EGL_NO_SYNC_KHR;
 793     }
 794     mSlots[slot].mFence = Fence::NO_FENCE;
 795 }
 796
 797 void BufferQueue::freeAllBuffersLocked() {
 798     ALOGW_IF(!mQueue.isEmpty(),
 799             "freeAllBuffersLocked called but mQueue is not empty");
 800     mQueue.clear();
 801     mBufferHasBeenQueued = false;
 802     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
 803         freeBufferLocked(i);
 804     }
 805 }
 806
 807 status_t BufferQueue::acquireBuffer(BufferItem *buffer) {
 808     ATRACE_CALL();
 809     Mutex::Autolock _l(mMutex);
 810
 811     // Check that the consumer doesn't currently have the maximum number of
 812     // buffers acquired.  We allow the max buffer count to be exceeded by one
 813     // buffer, so that the consumer can successfully set up the newly acquired
 814     // buffer before releasing the old one.
 815     int numAcquiredBuffers = 0;
 816     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
 817         if (mSlots[i].mBufferState == BufferSlot::ACQUIRED) {
 818             numAcquiredBuffers++;
 819         }
 820     }
 821     if (numAcquiredBuffers >= mMaxAcquiredBufferCount+1) {
 822         ST_LOGE("acquireBuffer: max acquired buffer count reached: %d (max=%d)",
 823                 numAcquiredBuffers, mMaxAcquiredBufferCount);
 824         return INVALID_OPERATION;
 825     }
 826
 827     // check if queue is empty
 828     // In asynchronous mode the list is guaranteed to be one buffer
 829     // deep, while in synchronous mode we use the oldest buffer.
 830     if (!mQueue.empty()) {
 831         Fifo::iterator front(mQueue.begin());
 832         int buf = *front;
 833
 834         ATRACE_BUFFER_INDEX(buf);
 835
 836         if (mSlots[buf].mAcquireCalled) {
 837             buffer->mGraphicBuffer = NULL;
 838         } else {
 839             buffer->mGraphicBuffer = mSlots[buf].mGraphicBuffer;
 840         }
 841         buffer->mCrop = mSlots[buf].mCrop;
 842         buffer->mTransform = mSlots[buf].mTransform;
 843         buffer->mScalingMode = mSlots[buf].mScalingMode;
 844         buffer->mFrameNumber = mSlots[buf].mFrameNumber;
 845         buffer->mTimestamp = mSlots[buf].mTimestamp;
 846         buffer->mBuf = buf;
 847         buffer->mFence = mSlots[buf].mFence;
 848
 849         mSlots[buf].mAcquireCalled = true;
 850         mSlots[buf].mNeedsCleanupOnRelease = false;
 851         mSlots[buf].mBufferState = BufferSlot::ACQUIRED;
 852         mSlots[buf].mFence = Fence::NO_FENCE;
 853
 854         mQueue.erase(front);
 855         mDequeueCondition.broadcast();
 856
 857         ATRACE_INT(mConsumerName.string(), mQueue.size());
 858     } else {
 859         return NO_BUFFER_AVAILABLE;
 860     }
 861
 862     return NO_ERROR;
 863 }
 864
 865 status_t BufferQueue::releaseBuffer(int buf, EGLDisplay display,
 866         EGLSyncKHR eglFence, const sp<Fence>& fence) {
 867     ATRACE_CALL();
 868     ATRACE_BUFFER_INDEX(buf);
 869
 870     Mutex::Autolock _l(mMutex);
 871
 872     if (buf == INVALID_BUFFER_SLOT || fence == NULL) {
 873         return BAD_VALUE;
 874     }
 875
 876     mSlots[buf].mEglDisplay = display;
 877     mSlots[buf].mEglFence = eglFence;
 878     mSlots[buf].mFence = fence;
 879
 880     // The buffer can now only be released if its in the acquired state
 881     if (mSlots[buf].mBufferState == BufferSlot::ACQUIRED) {
 882         mSlots[buf].mBufferState = BufferSlot::FREE;
 883     } else if (mSlots[buf].mNeedsCleanupOnRelease) {
 884         ST_LOGV("releasing a stale buf %d its state was %d", buf, mSlots[buf].mBufferState);
 885         mSlots[buf].mNeedsCleanupOnRelease = false;
 886         return STALE_BUFFER_SLOT;
 887     } else {
 888         ST_LOGE("attempted to release buf %d but its state was %d", buf, mSlots[buf].mBufferState);
 889         return -EINVAL;
 890     }
 891
 892     mDequeueCondition.broadcast();
 893     return NO_ERROR;
 894 }
 895
 896 status_t BufferQueue::consumerConnect(const sp<ConsumerListener>& consumerListener) {
 897     ST_LOGV("consumerConnect");
 898     Mutex::Autolock lock(mMutex);
 899
 900     if (mAbandoned) {
 901         ST_LOGE("consumerConnect: BufferQueue has been abandoned!");
 902         return NO_INIT;
 903     }
 904     if (consumerListener == NULL) {
 905         ST_LOGE("consumerConnect: consumerListener may not be NULL");
 906         return BAD_VALUE;
 907     }
 908
 909     mConsumerListener = consumerListener;
 910
 911     return NO_ERROR;
 912 }
 913
 914 status_t BufferQueue::consumerDisconnect() {
 915     ST_LOGV("consumerDisconnect");
 916     Mutex::Autolock lock(mMutex);
 917
 918     if (mConsumerListener == NULL) {
 919         ST_LOGE("consumerDisconnect: No consumer is connected!");
 920         return -EINVAL;
 921     }
 922
 923     mAbandoned = true;
 924     mConsumerListener = NULL;
 925     mQueue.clear();
 926     freeAllBuffersLocked();
 927     mDequeueCondition.broadcast();
 928     return NO_ERROR;
 929 }
 930
 931 status_t BufferQueue::getReleasedBuffers(uint32_t* slotMask) {
 932     ST_LOGV("getReleasedBuffers");
 933     Mutex::Autolock lock(mMutex);
 934
 935     if (mAbandoned) {
 936         ST_LOGE("getReleasedBuffers: BufferQueue has been abandoned!");
 937         return NO_INIT;
 938     }
 939
 940     uint32_t mask = 0;
 941     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
 942         if (!mSlots[i].mAcquireCalled) {
 943             mask |= 1 << i;
 944         }
 945     }
 946     *slotMask = mask;
 947
 948     ST_LOGV("getReleasedBuffers: returning mask %#x", mask);
 949     return NO_ERROR;
 950 }
 951
 952 status_t BufferQueue::setDefaultBufferSize(uint32_t w, uint32_t h)
 953 {
 954     ST_LOGV("setDefaultBufferSize: w=%d, h=%d", w, h);
 955     if (!w || !h) {
 956         ST_LOGE("setDefaultBufferSize: dimensions cannot be 0 (w=%d, h=%d)",
 957                 w, h);
 958         return BAD_VALUE;
 959     }
 960
 961     Mutex::Autolock lock(mMutex);
 962     mDefaultWidth = w;
 963     mDefaultHeight = h;
 964     return NO_ERROR;
 965 }
 966
 967 status_t BufferQueue::setDefaultMaxBufferCount(int bufferCount) {
 968     ATRACE_CALL();
 969     Mutex::Autolock lock(mMutex);
 970     return setDefaultMaxBufferCountLocked(bufferCount);
 971 }
 972
 973 status_t BufferQueue::setMaxAcquiredBufferCount(int maxAcquiredBuffers) {
 974     ATRACE_CALL();
 975     Mutex::Autolock lock(mMutex);
 976     if (maxAcquiredBuffers < 1 || maxAcquiredBuffers > MAX_MAX_ACQUIRED_BUFFERS) {
 977         ST_LOGE("setMaxAcquiredBufferCount: invalid count specified: %d",
 978                 maxAcquiredBuffers);
 979         return BAD_VALUE;
 980     }
 981     if (mConnectedApi != NO_CONNECTED_API) {
 982         return INVALID_OPERATION;
 983     }
 984     mMaxAcquiredBufferCount = maxAcquiredBuffers;
 985     return NO_ERROR;
 986 }
 987
 988 void BufferQueue::freeAllBuffersExceptHeadLocked() {
 989     int head = -1;
 990     if (!mQueue.empty()) {
 991         Fifo::iterator front(mQueue.begin());
 992         head = *front;
 993     }
 994     mBufferHasBeenQueued = false;
 995     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
 996         if (i != head) {
 997             freeBufferLocked(i);
 998         }
 999     }
1000 }
1001
1002 status_t BufferQueue::drainQueueLocked() {
1003     while (mSynchronousMode && mQueue.size() > 1) {
1004         mDequeueCondition.wait(mMutex);
1005         if (mAbandoned) {
1006             ST_LOGE("drainQueueLocked: BufferQueue has been abandoned!");
1007             return NO_INIT;
1008         }
1009         if (mConnectedApi == NO_CONNECTED_API) {
1010             ST_LOGE("drainQueueLocked: BufferQueue is not connected!");
1011             return NO_INIT;
1012         }
1013     }
1014     return NO_ERROR;
1015 }
1016
1017 status_t BufferQueue::drainQueueAndFreeBuffersLocked() {
1018     status_t err = drainQueueLocked();
1019     if (err == NO_ERROR) {
1020         if (mQueue.empty()) {
1021             freeAllBuffersLocked();
1022         } else {
1023             freeAllBuffersExceptHeadLocked();
1024         }
1025     }
1026     return err;
1027 }
1028
1029 int BufferQueue::getMinMaxBufferCountLocked() const {
1030     return getMinUndequeuedBufferCountLocked() + 1;
1031 }
1032
1033 int BufferQueue::getMinUndequeuedBufferCountLocked() const {
1034     return mSynchronousMode ? mMaxAcquiredBufferCount :
1035             mMaxAcquiredBufferCount + 1;
1036 }
1037
1038 int BufferQueue::getMaxBufferCountLocked() const {
1039     int minMaxBufferCount = getMinMaxBufferCountLocked();
1040
1041     int maxBufferCount = mDefaultMaxBufferCount;
1042     if (maxBufferCount < minMaxBufferCount) {
1043         maxBufferCount = minMaxBufferCount;
1044     }
1045     if (mOverrideMaxBufferCount != 0) {
1046         assert(mOverrideMaxBufferCount >= minMaxBufferCount);
1047         maxBufferCount = mOverrideMaxBufferCount;
1048     }
1049
1050     // Any buffers that are dequeued by the producer or sitting in the queue
1051     // waiting to be consumed need to have their slots preserved.  Such
1052     // buffers will temporarily keep the max buffer count up until the slots
1053     // no longer need to be preserved.
1054     for (int i = maxBufferCount; i < NUM_BUFFER_SLOTS; i++) {
1055         BufferSlot::BufferState state = mSlots[i].mBufferState;
1056         if (state == BufferSlot::QUEUED || state == BufferSlot::DEQUEUED) {
1057             maxBufferCount = i + 1;
1058         }
1059     }
1060
1061     return maxBufferCount;
1062 }
1063
1064 BufferQueue::ProxyConsumerListener::ProxyConsumerListener(
1065         const wp<BufferQueue::ConsumerListener>& consumerListener):
1066         mConsumerListener(consumerListener) {}
1067
1068 BufferQueue::ProxyConsumerListener::~ProxyConsumerListener() {}
1069
1070 void BufferQueue::ProxyConsumerListener::onFrameAvailable() {
1071     sp<BufferQueue::ConsumerListener> listener(mConsumerListener.promote());
1072     if (listener != NULL) {
1073         listener->onFrameAvailable();
1074     }
1075 }
1076
1077 void BufferQueue::ProxyConsumerListener::onBuffersReleased() {
1078     sp<BufferQueue::ConsumerListener> listener(mConsumerListener.promote());
1079     if (listener != NULL) {
1080         listener->onBuffersReleased();
1081     }
1082 }
1083
1084 }; // namespace android