You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
518 lines
16 KiB
518 lines
16 KiB
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <inttypes.h>
|
|
|
|
#define LOG_TAG "ConsumerBase"
|
|
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
|
|
//#define LOG_NDEBUG 0
|
|
|
|
#define EGL_EGLEXT_PROTOTYPES
|
|
|
|
#include <EGL/egl.h>
|
|
#include <EGL/eglext.h>
|
|
|
|
#include <hardware/hardware.h>
|
|
|
|
#include <cutils/atomic.h>
|
|
|
|
#include <gui/BufferItem.h>
|
|
#include <gui/ISurfaceComposer.h>
|
|
#include <gui/SurfaceComposerClient.h>
|
|
#include <gui/ConsumerBase.h>
|
|
|
|
#include <private/gui/ComposerService.h>
|
|
|
|
#include <utils/Log.h>
|
|
#include <utils/String8.h>
|
|
#include <utils/Trace.h>
|
|
|
|
// Macros for including the ConsumerBase name in log messages
|
|
#define CB_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
|
|
//#define CB_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
|
|
//#define CB_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)
|
|
//#define CB_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)
|
|
#define CB_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__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);
|
|
}
|
|
|
|
ConsumerBase::ConsumerBase(const sp<IGraphicBufferConsumer>& bufferQueue, bool controlledByApp) :
|
|
mAbandoned(false),
|
|
mConsumer(bufferQueue),
|
|
mPrevFinalReleaseFence(Fence::NO_FENCE) {
|
|
// 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<ConsumerListener> listener = static_cast<ConsumerListener*>(this);
|
|
sp<IConsumerListener> proxy = new BufferQueue::ProxyConsumerListener(listener);
|
|
|
|
status_t err = mConsumer->consumerConnect(proxy, controlledByApp);
|
|
if (err != NO_ERROR) {
|
|
CB_LOGE("ConsumerBase: error connecting to BufferQueue: %s (%d)",
|
|
strerror(-err), err);
|
|
} else {
|
|
mConsumer->setConsumerName(mName);
|
|
}
|
|
}
|
|
|
|
ConsumerBase::~ConsumerBase() {
|
|
CB_LOGV("~ConsumerBase");
|
|
Mutex::Autolock lock(mMutex);
|
|
|
|
// Verify that abandon() has been called before we get here. This should
|
|
// be done by ConsumerBase::onLastStrongRef(), but it's possible for a
|
|
// derived class to override that method and not call
|
|
// ConsumerBase::onLastStrongRef().
|
|
LOG_ALWAYS_FATAL_IF(!mAbandoned, "[%s] ~ConsumerBase was called, but the "
|
|
"consumer is not abandoned!", mName.string());
|
|
}
|
|
|
|
void ConsumerBase::onLastStrongRef(const void* id __attribute__((unused))) {
|
|
abandon();
|
|
}
|
|
|
|
void ConsumerBase::freeBufferLocked(int slotIndex) {
|
|
CB_LOGV("freeBufferLocked: slotIndex=%d", slotIndex);
|
|
mSlots[slotIndex].mGraphicBuffer = nullptr;
|
|
mSlots[slotIndex].mFence = Fence::NO_FENCE;
|
|
mSlots[slotIndex].mFrameNumber = 0;
|
|
}
|
|
|
|
void ConsumerBase::onFrameDequeued(const uint64_t bufferId) {
|
|
CB_LOGV("onFrameDequeued");
|
|
|
|
sp<FrameAvailableListener> listener;
|
|
{
|
|
Mutex::Autolock lock(mFrameAvailableMutex);
|
|
listener = mFrameAvailableListener.promote();
|
|
}
|
|
|
|
if (listener != nullptr) {
|
|
listener->onFrameDequeued(bufferId);
|
|
}
|
|
}
|
|
|
|
void ConsumerBase::onFrameCancelled(const uint64_t bufferId) {
|
|
CB_LOGV("onFrameCancelled");
|
|
|
|
sp<FrameAvailableListener> listener;
|
|
{
|
|
Mutex::Autolock lock(mFrameAvailableMutex);
|
|
listener = mFrameAvailableListener.promote();
|
|
}
|
|
|
|
if (listener != nullptr) {
|
|
listener->onFrameCancelled(bufferId);
|
|
}
|
|
}
|
|
|
|
void ConsumerBase::onFrameDetached(const uint64_t bufferId) {
|
|
CB_LOGV("onFrameDetached");
|
|
|
|
sp<FrameAvailableListener> listener;
|
|
{
|
|
Mutex::Autolock lock(mFrameAvailableMutex);
|
|
listener = mFrameAvailableListener.promote();
|
|
}
|
|
|
|
if (listener != nullptr) {
|
|
listener->onFrameDetached(bufferId);
|
|
}
|
|
}
|
|
|
|
void ConsumerBase::onFrameAvailable(const BufferItem& item) {
|
|
CB_LOGV("onFrameAvailable");
|
|
|
|
sp<FrameAvailableListener> listener;
|
|
{ // scope for the lock
|
|
Mutex::Autolock lock(mFrameAvailableMutex);
|
|
listener = mFrameAvailableListener.promote();
|
|
}
|
|
|
|
if (listener != nullptr) {
|
|
CB_LOGV("actually calling onFrameAvailable");
|
|
listener->onFrameAvailable(item);
|
|
}
|
|
}
|
|
|
|
void ConsumerBase::onFrameReplaced(const BufferItem &item) {
|
|
CB_LOGV("onFrameReplaced");
|
|
|
|
sp<FrameAvailableListener> listener;
|
|
{
|
|
Mutex::Autolock lock(mFrameAvailableMutex);
|
|
listener = mFrameAvailableListener.promote();
|
|
}
|
|
|
|
if (listener != nullptr) {
|
|
CB_LOGV("actually calling onFrameReplaced");
|
|
listener->onFrameReplaced(item);
|
|
}
|
|
}
|
|
|
|
void ConsumerBase::onBuffersReleased() {
|
|
Mutex::Autolock lock(mMutex);
|
|
|
|
CB_LOGV("onBuffersReleased");
|
|
|
|
if (mAbandoned) {
|
|
// Nothing to do if we're already abandoned.
|
|
return;
|
|
}
|
|
|
|
uint64_t mask = 0;
|
|
mConsumer->getReleasedBuffers(&mask);
|
|
for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
|
|
if (mask & (1ULL << i)) {
|
|
freeBufferLocked(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ConsumerBase::onSidebandStreamChanged() {
|
|
}
|
|
|
|
void ConsumerBase::abandon() {
|
|
CB_LOGV("abandon");
|
|
Mutex::Autolock lock(mMutex);
|
|
|
|
if (!mAbandoned) {
|
|
abandonLocked();
|
|
mAbandoned = true;
|
|
}
|
|
}
|
|
|
|
void ConsumerBase::abandonLocked() {
|
|
CB_LOGV("abandonLocked");
|
|
if (mAbandoned) {
|
|
CB_LOGE("abandonLocked: ConsumerBase is abandoned!");
|
|
return;
|
|
}
|
|
for (int i =0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
|
|
freeBufferLocked(i);
|
|
}
|
|
// disconnect from the BufferQueue
|
|
mConsumer->consumerDisconnect();
|
|
mConsumer.clear();
|
|
}
|
|
|
|
bool ConsumerBase::isAbandoned() {
|
|
Mutex::Autolock _l(mMutex);
|
|
return mAbandoned;
|
|
}
|
|
|
|
void ConsumerBase::setName(const String8& name) {
|
|
Mutex::Autolock _l(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("setName: ConsumerBase is abandoned!");
|
|
return;
|
|
}
|
|
mName = name;
|
|
mConsumer->setConsumerName(name);
|
|
}
|
|
|
|
void ConsumerBase::setFrameAvailableListener(
|
|
const wp<FrameAvailableListener>& listener) {
|
|
CB_LOGV("setFrameAvailableListener");
|
|
Mutex::Autolock lock(mFrameAvailableMutex);
|
|
mFrameAvailableListener = listener;
|
|
}
|
|
|
|
status_t ConsumerBase::detachBuffer(int slot) {
|
|
CB_LOGV("detachBuffer");
|
|
Mutex::Autolock lock(mMutex);
|
|
|
|
if (mAbandoned) {
|
|
CB_LOGE("detachBuffer: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
|
|
status_t result = mConsumer->detachBuffer(slot);
|
|
if (result != NO_ERROR) {
|
|
CB_LOGE("Failed to detach buffer: %d", result);
|
|
return result;
|
|
}
|
|
|
|
freeBufferLocked(slot);
|
|
|
|
return result;
|
|
}
|
|
|
|
status_t ConsumerBase::setDefaultBufferSize(uint32_t width, uint32_t height) {
|
|
Mutex::Autolock _l(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("setDefaultBufferSize: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
return mConsumer->setDefaultBufferSize(width, height);
|
|
}
|
|
|
|
status_t ConsumerBase::setDefaultBufferFormat(PixelFormat defaultFormat) {
|
|
Mutex::Autolock _l(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("setDefaultBufferFormat: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
return mConsumer->setDefaultBufferFormat(defaultFormat);
|
|
}
|
|
|
|
status_t ConsumerBase::setDefaultBufferDataSpace(
|
|
android_dataspace defaultDataSpace) {
|
|
Mutex::Autolock _l(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("setDefaultBufferDataSpace: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
|
|
}
|
|
|
|
status_t ConsumerBase::setConsumerUsageBits(uint64_t usage) {
|
|
Mutex::Autolock lock(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("setConsumerUsageBits: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
return mConsumer->setConsumerUsageBits(usage);
|
|
}
|
|
|
|
status_t ConsumerBase::setTransformHint(uint32_t hint) {
|
|
Mutex::Autolock lock(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("setTransformHint: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
return mConsumer->setTransformHint(hint);
|
|
}
|
|
|
|
status_t ConsumerBase::setMaxAcquiredBufferCount(int maxAcquiredBuffers) {
|
|
Mutex::Autolock lock(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("setMaxAcquiredBufferCount: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
return mConsumer->setMaxAcquiredBufferCount(maxAcquiredBuffers);
|
|
}
|
|
|
|
sp<NativeHandle> ConsumerBase::getSidebandStream() const {
|
|
Mutex::Autolock _l(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("getSidebandStream: ConsumerBase is abandoned!");
|
|
return nullptr;
|
|
}
|
|
|
|
sp<NativeHandle> stream;
|
|
status_t err = mConsumer->getSidebandStream(&stream);
|
|
if (err != NO_ERROR) {
|
|
CB_LOGE("failed to get sideband stream: %d", err);
|
|
return nullptr;
|
|
}
|
|
|
|
return stream;
|
|
}
|
|
|
|
status_t ConsumerBase::getOccupancyHistory(bool forceFlush,
|
|
std::vector<OccupancyTracker::Segment>* outHistory) {
|
|
Mutex::Autolock _l(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("getOccupancyHistory: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
return mConsumer->getOccupancyHistory(forceFlush, outHistory);
|
|
}
|
|
|
|
status_t ConsumerBase::discardFreeBuffers() {
|
|
Mutex::Autolock _l(mMutex);
|
|
if (mAbandoned) {
|
|
CB_LOGE("discardFreeBuffers: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
status_t err = mConsumer->discardFreeBuffers();
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
uint64_t mask;
|
|
mConsumer->getReleasedBuffers(&mask);
|
|
for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
|
|
if (mask & (1ULL << i)) {
|
|
freeBufferLocked(i);
|
|
}
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
void ConsumerBase::dumpState(String8& result) const {
|
|
dumpState(result, "");
|
|
}
|
|
|
|
void ConsumerBase::dumpState(String8& result, const char* prefix) const {
|
|
Mutex::Autolock _l(mMutex);
|
|
dumpLocked(result, prefix);
|
|
}
|
|
|
|
void ConsumerBase::dumpLocked(String8& result, const char* prefix) const {
|
|
result.appendFormat("%smAbandoned=%d\n", prefix, int(mAbandoned));
|
|
|
|
if (!mAbandoned) {
|
|
String8 consumerState;
|
|
mConsumer->dumpState(String8(prefix), &consumerState);
|
|
result.append(consumerState);
|
|
}
|
|
}
|
|
|
|
status_t ConsumerBase::acquireBufferLocked(BufferItem *item,
|
|
nsecs_t presentWhen, uint64_t maxFrameNumber) {
|
|
if (mAbandoned) {
|
|
CB_LOGE("acquireBufferLocked: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
|
|
status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber);
|
|
if (err != NO_ERROR) {
|
|
return err;
|
|
}
|
|
|
|
if (item->mGraphicBuffer != nullptr) {
|
|
if (mSlots[item->mSlot].mGraphicBuffer != nullptr) {
|
|
freeBufferLocked(item->mSlot);
|
|
}
|
|
mSlots[item->mSlot].mGraphicBuffer = item->mGraphicBuffer;
|
|
}
|
|
|
|
mSlots[item->mSlot].mFrameNumber = item->mFrameNumber;
|
|
mSlots[item->mSlot].mFence = item->mFence;
|
|
|
|
CB_LOGV("acquireBufferLocked: -> slot=%d/%" PRIu64,
|
|
item->mSlot, item->mFrameNumber);
|
|
|
|
return OK;
|
|
}
|
|
|
|
status_t ConsumerBase::addReleaseFence(int slot,
|
|
const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
|
|
Mutex::Autolock lock(mMutex);
|
|
return addReleaseFenceLocked(slot, graphicBuffer, fence);
|
|
}
|
|
|
|
status_t ConsumerBase::addReleaseFenceLocked(int slot,
|
|
const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
|
|
CB_LOGV("addReleaseFenceLocked: slot=%d", slot);
|
|
|
|
// If consumer no longer tracks this graphicBuffer, we can safely
|
|
// drop this fence, as it will never be received by the producer.
|
|
if (!stillTracking(slot, graphicBuffer)) {
|
|
return OK;
|
|
}
|
|
|
|
if (!mSlots[slot].mFence.get()) {
|
|
mSlots[slot].mFence = fence;
|
|
return OK;
|
|
}
|
|
|
|
// Check status of fences first because merging is expensive.
|
|
// Merging an invalid fence with any other fence results in an
|
|
// invalid fence.
|
|
auto currentStatus = mSlots[slot].mFence->getStatus();
|
|
if (currentStatus == Fence::Status::Invalid) {
|
|
CB_LOGE("Existing fence has invalid state");
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
auto incomingStatus = fence->getStatus();
|
|
if (incomingStatus == Fence::Status::Invalid) {
|
|
CB_LOGE("New fence has invalid state");
|
|
mSlots[slot].mFence = fence;
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
// If both fences are signaled or both are unsignaled, we need to merge
|
|
// them to get an accurate timestamp.
|
|
if (currentStatus == incomingStatus) {
|
|
char fenceName[32] = {};
|
|
snprintf(fenceName, 32, "%.28s:%d", mName.string(), slot);
|
|
sp<Fence> mergedFence = Fence::merge(
|
|
fenceName, 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;
|
|
} else if (incomingStatus == Fence::Status::Unsignaled) {
|
|
// If one fence has signaled and the other hasn't, the unsignaled
|
|
// fence will approximately correspond with the correct timestamp.
|
|
// There's a small race if both fences signal at about the same time
|
|
// and their statuses are retrieved with unfortunate timing. However,
|
|
// by this point, they will have both signaled and only the timestamp
|
|
// will be slightly off; any dependencies after this point will
|
|
// already have been met.
|
|
mSlots[slot].mFence = fence;
|
|
}
|
|
// else if (currentStatus == Fence::Status::Unsignaled) is a no-op.
|
|
|
|
return OK;
|
|
}
|
|
|
|
status_t ConsumerBase::releaseBufferLocked(
|
|
int slot, const sp<GraphicBuffer> graphicBuffer,
|
|
EGLDisplay display, EGLSyncKHR eglFence) {
|
|
if (mAbandoned) {
|
|
CB_LOGE("releaseBufferLocked: ConsumerBase is abandoned!");
|
|
return NO_INIT;
|
|
}
|
|
// If consumer no longer tracks this graphicBuffer (we received a new
|
|
// buffer on the same slot), the buffer producer is definitely no longer
|
|
// tracking it.
|
|
if (!stillTracking(slot, graphicBuffer)) {
|
|
return OK;
|
|
}
|
|
|
|
CB_LOGV("releaseBufferLocked: slot=%d/%" PRIu64,
|
|
slot, mSlots[slot].mFrameNumber);
|
|
status_t err = mConsumer->releaseBuffer(slot, mSlots[slot].mFrameNumber,
|
|
display, eglFence, mSlots[slot].mFence);
|
|
if (err == IGraphicBufferConsumer::STALE_BUFFER_SLOT) {
|
|
freeBufferLocked(slot);
|
|
}
|
|
|
|
mPrevFinalReleaseFence = mSlots[slot].mFence;
|
|
mSlots[slot].mFence = Fence::NO_FENCE;
|
|
|
|
return err;
|
|
}
|
|
|
|
bool ConsumerBase::stillTracking(int slot,
|
|
const sp<GraphicBuffer> graphicBuffer) {
|
|
if (slot < 0 || slot >= BufferQueue::NUM_BUFFER_SLOTS) {
|
|
return false;
|
|
}
|
|
return (mSlots[slot].mGraphicBuffer != nullptr &&
|
|
mSlots[slot].mGraphicBuffer->handle == graphicBuffer->handle);
|
|
}
|
|
|
|
} // namespace android
|