cf3834db10
Currently, there are two instances of BufferItem: one inside of
IGraphicBufferConsumer, and a standalone one inside of libgui. They
only differ in the name of one of the fields, and we want to remove
the IGBC version. This changes things so that client code may be
incrementally switched over to the libgui version.
This is a squashed commit containing the following changes:
I64f495105f56cbf5803cea4aa6b072ea29b70cf5
I1394e693314429ada93427889f10b7b01c948053
I9c3bc8037fa9438d4d9080b8afb694219ef2f71f
I699ed0a6837076867ca756b28d1ffb2238f7a0d9
Iac8425e1241774304a131da2fb9dec6e82922f13
Change-Id: Ic4d51f5df6dbc70b376d13fceba2335b9bae4f3d
131 lines
4.1 KiB
C++
131 lines
4.1 KiB
C++
/*
|
|
* Copyright (C) 2012 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.
|
|
*/
|
|
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "BufferItemConsumer"
|
|
//#define ATRACE_TAG ATRACE_TAG_GRAPHICS
|
|
#include <utils/Log.h>
|
|
|
|
#include <gui/BufferItem.h>
|
|
#include <gui/BufferItemConsumer.h>
|
|
|
|
//#define BI_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
|
|
//#define BI_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
|
|
//#define BI_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)
|
|
//#define BI_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)
|
|
#define BI_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__)
|
|
|
|
namespace android {
|
|
|
|
BufferItemConsumer::BufferItemConsumer(
|
|
const sp<IGraphicBufferConsumer>& consumer, uint32_t consumerUsage,
|
|
int bufferCount, bool controlledByApp) :
|
|
ConsumerBase(consumer, controlledByApp)
|
|
{
|
|
status_t err = mConsumer->setConsumerUsageBits(consumerUsage);
|
|
LOG_ALWAYS_FATAL_IF(err != OK,
|
|
"Failed to set consumer usage bits to %#x", consumerUsage);
|
|
if (bufferCount != DEFAULT_MAX_BUFFERS) {
|
|
err = mConsumer->setMaxAcquiredBufferCount(bufferCount);
|
|
LOG_ALWAYS_FATAL_IF(err != OK,
|
|
"Failed to set max acquired buffer count to %d", bufferCount);
|
|
}
|
|
}
|
|
|
|
BufferItemConsumer::~BufferItemConsumer() {}
|
|
|
|
void BufferItemConsumer::setName(const String8& name) {
|
|
Mutex::Autolock _l(mMutex);
|
|
mName = name;
|
|
mConsumer->setConsumerName(name);
|
|
}
|
|
|
|
status_t BufferItemConsumer::acquireBuffer(BufferQueue::BufferItem *item,
|
|
nsecs_t presentWhen, bool waitForFence) {
|
|
status_t err;
|
|
|
|
if (!item) return BAD_VALUE;
|
|
|
|
Mutex::Autolock _l(mMutex);
|
|
|
|
err = acquireBufferLocked(item, presentWhen);
|
|
if (err != OK) {
|
|
if (err != NO_BUFFER_AVAILABLE) {
|
|
BI_LOGE("Error acquiring buffer: %s (%d)", strerror(err), err);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
if (waitForFence) {
|
|
err = item->mFence->waitForever("BufferItemConsumer::acquireBuffer");
|
|
if (err != OK) {
|
|
BI_LOGE("Failed to wait for fence of acquired buffer: %s (%d)",
|
|
strerror(-err), err);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
item->mGraphicBuffer = mSlots[item->mBuf].mGraphicBuffer;
|
|
|
|
return OK;
|
|
}
|
|
|
|
status_t BufferItemConsumer::acquireBuffer(android::BufferItem* outItem,
|
|
nsecs_t presentWhen, bool waitForFence) {
|
|
BufferQueue::BufferItem item;
|
|
status_t result = acquireBuffer(&item, presentWhen, waitForFence);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
*outItem = item;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t BufferItemConsumer::releaseBuffer(const BufferItem &item,
|
|
const sp<Fence>& releaseFence) {
|
|
status_t err;
|
|
|
|
Mutex::Autolock _l(mMutex);
|
|
|
|
err = addReleaseFenceLocked(item.mBuf, item.mGraphicBuffer, releaseFence);
|
|
|
|
err = releaseBufferLocked(item.mBuf, item.mGraphicBuffer, EGL_NO_DISPLAY,
|
|
EGL_NO_SYNC_KHR);
|
|
if (err != OK) {
|
|
BI_LOGE("Failed to release buffer: %s (%d)",
|
|
strerror(-err), err);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
status_t BufferItemConsumer::setDefaultBufferSize(uint32_t w, uint32_t h) {
|
|
Mutex::Autolock _l(mMutex);
|
|
return mConsumer->setDefaultBufferSize(w, h);
|
|
}
|
|
|
|
status_t BufferItemConsumer::setDefaultBufferFormat(PixelFormat defaultFormat) {
|
|
Mutex::Autolock _l(mMutex);
|
|
return mConsumer->setDefaultBufferFormat(defaultFormat);
|
|
}
|
|
|
|
status_t BufferItemConsumer::setDefaultBufferDataSpace(
|
|
android_dataspace defaultDataSpace) {
|
|
Mutex::Autolock _l(mMutex);
|
|
return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
|
|
}
|
|
|
|
} // namespace android
|