Home | History | Annotate | Download | only in gui 
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <inttypes.h>
     18 
     19 #define LOG_TAG "ConsumerBase"
     20 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
     21 //#define LOG_NDEBUG 0
     22 
     23 #define EGL_EGLEXT_PROTOTYPES
     24 
     25 #include <EGL/egl.h>
     26 #include <EGL/eglext.h>
     27 
     28 #include <hardware/hardware.h>
     29 
     30 #include <gui/BufferItem.h>
     31 #include <gui/IGraphicBufferAlloc.h>
     32 #include <gui/ISurfaceComposer.h>
     33 #include <gui/SurfaceComposerClient.h>
     34 #include <gui/ConsumerBase.h>
     35 
     36 #include <private/gui/ComposerService.h>
     37 
     38 #include <utils/Log.h>
     39 #include <utils/String8.h>
     40 #include <utils/Trace.h>
     41 
     42 // Macros for including the ConsumerBase name in log messages
     43 #define CB_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
     44 //#define CB_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
     45 //#define CB_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)
     46 //#define CB_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)
     47 #define CB_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__)
     48 
     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 ConsumerBase::ConsumerBase(const sp<IGraphicBufferConsumer>& bufferQueue, bool controlledByApp) :
     58         mAbandoned(false),
     59         mConsumer(bufferQueue) {
     60     // Choose a name using the PID and a process-unique ID.
     61     mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());
     62 
     63     // Note that we can't create an sp<...>(this) in a ctor that will not keep a
     64     // reference once the ctor ends, as that would cause the refcount of 'this'
     65     // dropping to 0 at the end of the ctor.  Since all we need is a wp<...>
     66     // that's what we create.
     67     wp<ConsumerListener> listener = static_cast<ConsumerListener*>(this);
     68     sp<IConsumerListener> proxy = new BufferQueue::ProxyConsumerListener(listener);
     69 
     70     status_t err = mConsumer->consumerConnect(proxy, controlledByApp);
     71     if (err != NO_ERROR) {
     72         CB_LOGE("ConsumerBase: error connecting to BufferQueue: %s (%d)",
     73                 strerror(-err), err);
     74     } else {
     75         mConsumer->setConsumerName(mName);
     76     }
     77 }
     78 
     79 ConsumerBase::~ConsumerBase() {
     80     CB_LOGV("~ConsumerBase");
     81     Mutex::Autolock lock(mMutex);
     82 
     83     // Verify that abandon() has been called before we get here.  This should
     84     // be done by ConsumerBase::onLastStrongRef(), but it's possible for a
     85     // derived class to override that method and not call
     86     // ConsumerBase::onLastStrongRef().
     87     LOG_ALWAYS_FATAL_IF(!mAbandoned, "[%s] ~ConsumerBase was called, but the "
     88         "consumer is not abandoned!", mName.string());
     89 }
     90 
     91 void ConsumerBase::onLastStrongRef(const void* id __attribute__((unused))) {
     92     abandon();
     93 }
     94 
     95 void ConsumerBase::freeBufferLocked(int slotIndex) {
     96     CB_LOGV("freeBufferLocked: slotIndex=%d", slotIndex);
     97     mSlots[slotIndex].mGraphicBuffer = 0;
     98     mSlots[slotIndex].mFence = Fence::NO_FENCE;
     99     mSlots[slotIndex].mFrameNumber = 0;
    100 }
    101 
    102 void ConsumerBase::onFrameAvailable(const BufferItem& item) {
    103     CB_LOGV("onFrameAvailable");
    104 
    105     sp<FrameAvailableListener> listener;
    106     { // scope for the lock
    107         Mutex::Autolock lock(mMutex);
    108         listener = mFrameAvailableListener.promote();
    109     }
    110 
    111     if (listener != NULL) {
    112         CB_LOGV("actually calling onFrameAvailable");
    113         listener->onFrameAvailable(item);
    114     }
    115 }
    116 
    117 void ConsumerBase::onFrameReplaced(const BufferItem &item) {
    118     CB_LOGV("onFrameReplaced");
    119 
    120     sp<FrameAvailableListener> listener;
    121     {
    122         Mutex::Autolock lock(mMutex);
    123         listener = mFrameAvailableListener.promote();
    124     }
    125 
    126     if (listener != NULL) {
    127         CB_LOGV("actually calling onFrameReplaced");
    128         listener->onFrameReplaced(item);
    129     }
    130 }
    131 
    132 void ConsumerBase::onBuffersReleased() {
    133     Mutex::Autolock lock(mMutex);
    134 
    135     CB_LOGV("onBuffersReleased");
    136 
    137     if (mAbandoned) {
    138         // Nothing to do if we're already abandoned.
    139         return;
    140     }
    141 
    142     uint64_t mask = 0;
    143     mConsumer->getReleasedBuffers(&mask);
    144     for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
    145         if (mask & (1ULL << i)) {
    146             freeBufferLocked(i);
    147         }
    148     }
    149 }
    150 
    151 void ConsumerBase::onSidebandStreamChanged() {
    152 }
    153 
    154 void ConsumerBase::abandon() {
    155     CB_LOGV("abandon");
    156     Mutex::Autolock lock(mMutex);
    157 
    158     if (!mAbandoned) {
    159         abandonLocked();
    160         mAbandoned = true;
    161     }
    162 }
    163 
    164 void ConsumerBase::abandonLocked() {
    165 	CB_LOGV("abandonLocked");
    166     for (int i =0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
    167         freeBufferLocked(i);
    168     }
    169     // disconnect from the BufferQueue
    170     mConsumer->consumerDisconnect();
    171     mConsumer.clear();
    172 }
    173 
    174 bool ConsumerBase::isAbandoned() {
    175     Mutex::Autolock _l(mMutex);
    176     return mAbandoned;
    177 }
    178 
    179 void ConsumerBase::setFrameAvailableListener(
    180         const wp<FrameAvailableListener>& listener) {
    181     CB_LOGV("setFrameAvailableListener");
    182     Mutex::Autolock lock(mMutex);
    183     mFrameAvailableListener = listener;
    184 }
    185 
    186 status_t ConsumerBase::detachBuffer(int slot) {
    187     CB_LOGV("detachBuffer");
    188     Mutex::Autolock lock(mMutex);
    189 
    190     status_t result = mConsumer->detachBuffer(slot);
    191     if (result != NO_ERROR) {
    192         CB_LOGE("Failed to detach buffer: %d", result);
    193         return result;
    194     }
    195 
    196     freeBufferLocked(slot);
    197 
    198     return result;
    199 }
    200 
    201 status_t ConsumerBase::setDefaultBufferSize(uint32_t width, uint32_t height) {
    202     Mutex::Autolock _l(mMutex);
    203     return mConsumer->setDefaultBufferSize(width, height);
    204 }
    205 
    206 status_t ConsumerBase::setDefaultBufferFormat(PixelFormat defaultFormat) {
    207     Mutex::Autolock _l(mMutex);
    208     return mConsumer->setDefaultBufferFormat(defaultFormat);
    209 }
    210 
    211 status_t ConsumerBase::setDefaultBufferDataSpace(
    212         android_dataspace defaultDataSpace) {
    213     Mutex::Autolock _l(mMutex);
    214     return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
    215 }
    216 
    217 void ConsumerBase::dump(String8& result) const {
    218     dump(result, "");
    219 }
    220 
    221 void ConsumerBase::dump(String8& result, const char* prefix) const {
    222     Mutex::Autolock _l(mMutex);
    223     dumpLocked(result, prefix);
    224 }
    225 
    226 void ConsumerBase::dumpLocked(String8& result, const char* prefix) const {
    227     result.appendFormat("%smAbandoned=%d\n", prefix, int(mAbandoned));
    228 
    229     if (!mAbandoned) {
    230         mConsumer->dump(result, prefix);
    231     }
    232 }
    233 
    234 status_t ConsumerBase::acquireBufferLocked(BufferItem *item,
    235         nsecs_t presentWhen, uint64_t maxFrameNumber) {
    236     status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber);
    237     if (err != NO_ERROR) {
    238         return err;
    239     }
    240 
    241     if (item->mGraphicBuffer != NULL) {
    242         mSlots[item->mBuf].mGraphicBuffer = item->mGraphicBuffer;
    243     }
    244 
    245     mSlots[item->mBuf].mFrameNumber = item->mFrameNumber;
    246     mSlots[item->mBuf].mFence = item->mFence;
    247 
    248     CB_LOGV("acquireBufferLocked: -> slot=%d/%" PRIu64,
    249             item->mBuf, item->mFrameNumber);
    250 
    251     return OK;
    252 }
    253 
    254 status_t ConsumerBase::addReleaseFence(int slot,
    255         const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
    256     Mutex::Autolock lock(mMutex);
    257     return addReleaseFenceLocked(slot, graphicBuffer, fence);
    258 }
    259 
    260 status_t ConsumerBase::addReleaseFenceLocked(int slot,
    261         const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
    262     CB_LOGV("addReleaseFenceLocked: slot=%d", slot);
    263 
    264     // If consumer no longer tracks this graphicBuffer, we can safely
    265     // drop this fence, as it will never be received by the producer.
    266     if (!stillTracking(slot, graphicBuffer)) {
    267         return OK;
    268     }
    269 
    270     if (!mSlots[slot].mFence.get()) {
    271         mSlots[slot].mFence = fence;
    272     } else {
    273         sp<Fence> mergedFence = Fence::merge(
    274                 String8::format("%.28s:%d", mName.string(), slot),
    275                 mSlots[slot].mFence, fence);
    276         if (!mergedFence.get()) {
    277             CB_LOGE("failed to merge release fences");
    278             // synchronization is broken, the best we can do is hope fences
    279             // signal in order so the new fence will act like a union
    280             mSlots[slot].mFence = fence;
    281             return BAD_VALUE;
    282         }
    283         mSlots[slot].mFence = mergedFence;
    284     }
    285 
    286     return OK;
    287 }
    288 
    289 status_t ConsumerBase::releaseBufferLocked(
    290         int slot, const sp<GraphicBuffer> graphicBuffer,
    291         EGLDisplay display, EGLSyncKHR eglFence) {
    292     // If consumer no longer tracks this graphicBuffer (we received a new
    293     // buffer on the same slot), the buffer producer is definitely no longer
    294     // tracking it.
    295     if (!stillTracking(slot, graphicBuffer)) {
    296         return OK;
    297     }
    298 
    299     CB_LOGV("releaseBufferLocked: slot=%d/%" PRIu64,
    300             slot, mSlots[slot].mFrameNumber);
    301     status_t err = mConsumer->releaseBuffer(slot, mSlots[slot].mFrameNumber,
    302             display, eglFence, mSlots[slot].mFence);
    303     if (err == IGraphicBufferConsumer::STALE_BUFFER_SLOT) {
    304         freeBufferLocked(slot);
    305     }
    306 
    307     mSlots[slot].mFence = Fence::NO_FENCE;
    308 
    309     return err;
    310 }
    311 
    312 bool ConsumerBase::stillTracking(int slot,
    313         const sp<GraphicBuffer> graphicBuffer) {
    314     if (slot < 0 || slot >= BufferQueue::NUM_BUFFER_SLOTS) {
    315         return false;
    316     }
    317     return (mSlots[slot].mGraphicBuffer != NULL &&
    318             mSlots[slot].mGraphicBuffer->handle == graphicBuffer->handle);
    319 }
    320 
    321 } // namespace android
    322