Cherry-pick dataSpace and BufferItem changes

Add dataSpace to buffer queues; remove old format enums.
(cherry picked from commit 82c6bcc970)

libgui: Prepare for IGBC::BufferItem removal
(cherry picked from commit cf3834db10)

SurfaceFlinger: Stop using IGBC::BufferItem
(cherry picked from commit 11611f9be5)

Change-Id: Ic2e4770b916d2d1477e5ce98c4b49a0072ea03ff
(cherry picked from commit 6c45010175)
This commit is contained in:
Eino-Ville Talvala 2015-02-19 16:10:43 -08:00 committed by Dan Stoza
parent 2d4cf62a2c
commit 1c2001efcf
37 changed files with 388 additions and 91 deletions

View File

@ -44,6 +44,7 @@ class BufferItem : public Flattenable<BufferItem> {
// The default value of mBuf, used to indicate this doesn't correspond to a slot.
enum { INVALID_BUFFER_SLOT = -1 };
BufferItem();
BufferItem(const IGraphicBufferConsumer::BufferItem& item);
~BufferItem();
operator IGraphicBufferConsumer::BufferItem() const;
@ -78,11 +79,21 @@ class BufferItem : public Flattenable<BufferItem> {
// automatically when the buffer was queued.
bool mIsAutoTimestamp;
// mDataSpace is the current dataSpace value for this buffer slot. This gets
// set by queueBuffer each time this slot is queued. The meaning of the
// dataSpace is format-dependent.
android_dataspace mDataSpace;
// mFrameNumber is the number of the queued frame for this slot.
uint64_t mFrameNumber;
// mSlot is the slot index of this buffer (default INVALID_BUFFER_SLOT).
int mSlot;
union {
// mSlot is the slot index of this buffer (default INVALID_BUFFER_SLOT).
int mSlot;
// mBuf is the former name for mSlot
int mBuf;
};
// mIsDroppable whether this buffer was queued with the
// property that it can be replaced by a new buffer for the purpose of

View File

@ -76,8 +76,10 @@ class BufferItemConsumer: public ConsumerBase
//
// If waitForFence is true, and the acquired BufferItem has a valid fence object,
// acquireBuffer will wait on the fence with no timeout before returning.
status_t acquireBuffer(BufferItem *item, nsecs_t presentWhen,
bool waitForFence = true);
status_t acquireBuffer(BufferQueue::BufferItem *item, nsecs_t presentWhen,
bool waitForFence = true);
status_t acquireBuffer(android::BufferItem* item, nsecs_t presentWhen,
bool waitForFence = true);
// Returns an acquired buffer to the queue, allowing it to be reused. Since
// only a fixed number of buffers may be acquired at a time, old buffers
@ -96,6 +98,13 @@ class BufferItemConsumer: public ConsumerBase
// GraphicBuffers of a defaultFormat if no format is specified
// in dequeueBuffer
status_t setDefaultBufferFormat(PixelFormat defaultFormat);
// setDefaultBufferDataSpace allows the BufferQueue to create
// GraphicBuffers of a defaultDataSpace if no data space is specified
// in queueBuffer.
// The initial default is HAL_DATASPACE_UNKNOWN
status_t setDefaultBufferDataSpace(android_dataspace defaultDataSpace);
};
} // namespace android

View File

@ -48,6 +48,8 @@ public:
// is CLOCK_MONOTONIC.
virtual status_t acquireBuffer(BufferItem* outBuffer,
nsecs_t expectedPresent);
virtual status_t acquireBuffer(android::BufferItem* outBuffer,
nsecs_t expectedPresent);
// See IGraphicBufferConsumer::detachBuffer
virtual status_t detachBuffer(int slot);
@ -128,6 +130,13 @@ public:
// in dequeueBuffer. The initial default is HAL_PIXEL_FORMAT_RGBA_8888.
virtual status_t setDefaultBufferFormat(PixelFormat defaultFormat);
// setDefaultBufferDataSpace allows the BufferQueue to create
// GraphicBuffers of a defaultDataSpace if no data space is specified
// in queueBuffer.
// The initial default is HAL_DATASPACE_UNKNOWN
virtual status_t setDefaultBufferDataSpace(
android_dataspace defaultDataSpace);
// setConsumerUsageBits will turn on additional usage bits for dequeueBuffer.
// These are merged with the bits passed to dequeueBuffer. The values are
// enumerated in gralloc.h, e.g. GRALLOC_USAGE_HW_RENDER; the default is 0.

View File

@ -209,6 +209,11 @@ private:
// in dequeueBuffer if a width and height of 0 are specified.
uint32_t mDefaultHeight;
// mDefaultBufferDataSpace holds the default dataSpace of queued buffers.
// It is used in queueBuffer if a dataspace of 0 (HAL_DATASPACE_UNKNOWN)
// is specified.
android_dataspace mDefaultBufferDataSpace;
// mDefaultMaxBufferCount is the default limit on the number of buffers that
// will be allocated at one time. This default limit is set by the consumer.
// The limit (as opposed to the default limit) may be overriden by the

View File

@ -153,8 +153,8 @@ protected:
// initialization that must take place the first time a buffer is assigned
// to a slot. If it is overridden the derived class's implementation must
// call ConsumerBase::acquireBufferLocked.
virtual status_t acquireBufferLocked(IGraphicBufferConsumer::BufferItem *item,
nsecs_t presentWhen);
virtual status_t acquireBufferLocked(BufferItem *item, nsecs_t presentWhen);
virtual status_t acquireBufferLocked(BufferQueue::BufferItem *item, nsecs_t presentWhen);
// releaseBufferLocked relinquishes control over a buffer, returning that
// control to the BufferQueue.

View File

@ -53,6 +53,7 @@ class CpuConsumer : public ConsumerBase
uint32_t transform;
uint32_t scalingMode;
int64_t timestamp;
android_dataspace dataSpace;
uint64_t frameNumber;
// this is the same as format, except for formats that are compatible with
// a flexible format (e.g. HAL_PIXEL_FORMAT_YCbCr_420_888). In the latter
@ -90,6 +91,12 @@ class CpuConsumer : public ConsumerBase
// The initial default is PIXEL_FORMAT_RGBA_8888.
status_t setDefaultBufferFormat(PixelFormat defaultFormat);
// setDefaultBufferDataSpace allows the BufferQueue to create
// GraphicBuffers of a defaultDataSpace if no data space is specified
// in queueBuffer.
// The initial default is HAL_DATASPACE_UNKNOWN
status_t setDefaultBufferDataSpace(android_dataspace defaultDataSpace);
// Gets the next graphics buffer from the producer and locks it for CPU use,
// filling out the passed-in locked buffer structure with the native pointer
// and metadata. Returns BAD_VALUE if no new buffer is available, and

View File

@ -198,6 +198,7 @@ public:
// These functions call the corresponding BufferQueue implementation
// so the refactoring can proceed smoothly
status_t setDefaultBufferFormat(PixelFormat defaultFormat);
status_t setDefaultBufferDataSpace(android_dataspace defaultDataSpace);
status_t setConsumerUsageBits(uint32_t usage);
status_t setTransformHint(uint32_t hint);
@ -240,8 +241,8 @@ protected:
// acquireBufferLocked overrides the ConsumerBase method to update the
// mEglSlots array in addition to the ConsumerBase behavior.
virtual status_t acquireBufferLocked(BufferQueue::BufferItem *item,
nsecs_t presentWhen);
virtual status_t acquireBufferLocked(BufferItem *item, nsecs_t presentWhen);
virtual status_t acquireBufferLocked(IGraphicBufferConsumer::BufferItem *item, nsecs_t presentWhen);
// releaseBufferLocked overrides the ConsumerBase method to update the
// mEglSlots array in addition to the ConsumerBase.

View File

@ -34,6 +34,7 @@
namespace android {
// ----------------------------------------------------------------------------
class BufferItem;
class Fence;
class GraphicBuffer;
class IConsumerListener;
@ -86,6 +87,10 @@ public:
// automatically when the buffer was queued.
bool mIsAutoTimestamp;
// mDataSpace is the current dataSpace for this buffer slot. This gets
// set by queueBuffer each time this slot is queued.
android_dataspace mDataSpace;
// mFrameNumber is the number of the queued frame for this slot.
uint64_t mFrameNumber;
@ -143,6 +148,7 @@ public:
// Return of a negative value means an error has occurred:
// * INVALID_OPERATION - too many buffers have been acquired
virtual status_t acquireBuffer(BufferItem* buffer, nsecs_t presentWhen) = 0;
virtual status_t acquireBuffer(android::BufferItem* buffer, nsecs_t presentWhen) = 0;
// detachBuffer attempts to remove all ownership of the buffer in the given
// slot from the buffer queue. If this call succeeds, the slot will be
@ -287,6 +293,14 @@ public:
// Return of a value other than NO_ERROR means an unknown error has occurred.
virtual status_t setDefaultBufferFormat(PixelFormat defaultFormat) = 0;
// setDefaultBufferDataSpace is a request to the producer to provide buffers
// of the indicated dataSpace. The producer may ignore this request.
// The initial default is HAL_DATASPACE_UNKNOWN.
//
// Return of a value other than NO_ERROR means an unknown error has occurred.
virtual status_t setDefaultBufferDataSpace(
android_dataspace defaultDataSpace) = 0;
// setConsumerUsageBits will turn on additional usage bits for dequeueBuffer.
// These are merged with the bits passed to dequeueBuffer. The values are
// enumerated in gralloc.h, e.g. GRALLOC_USAGE_HW_RENDER; the default is 0.

View File

@ -265,6 +265,7 @@ public:
inline QueueBufferInput(const Parcel& parcel);
// timestamp - a monotonically increasing value in nanoseconds
// isAutoTimestamp - if the timestamp was synthesized at queue time
// dataSpace - description of the contents, interpretation depends on format
// crop - a crop rectangle that's used as a hint to the consumer
// scalingMode - a set of flags from NATIVE_WINDOW_SCALING_* in <window.h>
// transform - a set of flags from NATIVE_WINDOW_TRANSFORM_* in <window.h>
@ -274,17 +275,21 @@ public:
// sticky - the sticky transform set in Surface (only used by the LEGACY
// camera mode).
inline QueueBufferInput(int64_t timestamp, bool isAutoTimestamp,
const Rect& crop, int scalingMode, uint32_t transform, bool async,
const sp<Fence>& fence, uint32_t sticky = 0)
: timestamp(timestamp), isAutoTimestamp(isAutoTimestamp), crop(crop),
scalingMode(scalingMode), transform(transform), stickyTransform(sticky),
async(async), fence(fence) { }
android_dataspace dataSpace, const Rect& crop, int scalingMode,
uint32_t transform, bool async, const sp<Fence>& fence,
uint32_t sticky = 0)
: timestamp(timestamp), isAutoTimestamp(isAutoTimestamp),
dataSpace(dataSpace), crop(crop), scalingMode(scalingMode),
transform(transform), stickyTransform(sticky),
async(async), fence(fence) { }
inline void deflate(int64_t* outTimestamp, bool* outIsAutoTimestamp,
Rect* outCrop, int* outScalingMode, uint32_t* outTransform,
bool* outAsync, sp<Fence>* outFence,
android_dataspace* outDataSpace,
Rect* outCrop, int* outScalingMode,
uint32_t* outTransform, bool* outAsync, sp<Fence>* outFence,
uint32_t* outStickyTransform = NULL) const {
*outTimestamp = timestamp;
*outIsAutoTimestamp = bool(isAutoTimestamp);
*outDataSpace = dataSpace;
*outCrop = crop;
*outScalingMode = scalingMode;
*outTransform = transform;
@ -304,6 +309,7 @@ public:
private:
int64_t timestamp;
int isAutoTimestamp;
android_dataspace dataSpace;
Rect crop;
int scalingMode;
uint32_t transform;

View File

@ -146,6 +146,7 @@ private:
int dispatchLock(va_list args);
int dispatchUnlockAndPost(va_list args);
int dispatchSetSidebandStream(va_list args);
int dispatchSetBuffersDataSpace(va_list args);
protected:
virtual int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd);
@ -168,6 +169,7 @@ protected:
virtual int setBuffersTransform(uint32_t transform);
virtual int setBuffersStickyTransform(uint32_t transform);
virtual int setBuffersTimestamp(int64_t timestamp);
virtual int setBuffersDataSpace(android_dataspace dataSpace);
virtual int setCrop(Rect const* rect);
virtual int setUsage(uint32_t reqUsage);
@ -223,6 +225,11 @@ private:
// a timestamp is auto-generated when queueBuffer is called.
int64_t mTimestamp;
// mDataSpace is the buffer dataSpace that will be used for the next buffer
// queue operation. It defaults to HAL_DATASPACE_UNKNOWN, which
// means that the buffer contains some type of color data.
android_dataspace mDataSpace;
// mCrop is the crop rectangle that will be used for the next buffer
// that gets queued. It is set by calling setCrop.
Rect mCrop;

View File

@ -60,8 +60,6 @@ enum {
PIXEL_FORMAT_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888, // 4x8-bit BGRA
PIXEL_FORMAT_RGBA_5551 = 6, // 16-bit ARGB
PIXEL_FORMAT_RGBA_4444 = 7, // 16-bit ARGB
PIXEL_FORMAT_sRGB_A_8888 = HAL_PIXEL_FORMAT_sRGB_A_8888, // 4x8-bit sRGB + A
PIXEL_FORMAT_sRGB_X_8888 = HAL_PIXEL_FORMAT_sRGB_X_8888, // 4x8-bit sRGB, no A
};
typedef int32_t PixelFormat;

View File

@ -28,6 +28,7 @@ BufferItem::BufferItem() :
mScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
mTimestamp(0),
mIsAutoTimestamp(false),
mDataSpace(HAL_DATASPACE_UNKNOWN),
mFrameNumber(0),
mSlot(INVALID_BUFFER_SLOT),
mIsDroppable(false),
@ -36,6 +37,21 @@ BufferItem::BufferItem() :
mCrop.makeInvalid();
}
BufferItem::BufferItem(const IGraphicBufferConsumer::BufferItem& item) :
mGraphicBuffer(item.mGraphicBuffer),
mFence(item.mFence),
mCrop(item.mCrop),
mTransform(item.mTransform),
mScalingMode(item.mScalingMode),
mTimestamp(item.mTimestamp),
mIsAutoTimestamp(item.mIsAutoTimestamp),
mDataSpace(item.mDataSpace),
mFrameNumber(item.mFrameNumber),
mSlot(item.mBuf),
mIsDroppable(item.mIsDroppable),
mAcquireCalled(item.mAcquireCalled),
mTransformToDisplayInverse(item.mTransformToDisplayInverse) {}
BufferItem::~BufferItem() {}
BufferItem::operator IGraphicBufferConsumer::BufferItem() const {
@ -47,6 +63,7 @@ BufferItem::operator IGraphicBufferConsumer::BufferItem() const {
bufferItem.mScalingMode = mScalingMode;
bufferItem.mTimestamp = mTimestamp;
bufferItem.mIsAutoTimestamp = mIsAutoTimestamp;
bufferItem.mDataSpace = mDataSpace;
bufferItem.mFrameNumber = mFrameNumber;
bufferItem.mBuf = mSlot;
bufferItem.mIsDroppable = mIsDroppable;
@ -61,6 +78,7 @@ size_t BufferItem::getPodSize() const {
sizeof(mScalingMode) +
sizeof(mTimestamp) +
sizeof(mIsAutoTimestamp) +
sizeof(mDataSpace) +
sizeof(mFrameNumber) +
sizeof(mSlot) +
sizeof(mIsDroppable) +
@ -131,6 +149,7 @@ status_t BufferItem::flatten(
FlattenableUtils::write(buffer, size, mScalingMode);
FlattenableUtils::write(buffer, size, mTimestamp);
FlattenableUtils::write(buffer, size, mIsAutoTimestamp);
FlattenableUtils::write(buffer, size, mDataSpace);
FlattenableUtils::write(buffer, size, mFrameNumber);
FlattenableUtils::write(buffer, size, mSlot);
FlattenableUtils::write(buffer, size, mIsDroppable);
@ -173,6 +192,7 @@ status_t BufferItem::unflatten(
FlattenableUtils::read(buffer, size, mScalingMode);
FlattenableUtils::read(buffer, size, mTimestamp);
FlattenableUtils::read(buffer, size, mIsAutoTimestamp);
FlattenableUtils::read(buffer, size, mDataSpace);
FlattenableUtils::read(buffer, size, mFrameNumber);
FlattenableUtils::read(buffer, size, mSlot);
FlattenableUtils::read(buffer, size, mIsDroppable);

View File

@ -19,6 +19,7 @@
//#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__)
@ -52,7 +53,7 @@ void BufferItemConsumer::setName(const String8& name) {
mConsumer->setConsumerName(name);
}
status_t BufferItemConsumer::acquireBuffer(BufferItem *item,
status_t BufferItemConsumer::acquireBuffer(BufferQueue::BufferItem *item,
nsecs_t presentWhen, bool waitForFence) {
status_t err;
@ -82,6 +83,17 @@ status_t BufferItemConsumer::acquireBuffer(BufferItem *item,
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;
@ -109,4 +121,10 @@ status_t BufferItemConsumer::setDefaultBufferFormat(PixelFormat defaultFormat) {
return mConsumer->setDefaultBufferFormat(defaultFormat);
}
status_t BufferItemConsumer::setDefaultBufferDataSpace(
android_dataspace defaultDataSpace) {
Mutex::Autolock _l(mMutex);
return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
}
} // namespace android

View File

@ -176,6 +176,22 @@ status_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
return NO_ERROR;
}
status_t BufferQueueConsumer::acquireBuffer(android::BufferItem* outBuffer,
nsecs_t expectedPresent) {
if (outBuffer == nullptr) {
return BAD_VALUE;
}
BufferItem item;
status_t result = acquireBuffer(&item, expectedPresent);
if (result != NO_ERROR) {
return result;
}
*outBuffer = item;
return NO_ERROR;
}
status_t BufferQueueConsumer::detachBuffer(int slot) {
ATRACE_CALL();
ATRACE_BUFFER_INDEX(slot);
@ -496,6 +512,15 @@ status_t BufferQueueConsumer::setDefaultBufferFormat(PixelFormat defaultFormat)
return NO_ERROR;
}
status_t BufferQueueConsumer::setDefaultBufferDataSpace(
android_dataspace defaultDataSpace) {
ATRACE_CALL();
BQ_LOGV("setDefaultBufferDataSpace: %u", defaultDataSpace);
Mutex::Autolock lock(mCore->mMutex);
mCore->mDefaultBufferDataSpace = defaultDataSpace;
return NO_ERROR;
}
status_t BufferQueueConsumer::setConsumerUsageBits(uint32_t usage) {
ATRACE_CALL();
BQ_LOGV("setConsumerUsageBits: %#x", usage);

View File

@ -60,6 +60,7 @@ BufferQueueCore::BufferQueueCore(const sp<IGraphicBufferAlloc>& allocator) :
mDefaultBufferFormat(PIXEL_FORMAT_RGBA_8888),
mDefaultWidth(1),
mDefaultHeight(1),
mDefaultBufferDataSpace(HAL_DATASPACE_UNKNOWN),
mDefaultMaxBufferCount(2),
mMaxAcquiredBufferCount(1),
mBufferHasBeenQueued(false),

View File

@ -516,14 +516,15 @@ status_t BufferQueueProducer::queueBuffer(int slot,
int64_t timestamp;
bool isAutoTimestamp;
android_dataspace dataSpace;
Rect crop;
int scalingMode;
uint32_t transform;
uint32_t stickyTransform;
bool async;
sp<Fence> fence;
input.deflate(&timestamp, &isAutoTimestamp, &crop, &scalingMode, &transform,
&async, &fence, &stickyTransform);
input.deflate(&timestamp, &isAutoTimestamp, &dataSpace, &crop, &scalingMode,
&transform, &async, &fence, &stickyTransform);
if (fence == NULL) {
BQ_LOGE("queueBuffer: fence is NULL");
@ -579,9 +580,9 @@ status_t BufferQueueProducer::queueBuffer(int slot,
return BAD_VALUE;
}
BQ_LOGV("queueBuffer: slot=%d/%" PRIu64 " time=%" PRIu64
BQ_LOGV("queueBuffer: slot=%d/%" PRIu64 " time=%" PRIu64 " dataSpace=%d"
" crop=[%d,%d,%d,%d] transform=%#x scale=%s",
slot, mCore->mFrameCounter + 1, timestamp,
slot, mCore->mFrameCounter + 1, timestamp, dataSpace,
crop.left, crop.top, crop.right, crop.bottom, transform,
BufferItem::scalingModeName(static_cast<uint32_t>(scalingMode)));
@ -595,6 +596,11 @@ status_t BufferQueueProducer::queueBuffer(int slot,
return BAD_VALUE;
}
// Override UNKNOWN dataspace with consumer default
if (dataSpace == HAL_DATASPACE_UNKNOWN) {
dataSpace = mCore->mDefaultBufferDataSpace;
}
mSlots[slot].mFence = fence;
mSlots[slot].mBufferState = BufferSlot::QUEUED;
++mCore->mFrameCounter;
@ -610,6 +616,7 @@ status_t BufferQueueProducer::queueBuffer(int slot,
item.mScalingMode = static_cast<uint32_t>(scalingMode);
item.mTimestamp = timestamp;
item.mIsAutoTimestamp = isAutoTimestamp;
item.mDataSpace = dataSpace;
item.mFrameNumber = mCore->mFrameCounter;
item.mSlot = slot;
item.mFence = fence;
@ -758,6 +765,9 @@ int BufferQueueProducer::query(int what, int *outValue) {
case NATIVE_WINDOW_CONSUMER_USAGE_BITS:
value = static_cast<int32_t>(mCore->mConsumerUsageBits);
break;
case NATIVE_WINDOW_DEFAULT_DATASPACE:
value = static_cast<int32_t>(mCore->mDefaultBufferDataSpace);
break;
default:
return BAD_VALUE;
}

View File

@ -27,6 +27,7 @@
#include <hardware/hardware.h>
#include <gui/BufferItem.h>
#include <gui/IGraphicBufferAlloc.h>
#include <gui/ISurfaceComposer.h>
#include <gui/SurfaceComposerClient.h>
@ -179,7 +180,7 @@ void ConsumerBase::dumpLocked(String8& result, const char* prefix) const {
}
}
status_t ConsumerBase::acquireBufferLocked(BufferQueue::BufferItem *item,
status_t ConsumerBase::acquireBufferLocked(BufferItem *item,
nsecs_t presentWhen) {
status_t err = mConsumer->acquireBuffer(item, presentWhen);
if (err != NO_ERROR) {
@ -199,6 +200,17 @@ status_t ConsumerBase::acquireBufferLocked(BufferQueue::BufferItem *item,
return OK;
}
status_t ConsumerBase::acquireBufferLocked(BufferQueue::BufferItem *outItem,
nsecs_t presentWhen) {
BufferItem item;
status_t result = acquireBufferLocked(&item, presentWhen);
if (result != NO_ERROR) {
return result;
}
*outItem = item;
return NO_ERROR;
}
status_t ConsumerBase::addReleaseFence(int slot,
const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
Mutex::Autolock lock(mMutex);

View File

@ -20,6 +20,7 @@
#include <cutils/compiler.h>
#include <utils/Log.h>
#include <gui/BufferItem.h>
#include <gui/CpuConsumer.h>
#define CC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
@ -67,6 +68,13 @@ status_t CpuConsumer::setDefaultBufferFormat(PixelFormat defaultFormat)
return mConsumer->setDefaultBufferFormat(defaultFormat);
}
status_t CpuConsumer::setDefaultBufferDataSpace(
android_dataspace defaultDataSpace)
{
Mutex::Autolock _l(mMutex);
return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
}
static bool isPossiblyYUV(PixelFormat format) {
switch (static_cast<int>(format)) {
case HAL_PIXEL_FORMAT_RGBA_8888:
@ -74,11 +82,9 @@ static bool isPossiblyYUV(PixelFormat format) {
case HAL_PIXEL_FORMAT_RGB_888:
case HAL_PIXEL_FORMAT_RGB_565:
case HAL_PIXEL_FORMAT_BGRA_8888:
case HAL_PIXEL_FORMAT_sRGB_A_8888:
case HAL_PIXEL_FORMAT_sRGB_X_8888:
case HAL_PIXEL_FORMAT_Y8:
case HAL_PIXEL_FORMAT_Y16:
case HAL_PIXEL_FORMAT_RAW16: // same as HAL_PIXEL_FORMAT_RAW_SENSOR
case HAL_PIXEL_FORMAT_RAW16:
case HAL_PIXEL_FORMAT_RAW10:
case HAL_PIXEL_FORMAT_RAW_OPAQUE:
case HAL_PIXEL_FORMAT_BLOB:
@ -105,7 +111,7 @@ status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {
return NOT_ENOUGH_DATA;
}
BufferQueue::BufferItem b;
BufferItem b;
Mutex::Autolock _l(mMutex);
@ -200,6 +206,7 @@ status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {
nativeBuffer->transform = b.mTransform;
nativeBuffer->scalingMode = b.mScalingMode;
nativeBuffer->timestamp = b.mTimestamp;
nativeBuffer->dataSpace = b.mDataSpace;
nativeBuffer->frameNumber = b.mFrameNumber;
nativeBuffer->dataCb = reinterpret_cast<uint8_t*>(ycbcr.cb);

View File

@ -29,6 +29,7 @@
#include <hardware/hardware.h>
#include <gui/BufferItem.h>
#include <gui/GLConsumer.h>
#include <gui/IGraphicBufferAlloc.h>
#include <gui/ISurfaceComposer.h>
@ -210,7 +211,7 @@ status_t GLConsumer::updateTexImage() {
return err;
}
BufferQueue::BufferItem item;
BufferItem item;
// Acquire the next buffer.
// In asynchronous mode the list is guaranteed to be one buffer
@ -342,7 +343,7 @@ sp<GraphicBuffer> GLConsumer::getDebugTexImageBuffer() {
return sReleasedTexImageBuffer;
}
status_t GLConsumer::acquireBufferLocked(BufferQueue::BufferItem *item,
status_t GLConsumer::acquireBufferLocked(BufferItem *item,
nsecs_t presentWhen) {
status_t err = ConsumerBase::acquireBufferLocked(item, presentWhen);
if (err != NO_ERROR) {
@ -360,6 +361,17 @@ status_t GLConsumer::acquireBufferLocked(BufferQueue::BufferItem *item,
return NO_ERROR;
}
status_t GLConsumer::acquireBufferLocked(BufferQueue::BufferItem *outItem,
nsecs_t presentWhen) {
BufferItem item;
status_t result = acquireBufferLocked(&item, presentWhen);
if (result != NO_ERROR) {
return result;
}
*outItem = item;
return NO_ERROR;
}
status_t GLConsumer::releaseBufferLocked(int buf,
sp<GraphicBuffer> graphicBuffer,
EGLDisplay display, EGLSyncKHR eglFence) {
@ -1023,6 +1035,12 @@ status_t GLConsumer::setDefaultBufferFormat(PixelFormat defaultFormat) {
return mConsumer->setDefaultBufferFormat(defaultFormat);
}
status_t GLConsumer::setDefaultBufferDataSpace(
android_dataspace defaultDataSpace) {
Mutex::Autolock lock(mMutex);
return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
}
status_t GLConsumer::setConsumerUsageBits(uint32_t usage) {
Mutex::Autolock lock(mMutex);
usage |= DEFAULT_USAGE_FLAGS;

View File

@ -23,6 +23,7 @@
#include <binder/Parcel.h>
#include <binder/IInterface.h>
#include <gui/BufferItem.h>
#include <gui/IConsumerListener.h>
#include <gui/IGraphicBufferConsumer.h>
@ -39,6 +40,7 @@ IGraphicBufferConsumer::BufferItem::BufferItem() :
mScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
mTimestamp(0),
mIsAutoTimestamp(false),
mDataSpace(HAL_DATASPACE_UNKNOWN),
mFrameNumber(0),
mBuf(INVALID_BUFFER_SLOT),
mIsDroppable(false),
@ -53,6 +55,7 @@ size_t IGraphicBufferConsumer::BufferItem::getPodSize() const {
sizeof(mScalingMode) +
sizeof(mTimestamp) +
sizeof(mIsAutoTimestamp) +
sizeof(mDataSpace) +
sizeof(mFrameNumber) +
sizeof(mBuf) +
sizeof(mIsDroppable) +
@ -133,6 +136,7 @@ status_t IGraphicBufferConsumer::BufferItem::flatten(
FlattenableUtils::write(buffer, size, mScalingMode);
FlattenableUtils::write(buffer, size, mTimestamp);
writeBoolAsInt(buffer, size, mIsAutoTimestamp);
FlattenableUtils::write(buffer, size, mDataSpace);
FlattenableUtils::write(buffer, size, mFrameNumber);
FlattenableUtils::write(buffer, size, mBuf);
writeBoolAsInt(buffer, size, mIsDroppable);
@ -175,6 +179,7 @@ status_t IGraphicBufferConsumer::BufferItem::unflatten(
FlattenableUtils::read(buffer, size, mScalingMode);
FlattenableUtils::read(buffer, size, mTimestamp);
mIsAutoTimestamp = readBoolFromInt(buffer, size);
FlattenableUtils::read(buffer, size, mDataSpace);
FlattenableUtils::read(buffer, size, mFrameNumber);
FlattenableUtils::read(buffer, size, mBuf);
mIsDroppable = readBoolFromInt(buffer, size);
@ -200,6 +205,7 @@ enum {
SET_MAX_ACQUIRED_BUFFER_COUNT,
SET_CONSUMER_NAME,
SET_DEFAULT_BUFFER_FORMAT,
SET_DEFAULT_BUFFER_DATA_SPACE,
SET_CONSUMER_USAGE_BITS,
SET_TRANSFORM_HINT,
GET_SIDEBAND_STREAM,
@ -232,6 +238,21 @@ public:
return reply.readInt32();
}
virtual status_t acquireBuffer(android::BufferItem* buffer,
nsecs_t presentWhen) {
if (buffer == nullptr) {
return BAD_VALUE;
}
BufferItem item;
status_t result = acquireBuffer(&item, presentWhen);
if (result != NO_ERROR) {
return result;
}
*buffer = item;
return NO_ERROR;
}
virtual status_t detachBuffer(int slot) {
Parcel data, reply;
data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
@ -371,6 +392,19 @@ public:
return reply.readInt32();
}
virtual status_t setDefaultBufferDataSpace(
android_dataspace defaultDataSpace) {
Parcel data, reply;
data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
data.writeInt32(static_cast<int32_t>(defaultDataSpace));
status_t result = remote()->transact(SET_DEFAULT_BUFFER_DATA_SPACE,
data, &reply);
if (result != NO_ERROR) {
return result;
}
return reply.readInt32();
}
virtual status_t setConsumerUsageBits(uint32_t usage) {
Parcel data, reply;
data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
@ -530,6 +564,14 @@ status_t BnGraphicBufferConsumer::onTransact(
reply->writeInt32(result);
return NO_ERROR;
}
case SET_DEFAULT_BUFFER_DATA_SPACE: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
android_dataspace defaultDataSpace =
static_cast<android_dataspace>(data.readInt32());
status_t result = setDefaultBufferDataSpace(defaultDataSpace);
reply->writeInt32(result);
return NO_ERROR;
}
case SET_CONSUMER_USAGE_BITS: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t usage = data.readUint32();

View File

@ -440,6 +440,7 @@ IGraphicBufferProducer::QueueBufferInput::QueueBufferInput(const Parcel& parcel)
size_t IGraphicBufferProducer::QueueBufferInput::getFlattenedSize() const {
return sizeof(timestamp)
+ sizeof(isAutoTimestamp)
+ sizeof(dataSpace)
+ sizeof(crop)
+ sizeof(scalingMode)
+ sizeof(transform)
@ -460,6 +461,7 @@ status_t IGraphicBufferProducer::QueueBufferInput::flatten(
}
FlattenableUtils::write(buffer, size, timestamp);
FlattenableUtils::write(buffer, size, isAutoTimestamp);
FlattenableUtils::write(buffer, size, dataSpace);
FlattenableUtils::write(buffer, size, crop);
FlattenableUtils::write(buffer, size, scalingMode);
FlattenableUtils::write(buffer, size, transform);
@ -474,6 +476,7 @@ status_t IGraphicBufferProducer::QueueBufferInput::unflatten(
size_t minNeeded =
sizeof(timestamp)
+ sizeof(isAutoTimestamp)
+ sizeof(dataSpace)
+ sizeof(crop)
+ sizeof(scalingMode)
+ sizeof(transform)
@ -486,6 +489,7 @@ status_t IGraphicBufferProducer::QueueBufferInput::unflatten(
FlattenableUtils::read(buffer, size, timestamp);
FlattenableUtils::read(buffer, size, isAutoTimestamp);
FlattenableUtils::read(buffer, size, dataSpace);
FlattenableUtils::read(buffer, size, crop);
FlattenableUtils::read(buffer, size, scalingMode);
FlattenableUtils::read(buffer, size, transform);

View File

@ -20,6 +20,7 @@
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
//#define LOG_NDEBUG 0
#include <gui/BufferItem.h>
#include <gui/IGraphicBufferConsumer.h>
#include <gui/IGraphicBufferProducer.h>
#include <gui/StreamSplitter.h>
@ -123,7 +124,7 @@ void StreamSplitter::onFrameAvailable(const BufferItem& /* item */) {
++mOutstandingBuffers;
// Acquire and detach the buffer from the input
IGraphicBufferConsumer::BufferItem bufferItem;
BufferItem bufferItem;
status_t status = mInput->acquireBuffer(&bufferItem, /* presentWhen */ 0);
LOG_ALWAYS_FATAL_IF(status != NO_ERROR,
"acquiring buffer from input failed (%d)", status);
@ -141,7 +142,8 @@ void StreamSplitter::onFrameAvailable(const BufferItem& /* item */) {
IGraphicBufferProducer::QueueBufferInput queueInput(
bufferItem.mTimestamp, bufferItem.mIsAutoTimestamp,
bufferItem.mCrop, static_cast<int32_t>(bufferItem.mScalingMode),
bufferItem.mDataSpace, bufferItem.mCrop,
static_cast<int32_t>(bufferItem.mScalingMode),
bufferItem.mTransform, bufferItem.mIsDroppable,
bufferItem.mFence);

View File

@ -64,6 +64,7 @@ Surface::Surface(
mReqFormat = 0;
mReqUsage = 0;
mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
mDataSpace = HAL_DATASPACE_UNKNOWN;
mCrop.clear();
mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE;
mTransform = 0;
@ -317,8 +318,8 @@ int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) {
sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE);
IGraphicBufferProducer::QueueBufferOutput output;
IGraphicBufferProducer::QueueBufferInput input(timestamp, isAutoTimestamp,
crop, mScalingMode, mTransform ^ mStickyTransform, mSwapIntervalZero,
fence, mStickyTransform);
mDataSpace, crop, mScalingMode, mTransform ^ mStickyTransform,
mSwapIntervalZero, fence, mStickyTransform);
status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output);
if (err != OK) {
ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err);
@ -449,6 +450,9 @@ int Surface::perform(int operation, va_list args)
case NATIVE_WINDOW_SET_SIDEBAND_STREAM:
res = dispatchSetSidebandStream(args);
break;
case NATIVE_WINDOW_SET_BUFFERS_DATASPACE:
res = dispatchSetBuffersDataSpace(args);
break;
default:
res = NAME_NOT_FOUND;
break;
@ -546,6 +550,12 @@ int Surface::dispatchSetSidebandStream(va_list args) {
return OK;
}
int Surface::dispatchSetBuffersDataSpace(va_list args) {
android_dataspace dataspace =
static_cast<android_dataspace>(va_arg(args, int));
return setBuffersDataSpace(dataspace);
}
int Surface::connect(int api) {
static sp<IProducerListener> listener = new DummyProducerListener();
return connect(api, listener);
@ -727,6 +737,14 @@ int Surface::setBuffersTimestamp(int64_t timestamp)
return NO_ERROR;
}
int Surface::setBuffersDataSpace(android_dataspace dataSpace)
{
ALOGV("Surface::setBuffersDataSpace");
Mutex::Autolock lock(mMutex);
mDataSpace = dataSpace;
return NO_ERROR;
}
void Surface::freeAllBuffers() {
for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
mSlots[i].buffer = 0;

View File

@ -17,6 +17,7 @@
#define LOG_TAG "BufferQueue_test"
//#define LOG_NDEBUG 0
#include <gui/BufferItem.h>
#include <gui/BufferQueue.h>
#include <gui/IProducerListener.h>
@ -124,11 +125,12 @@ TEST_F(BufferQueueTest, BufferQueueInAnotherProcess) {
*dataIn = 0x12345678;
ASSERT_EQ(OK, buffer->unlock());
IGraphicBufferProducer::QueueBufferInput input(0, false, Rect(0, 0, 1, 1),
IGraphicBufferProducer::QueueBufferInput input(0, false,
HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
IGraphicBufferConsumer::BufferItem item;
BufferItem item;
ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
uint32_t* dataOut;
@ -150,9 +152,10 @@ TEST_F(BufferQueueTest, AcquireBuffer_ExceedsMaxAcquireCount_Fails) {
int slot;
sp<Fence> fence;
sp<GraphicBuffer> buf;
IGraphicBufferProducer::QueueBufferInput qbi(0, false, Rect(0, 0, 1, 1),
IGraphicBufferProducer::QueueBufferInput qbi(0, false,
HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
BufferQueue::BufferItem item;
BufferItem item;
for (int i = 0; i < 2; i++) {
ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
@ -244,11 +247,12 @@ TEST_F(BufferQueueTest, DetachAndReattachOnProducerSide) {
ASSERT_EQ(BAD_VALUE, mProducer->attachBuffer(&newSlot, NULL));
ASSERT_EQ(OK, mProducer->attachBuffer(&newSlot, buffer));
IGraphicBufferProducer::QueueBufferInput input(0, false, Rect(0, 0, 1, 1),
IGraphicBufferProducer::QueueBufferInput input(0, false,
HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
ASSERT_EQ(OK, mProducer->queueBuffer(newSlot, input, &output));
IGraphicBufferConsumer::BufferItem item;
BufferItem item;
ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, static_cast<nsecs_t>(0)));
uint32_t* dataOut;
@ -273,7 +277,8 @@ TEST_F(BufferQueueTest, DetachAndReattachOnConsumerSide) {
mProducer->dequeueBuffer(&slot, &fence, false, 0, 0, 0,
GRALLOC_USAGE_SW_WRITE_OFTEN));
ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));
IGraphicBufferProducer::QueueBufferInput input(0, false, Rect(0, 0, 1, 1),
IGraphicBufferProducer::QueueBufferInput input(0, false,
HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
@ -282,7 +287,7 @@ TEST_F(BufferQueueTest, DetachAndReattachOnConsumerSide) {
BufferQueueDefs::NUM_BUFFER_SLOTS)); // Index too high
ASSERT_EQ(BAD_VALUE, mConsumer->detachBuffer(0)); // Not acquired
IGraphicBufferConsumer::BufferItem item;
BufferItem item;
ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, static_cast<nsecs_t>(0)));
ASSERT_EQ(OK, mConsumer->detachBuffer(item.mBuf));
@ -338,11 +343,12 @@ TEST_F(BufferQueueTest, MoveFromConsumerToProducer) {
*dataIn = 0x12345678;
ASSERT_EQ(OK, buffer->unlock());
IGraphicBufferProducer::QueueBufferInput input(0, false, Rect(0, 0, 1, 1),
IGraphicBufferProducer::QueueBufferInput input(0, false,
HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
IGraphicBufferConsumer::BufferItem item;
BufferItem item;
ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, static_cast<nsecs_t>(0)));
ASSERT_EQ(OK, mConsumer->detachBuffer(item.mBuf));

View File

@ -166,7 +166,7 @@ void checkPixel(const CpuConsumer::LockedBuffer &buf,
uint32_t x, uint32_t y, uint32_t r, uint32_t g=0, uint32_t b=0) {
// Ignores components that don't exist for given pixel
switch(buf.format) {
case HAL_PIXEL_FORMAT_RAW_SENSOR: {
case HAL_PIXEL_FORMAT_RAW16: {
String8 msg;
uint16_t *bPtr = (uint16_t*)buf.data;
bPtr += y * buf.stride + x;
@ -429,7 +429,7 @@ void checkBayerRawBuffer(const CpuConsumer::LockedBuffer &buf) {
void checkAnyBuffer(const CpuConsumer::LockedBuffer &buf, int format) {
switch (format) {
case HAL_PIXEL_FORMAT_RAW_SENSOR:
case HAL_PIXEL_FORMAT_RAW16:
checkBayerRawBuffer(buf);
break;
case HAL_PIXEL_FORMAT_Y8:
@ -505,7 +505,7 @@ void produceOneFrame(const sp<ANativeWindow>& anw,
case HAL_PIXEL_FORMAT_YV12:
fillYV12Buffer(img, params.width, params.height, *stride);
break;
case HAL_PIXEL_FORMAT_RAW_SENSOR:
case HAL_PIXEL_FORMAT_RAW16:
fillBayerRawBuffer(img, params.width, params.height, buf->getStride());
break;
case HAL_PIXEL_FORMAT_Y8:
@ -537,7 +537,7 @@ void produceOneFrame(const sp<ANativeWindow>& anw,
ASSERT_NO_ERROR(err, "queueBuffer error:");
};
// This test is disabled because the HAL_PIXEL_FORMAT_RAW_SENSOR format is not
// This test is disabled because the HAL_PIXEL_FORMAT_RAW16 format is not
// supported on all devices.
TEST_P(CpuConsumerTest, FromCpuSingle) {
status_t err;
@ -571,7 +571,7 @@ TEST_P(CpuConsumerTest, FromCpuSingle) {
mCC->unlockBuffer(b);
}
// This test is disabled because the HAL_PIXEL_FORMAT_RAW_SENSOR format is not
// This test is disabled because the HAL_PIXEL_FORMAT_RAW16 format is not
// supported on all devices.
TEST_P(CpuConsumerTest, FromCpuManyInQueue) {
status_t err;
@ -614,7 +614,7 @@ TEST_P(CpuConsumerTest, FromCpuManyInQueue) {
}
}
// This test is disabled because the HAL_PIXEL_FORMAT_RAW_SENSOR format is not
// This test is disabled because the HAL_PIXEL_FORMAT_RAW16 format is not
// supported on all devices.
TEST_P(CpuConsumerTest, FromCpuLockMax) {
status_t err;
@ -710,12 +710,12 @@ CpuConsumerTestParams y16TestSets[] = {
};
CpuConsumerTestParams rawTestSets[] = {
{ 512, 512, 1, HAL_PIXEL_FORMAT_RAW_SENSOR},
{ 512, 512, 3, HAL_PIXEL_FORMAT_RAW_SENSOR},
{ 2608, 1960, 1, HAL_PIXEL_FORMAT_RAW_SENSOR},
{ 2608, 1960, 3, HAL_PIXEL_FORMAT_RAW_SENSOR},
{ 100, 100, 1, HAL_PIXEL_FORMAT_RAW_SENSOR},
{ 100, 100, 3, HAL_PIXEL_FORMAT_RAW_SENSOR},
{ 512, 512, 1, HAL_PIXEL_FORMAT_RAW16},
{ 512, 512, 3, HAL_PIXEL_FORMAT_RAW16},
{ 2608, 1960, 1, HAL_PIXEL_FORMAT_RAW16},
{ 2608, 1960, 3, HAL_PIXEL_FORMAT_RAW16},
{ 100, 100, 1, HAL_PIXEL_FORMAT_RAW16},
{ 100, 100, 3, HAL_PIXEL_FORMAT_RAW16},
};
CpuConsumerTestParams rgba8888TestSets[] = {

View File

@ -57,6 +57,7 @@ namespace {
// Parameters for a generic "valid" input for queueBuffer.
const int64_t QUEUE_BUFFER_INPUT_TIMESTAMP = 1384888611;
const bool QUEUE_BUFFER_INPUT_IS_AUTO_TIMESTAMP = false;
const android_dataspace QUEUE_BUFFER_INPUT_DATASPACE = HAL_DATASPACE_UNKNOWN;
const Rect QUEUE_BUFFER_INPUT_RECT = Rect(DEFAULT_WIDTH, DEFAULT_HEIGHT);
const int QUEUE_BUFFER_INPUT_SCALING_MODE = 0;
const int QUEUE_BUFFER_INPUT_TRANSFORM = 0;
@ -126,6 +127,7 @@ protected:
QueueBufferInputBuilder() {
timestamp = QUEUE_BUFFER_INPUT_TIMESTAMP;
isAutoTimestamp = QUEUE_BUFFER_INPUT_IS_AUTO_TIMESTAMP;
dataSpace = QUEUE_BUFFER_INPUT_DATASPACE;
crop = QUEUE_BUFFER_INPUT_RECT;
scalingMode = QUEUE_BUFFER_INPUT_SCALING_MODE;
transform = QUEUE_BUFFER_INPUT_TRANSFORM;
@ -137,6 +139,7 @@ protected:
return IGraphicBufferProducer::QueueBufferInput(
timestamp,
isAutoTimestamp,
dataSpace,
crop,
scalingMode,
transform,
@ -154,6 +157,11 @@ protected:
return *this;
}
QueueBufferInputBuilder& setDataSpace(android_dataspace dataSpace) {
this->dataSpace = dataSpace;
return *this;
}
QueueBufferInputBuilder& setCrop(Rect crop) {
this->crop = crop;
return *this;
@ -182,6 +190,7 @@ protected:
private:
int64_t timestamp;
bool isAutoTimestamp;
android_dataspace dataSpace;
Rect crop;
int scalingMode;
uint32_t transform;

View File

@ -214,10 +214,11 @@ protected:
ASSERT_EQ(GL_NO_ERROR, glGetError());
}
void checkLockedBuffer(PixelFormat format) {
void checkLockedBuffer(PixelFormat format, android_dataspace dataSpace) {
ASSERT_EQ(mLockedBuffer.format, format);
ASSERT_EQ(mLockedBuffer.width, DISPLAY_WIDTH);
ASSERT_EQ(mLockedBuffer.height, DISPLAY_HEIGHT);
ASSERT_EQ(mLockedBuffer.dataSpace, dataSpace);
}
static bool withinTolerance(int a, int b) {
@ -335,7 +336,8 @@ private:
if (mLockedBuffer.format == outBuffer.format) {
memcpy(outBuffer.bits, mLockedBuffer.data, bufferSize);
} else {
ASSERT_EQ(mLockedBuffer.format, PIXEL_FORMAT_sRGB_A_8888);
ASSERT_EQ(mLockedBuffer.format, PIXEL_FORMAT_RGBA_8888);
ASSERT_EQ(mLockedBuffer.dataSpace, HAL_DATASPACE_SRGB);
ASSERT_EQ(outBuffer.format, PIXEL_FORMAT_RGBA_8888);
uint8_t* outPointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
for (int y = 0; y < outBuffer.height; ++y) {
@ -380,7 +382,8 @@ TEST_F(SRGBTest, GLRenderFromSRGBTexture) {
// Lock
ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_RGBA_8888));
ASSERT_NO_FATAL_FAILURE(
checkLockedBuffer(PIXEL_FORMAT_RGBA_8888, HAL_DATASPACE_UNKNOWN));
// Compare a pixel in the middle of each texture
int midSRGBOffset = (DISPLAY_HEIGHT / 4) * mLockedBuffer.stride *
@ -411,7 +414,8 @@ TEST_F(SRGBTest, RenderToSRGBSurface) {
// Lock
ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_RGBA_8888));
ASSERT_NO_FATAL_FAILURE(
checkLockedBuffer(PIXEL_FORMAT_RGBA_8888, HAL_DATASPACE_UNKNOWN));
// Save the values of the middle pixel for later comparison against SRGB
uint8_t values[PIXEL_SIZE] = {};
@ -460,7 +464,8 @@ TEST_F(SRGBTest, RenderToSRGBSurface) {
ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
// Make sure we actually got the SRGB buffer on the consumer side
ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_sRGB_A_8888));
ASSERT_NO_FATAL_FAILURE(
checkLockedBuffer(PIXEL_FORMAT_RGBA_8888, HAL_DATASPACE_SRGB));
// Verify that the stored value is the same, accounting for RGB/SRGB
for (int c = 0; c < PIXEL_SIZE; ++c) {

View File

@ -17,6 +17,7 @@
#define LOG_TAG "StreamSplitter_test"
//#define LOG_NDEBUG 0
#include <gui/BufferItem.h>
#include <gui/BufferQueue.h>
#include <gui/IConsumerListener.h>
#include <gui/ISurfaceComposer.h>
@ -111,11 +112,12 @@ TEST_F(StreamSplitterTest, OneInputOneOutput) {
ASSERT_EQ(OK, buffer->unlock());
IGraphicBufferProducer::QueueBufferInput qbInput(0, false,
HAL_DATASPACE_UNKNOWN,
Rect(0, 0, 1, 1), NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false,
Fence::NO_FENCE);
ASSERT_EQ(OK, inputProducer->queueBuffer(slot, qbInput, &qbOutput));
IGraphicBufferConsumer::BufferItem item;
BufferItem item;
ASSERT_EQ(OK, outputConsumer->acquireBuffer(&item, 0));
uint32_t* dataOut;
@ -177,12 +179,13 @@ TEST_F(StreamSplitterTest, OneInputMultipleOutputs) {
ASSERT_EQ(OK, buffer->unlock());
IGraphicBufferProducer::QueueBufferInput qbInput(0, false,
HAL_DATASPACE_UNKNOWN,
Rect(0, 0, 1, 1), NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false,
Fence::NO_FENCE);
ASSERT_EQ(OK, inputProducer->queueBuffer(slot, qbInput, &qbOutput));
for (int output = 0; output < NUM_OUTPUTS; ++output) {
IGraphicBufferConsumer::BufferItem item;
BufferItem item;
ASSERT_EQ(OK, outputConsumers[output]->acquireBuffer(&item, 0));
uint32_t* dataOut;
@ -234,6 +237,7 @@ TEST_F(StreamSplitterTest, OutputAbandonment) {
outputConsumer->consumerDisconnect();
IGraphicBufferProducer::QueueBufferInput qbInput(0, false,
HAL_DATASPACE_UNKNOWN,
Rect(0, 0, 1, 1), NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false,
Fence::NO_FENCE);
ASSERT_EQ(OK, inputProducer->queueBuffer(slot, qbInput, &qbOutput));

View File

@ -155,4 +155,26 @@ TEST_F(SurfaceTest, QueryConsumerUsage) {
ASSERT_EQ(TEST_USAGE_FLAGS, flags);
}
TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
const android_dataspace TEST_DATASPACE = HAL_DATASPACE_SRGB;
sp<IGraphicBufferProducer> producer;
sp<IGraphicBufferConsumer> consumer;
BufferQueue::createBufferQueue(&producer, &consumer);
sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
sp<Surface> s = new Surface(producer);
sp<ANativeWindow> anw(s);
android_dataspace dataSpace;
int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
reinterpret_cast<int*>(&dataSpace));
ASSERT_EQ(NO_ERROR, err);
ASSERT_EQ(TEST_DATASPACE, dataSpace);
}
}

View File

@ -25,8 +25,6 @@ uint32_t bytesPerPixel(PixelFormat format) {
case PIXEL_FORMAT_RGBA_8888:
case PIXEL_FORMAT_RGBX_8888:
case PIXEL_FORMAT_BGRA_8888:
case PIXEL_FORMAT_sRGB_A_8888:
case PIXEL_FORMAT_sRGB_X_8888:
return 4;
case PIXEL_FORMAT_RGB_888:
return 3;
@ -57,4 +55,3 @@ uint32_t bitsPerPixel(PixelFormat format) {
// ----------------------------------------------------------------------------
}; // namespace android
// ----------------------------------------------------------------------------

View File

@ -381,20 +381,15 @@ EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
// Turn linear formats into corresponding sRGB formats when colorspace is
// EGL_GL_COLORSPACE_SRGB_KHR, or turn sRGB formats into corresponding linear
// formats when colorspace is EGL_GL_COLORSPACE_LINEAR_KHR. In any cases where
// the modification isn't possible, the original format is returned.
static int modifyFormatColorspace(int fmt, EGLint colorspace) {
// the modification isn't possible, the original dataSpace is returned.
static android_dataspace modifyBufferDataspace( android_dataspace dataSpace,
EGLint colorspace) {
if (colorspace == EGL_GL_COLORSPACE_LINEAR_KHR) {
switch (fmt) {
case HAL_PIXEL_FORMAT_sRGB_A_8888: return HAL_PIXEL_FORMAT_RGBA_8888;
case HAL_PIXEL_FORMAT_sRGB_X_8888: return HAL_PIXEL_FORMAT_RGBX_8888;
}
return HAL_DATASPACE_SRGB_LINEAR;
} else if (colorspace == EGL_GL_COLORSPACE_SRGB_KHR) {
switch (fmt) {
case HAL_PIXEL_FORMAT_RGBA_8888: return HAL_PIXEL_FORMAT_sRGB_A_8888;
case HAL_PIXEL_FORMAT_RGBX_8888: return HAL_PIXEL_FORMAT_sRGB_X_8888;
}
return HAL_DATASPACE_SRGB;
}
return fmt;
return dataSpace;
}
EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
@ -424,6 +419,7 @@ EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
// by default, just pick RGBA_8888
EGLint format = HAL_PIXEL_FORMAT_RGBA_8888;
android_dataspace dataSpace = HAL_DATASPACE_UNKNOWN;
EGLint a = 0;
cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_ALPHA_SIZE, &a);
@ -449,7 +445,7 @@ EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
for (const EGLint* attr = attrib_list; *attr != EGL_NONE; attr += 2) {
if (*attr == EGL_GL_COLORSPACE_KHR) {
if (ENABLE_EGL_KHR_GL_COLORSPACE) {
format = modifyFormatColorspace(format, *(attr+1));
dataSpace = modifyBufferDataspace(dataSpace, *(attr+1));
} else {
// Normally we'd pass through unhandled attributes to
// the driver. But in case the driver implements this
@ -473,6 +469,16 @@ EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
}
}
if (dataSpace != 0) {
int err = native_window_set_buffers_data_space(window, dataSpace);
if (err != 0) {
ALOGE("error setting native window pixel dataSpace: %s (%d)",
strerror(-err), err);
native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
}
}
// the EGL spec requires that a new EGLSurface default to swap interval
// 1, so explicitly set that on the window here.
ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(window);

View File

@ -29,8 +29,9 @@
#include <EGL/egl.h>
#include <hardware/hardware.h>
#include <gui/Surface.h>
#include <gui/BufferItem.h>
#include <gui/GraphicBufferAlloc.h>
#include <gui/Surface.h>
#include <ui/GraphicBuffer.h>
#include "FramebufferSurface.h"
@ -86,7 +87,7 @@ status_t FramebufferSurface::advanceFrame() {
status_t FramebufferSurface::nextBuffer(sp<GraphicBuffer>& outBuffer, sp<Fence>& outFence) {
Mutex::Autolock lock(mMutex);
BufferQueue::BufferItem item;
BufferItem item;
status_t err = acquireBufferLocked(&item, 0);
if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
outBuffer = mCurrentBuffer;

View File

@ -1105,8 +1105,6 @@ static String8 getFormatStr(PixelFormat format) {
case PIXEL_FORMAT_RGB_888: return String8("RGB_888");
case PIXEL_FORMAT_RGB_565: return String8("RGB_565");
case PIXEL_FORMAT_BGRA_8888: return String8("BGRA_8888");
case PIXEL_FORMAT_sRGB_A_8888: return String8("sRGB_A_8888");
case PIXEL_FORMAT_sRGB_X_8888: return String8("sRGB_x_8888");
case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
return String8("ImplDef");
default:

View File

@ -18,6 +18,8 @@
#include "VirtualDisplaySurface.h"
#include "HWComposer.h"
#include <gui/BufferItem.h>
// ---------------------------------------------------------------------------
namespace android {
// ---------------------------------------------------------------------------
@ -234,6 +236,7 @@ void VirtualDisplaySurface::onFrameCommitted() {
status_t result = mSource[SOURCE_SINK]->queueBuffer(sslot,
QueueBufferInput(
systemTime(), false /* isAutoTimestamp */,
HAL_DATASPACE_UNKNOWN,
Rect(mSinkBufferWidth, mSinkBufferHeight),
NATIVE_WINDOW_SCALING_MODE_FREEZE, 0 /* transform */,
true /* async*/,
@ -435,7 +438,7 @@ status_t VirtualDisplaySurface::queueBuffer(int pslot,
// Now acquire the buffer from the scratch pool -- should be the same
// slot and fence as we just queued.
Mutex::Autolock lock(mMutex);
BufferQueue::BufferItem item;
BufferItem item;
result = acquireBufferLocked(&item, 0);
if (result != NO_ERROR)
return result;
@ -453,12 +456,13 @@ status_t VirtualDisplaySurface::queueBuffer(int pslot,
// Extract the GLES release fence for HWC to acquire
int64_t timestamp;
bool isAutoTimestamp;
android_dataspace dataSpace;
Rect crop;
int scalingMode;
uint32_t transform;
bool async;
input.deflate(&timestamp, &isAutoTimestamp, &crop, &scalingMode,
&transform, &async, &mFbFence);
input.deflate(&timestamp, &isAutoTimestamp, &dataSpace, &crop,
&scalingMode, &transform, &async, &mFbFence);
mFbProducerSlot = pslot;
mOutputFence = mFbFence;

View File

@ -764,7 +764,6 @@ bool Layer::getOpacityForFormat(uint32_t format) {
switch (format) {
case HAL_PIXEL_FORMAT_RGBA_8888:
case HAL_PIXEL_FORMAT_BGRA_8888:
case HAL_PIXEL_FORMAT_sRGB_A_8888:
return false;
}
// in all other case, we have no blending (also for unknown formats)
@ -1131,7 +1130,7 @@ Region Layer::latchBuffer(bool& recomputeVisibleRegions)
}
virtual bool reject(const sp<GraphicBuffer>& buf,
const IGraphicBufferConsumer::BufferItem& item) {
const BufferItem& item) {
if (buf == NULL) {
return false;
}

View File

@ -21,6 +21,8 @@
#include <private/gui/SyncFeatures.h>
#include <gui/BufferItem.h>
#include <utils/Errors.h>
#include <utils/NativeHandle.h>
#include <utils/Trace.h>
@ -47,7 +49,7 @@ status_t SurfaceFlingerConsumer::updateTexImage(BufferRejecter* rejecter,
return err;
}
BufferQueue::BufferItem item;
BufferItem item;
// Acquire the next buffer.
// In asynchronous mode the list is guaranteed to be one buffer
@ -101,8 +103,8 @@ status_t SurfaceFlingerConsumer::bindTextureImage()
return bindTextureImageLocked();
}
status_t SurfaceFlingerConsumer::acquireBufferLocked(
BufferQueue::BufferItem *item, nsecs_t presentWhen) {
status_t SurfaceFlingerConsumer::acquireBufferLocked(BufferItem* item,
nsecs_t presentWhen) {
status_t result = GLConsumer::acquireBufferLocked(item, presentWhen);
if (result == NO_ERROR) {
mTransformToDisplayInverse = item->mTransformToDisplayInverse;

View File

@ -41,13 +41,13 @@ public:
class BufferRejecter {
friend class SurfaceFlingerConsumer;
virtual bool reject(const sp<GraphicBuffer>& buf,
const IGraphicBufferConsumer::BufferItem& item) = 0;
const BufferItem& item) = 0;
protected:
virtual ~BufferRejecter() { }
};
virtual status_t acquireBufferLocked(BufferQueue::BufferItem *item, nsecs_t presentWhen);
virtual status_t acquireBufferLocked(BufferItem *item, nsecs_t presentWhen);
// This version of updateTexImage() takes a functor that may be used to
// reject the newly acquired buffer. Unlike the GLConsumer version,