mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-31 06:05:44 +00:00
238 lines
7.3 KiB
C++
Executable File
238 lines
7.3 KiB
C++
Executable File
/*
|
|
* 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 "GonkConsumerBase.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);
|
|
listener = mFrameAvailableListener.promote();
|
|
}
|
|
|
|
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(
|
|
const wp<FrameAvailableListener>& listener) {
|
|
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->dump(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
|