/* * Copyright (C) 2010 The Android Open Source Project * Copyright (C) 2013 Mozilla Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define LOG_TAG "GonkConsumerBase" #define ATRACE_TAG ATRACE_TAG_GRAPHICS //#define LOG_NDEBUG 0 #define EGL_EGLEXT_PROTOTYPES #include <hardware/hardware.h> #include <gui/IGraphicBufferAlloc.h> #include <utils/Log.h> #include <utils/String8.h> #include "GonkConsumerBaseJB.h" // Macros for including the GonkConsumerBase name in log messages #define CB_LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__) #define CB_LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__) #define CB_LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__) #define CB_LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__) #define CB_LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__) namespace android { // Get an ID that's unique within this process. static int32_t createProcessUniqueId() { static volatile int32_t globalCounter = 0; return android_atomic_inc(&globalCounter); } GonkConsumerBase::GonkConsumerBase(const sp<GonkBufferQueue>& bufferQueue) : mAbandoned(false), mBufferQueue(bufferQueue) { // Choose a name using the PID and a process-unique ID. mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId()); // Note that we can't create an sp<...>(this) in a ctor that will not keep a // reference once the ctor ends, as that would cause the refcount of 'this' // dropping to 0 at the end of the ctor. Since all we need is a wp<...> // that's what we create. wp<GonkBufferQueue::ConsumerListener> listener; sp<GonkBufferQueue::ConsumerListener> proxy; listener = static_cast<GonkBufferQueue::ConsumerListener*>(this); proxy = new GonkBufferQueue::ProxyConsumerListener(listener); status_t err = mBufferQueue->consumerConnect(proxy); if (err != NO_ERROR) { CB_LOGE("GonkConsumerBase: error connecting to GonkBufferQueue: %s (%d)", strerror(-err), err); } else { mBufferQueue->setConsumerName(mName); } } GonkConsumerBase::~GonkConsumerBase() { CB_LOGV("~GonkConsumerBase"); Mutex::Autolock lock(mMutex); // Verify that abandon() has been called before we get here. This should // be done by GonkConsumerBase::onLastStrongRef(), but it's possible for a // derived class to override that method and not call // GonkConsumerBase::onLastStrongRef(). LOG_ALWAYS_FATAL_IF(!mAbandoned, "[%s] ~GonkConsumerBase was called, but the " "consumer is not abandoned!", mName.string()); } void GonkConsumerBase::onLastStrongRef(const void* id) { abandon(); } void GonkConsumerBase::freeBufferLocked(int slotIndex) { CB_LOGV("freeBufferLocked: slotIndex=%d", slotIndex); mSlots[slotIndex].mGraphicBuffer = 0; mSlots[slotIndex].mFence = Fence::NO_FENCE; } // Used for refactoring, should not be in final interface sp<GonkBufferQueue> GonkConsumerBase::getBufferQueue() const { Mutex::Autolock lock(mMutex); return mBufferQueue; } void GonkConsumerBase::onFrameAvailable() { CB_LOGV("onFrameAvailable"); sp<FrameAvailableListener> listener; { // scope for the lock Mutex::Autolock lock(mMutex); #if ANDROID_VERSION == 17 listener = mFrameAvailableListener; #else listener = mFrameAvailableListener.promote(); #endif } if (listener != NULL) { CB_LOGV("actually calling onFrameAvailable"); listener->onFrameAvailable(); } } void GonkConsumerBase::onBuffersReleased() { Mutex::Autolock lock(mMutex); CB_LOGV("onBuffersReleased"); if (mAbandoned) { // Nothing to do if we're already abandoned. return; } uint32_t mask = 0; mBufferQueue->getReleasedBuffers(&mask); for (int i = 0; i < GonkBufferQueue::NUM_BUFFER_SLOTS; i++) { if (mask & (1 << i)) { freeBufferLocked(i); } } } void GonkConsumerBase::abandon() { CB_LOGV("abandon"); Mutex::Autolock lock(mMutex); if (!mAbandoned) { abandonLocked(); mAbandoned = true; } } void GonkConsumerBase::abandonLocked() { CB_LOGV("abandonLocked"); for (int i =0; i < GonkBufferQueue::NUM_BUFFER_SLOTS; i++) { freeBufferLocked(i); } // disconnect from the GonkBufferQueue mBufferQueue->consumerDisconnect(); mBufferQueue.clear(); } void GonkConsumerBase::setFrameAvailableListener( #if ANDROID_VERSION == 17 const sp<FrameAvailableListener>& listener) { #else const wp<FrameAvailableListener>& listener) { #endif CB_LOGV("setFrameAvailableListener"); Mutex::Autolock lock(mMutex); mFrameAvailableListener = listener; } void GonkConsumerBase::dump(String8& result) const { char buffer[1024]; dump(result, "", buffer, 1024); } void GonkConsumerBase::dump(String8& result, const char* prefix, char* buffer, size_t size) const { Mutex::Autolock _l(mMutex); dumpLocked(result, prefix, buffer, size); } void GonkConsumerBase::dumpLocked(String8& result, const char* prefix, char* buffer, size_t SIZE) const { snprintf(buffer, SIZE, "%smAbandoned=%d\n", prefix, int(mAbandoned)); result.append(buffer); if (!mAbandoned) { mBufferQueue->dumpToString(result, prefix, buffer, SIZE); } } status_t GonkConsumerBase::acquireBufferLocked(GonkBufferQueue::BufferItem *item) { status_t err = mBufferQueue->acquireBuffer(item); if (err != NO_ERROR) { return err; } if (item->mGraphicBuffer != NULL) { mSlots[item->mBuf].mGraphicBuffer = item->mGraphicBuffer; } mSlots[item->mBuf].mFence = item->mFence; CB_LOGV("acquireBufferLocked: -> slot=%d", item->mBuf); return OK; } status_t GonkConsumerBase::addReleaseFence(int slot, const sp<Fence>& fence) { Mutex::Autolock lock(mMutex); return addReleaseFenceLocked(slot, fence); } status_t GonkConsumerBase::addReleaseFenceLocked(int slot, const sp<Fence>& fence) { CB_LOGV("addReleaseFenceLocked: slot=%d", slot); if (!mSlots[slot].mFence.get()) { mSlots[slot].mFence = fence; } else { sp<Fence> mergedFence = Fence::merge( String8::format("%.28s:%d", mName.string(), slot), mSlots[slot].mFence, fence); if (!mergedFence.get()) { CB_LOGE("failed to merge release fences"); // synchronization is broken, the best we can do is hope fences // signal in order so the new fence will act like a union mSlots[slot].mFence = fence; return BAD_VALUE; } mSlots[slot].mFence = mergedFence; } return OK; } status_t GonkConsumerBase::releaseBufferLocked(int slot) { CB_LOGV("releaseBufferLocked: slot=%d", slot); status_t err = mBufferQueue->releaseBuffer(slot, mSlots[slot].mFence); if (err == GonkBufferQueue::STALE_BUFFER_SLOT) { freeBufferLocked(slot); } mSlots[slot].mFence = Fence::NO_FENCE; return err; } } // namespace android