From 6c450101753d0219b151e79007bcded1bfbb058b Mon Sep 17 00:00:00 2001 From: Eino-Ville Talvala Date: Thu, 19 Feb 2015 16:10:43 -0800 Subject: [PATCH] DO NOT MERGE Cherry-pick dataSpace and BufferItem changes DO NOT MERGE Add dataSpace to buffer queues; remove old format enums. (cherry picked from commit 82c6bcc9705eabcaf5b9e45bc81867b0e2d61a02) DO NOT MERGE libgui: Prepare for IGBC::BufferItem removal (cherry picked from commit cf3834db104e0b052056e3a06d46e3f222f0d372) DO NOT MERGE SurfaceFlinger: Stop using IGBC::BufferItem (cherry picked from commit 11611f9be590480d7ea27bf0153558573ddcded2) --- include/gui/BufferItem.h | 15 ++++++- include/gui/BufferItemConsumer.h | 13 +++++- include/gui/BufferQueueConsumer.h | 9 ++++ include/gui/BufferQueueCore.h | 5 +++ include/gui/ConsumerBase.h | 4 +- include/gui/CpuConsumer.h | 7 ++++ include/gui/GLConsumer.h | 5 ++- include/gui/IGraphicBufferConsumer.h | 14 +++++++ include/gui/IGraphicBufferProducer.h | 20 +++++---- include/gui/Surface.h | 7 ++++ include/ui/PixelFormat.h | 2 - libs/gui/BufferItem.cpp | 20 +++++++++ libs/gui/BufferItemConsumer.cpp | 20 ++++++++- libs/gui/BufferQueueConsumer.cpp | 25 +++++++++++ libs/gui/BufferQueueCore.cpp | 1 + libs/gui/BufferQueueProducer.cpp | 18 ++++++-- libs/gui/ConsumerBase.cpp | 14 ++++++- libs/gui/CpuConsumer.cpp | 15 +++++-- libs/gui/GLConsumer.cpp | 22 +++++++++- libs/gui/IGraphicBufferConsumer.cpp | 42 +++++++++++++++++++ libs/gui/IGraphicBufferProducer.cpp | 4 ++ libs/gui/StreamSplitter.cpp | 6 ++- libs/gui/Surface.cpp | 22 +++++++++- libs/gui/tests/BufferQueue_test.cpp | 26 +++++++----- libs/gui/tests/CpuConsumer_test.cpp | 24 +++++------ .../gui/tests/IGraphicBufferProducer_test.cpp | 9 ++++ libs/gui/tests/SRGB_test.cpp | 15 ++++--- libs/gui/tests/StreamSplitter_test.cpp | 8 +++- libs/gui/tests/Surface_test.cpp | 22 ++++++++++ libs/ui/PixelFormat.cpp | 3 -- opengl/libs/EGL/eglApi.cpp | 30 +++++++------ .../DisplayHardware/FramebufferSurface.cpp | 5 ++- .../DisplayHardware/HWComposer.cpp | 2 - .../DisplayHardware/VirtualDisplaySurface.cpp | 10 +++-- services/surfaceflinger/Layer.cpp | 3 +- .../surfaceflinger/SurfaceFlingerConsumer.cpp | 8 ++-- .../surfaceflinger/SurfaceFlingerConsumer.h | 4 +- 37 files changed, 388 insertions(+), 91 deletions(-) diff --git a/include/gui/BufferItem.h b/include/gui/BufferItem.h index 01b6ff4b5..112c48293 100644 --- a/include/gui/BufferItem.h +++ b/include/gui/BufferItem.h @@ -44,6 +44,7 @@ class BufferItem : public Flattenable { // 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 { // 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 diff --git a/include/gui/BufferItemConsumer.h b/include/gui/BufferItemConsumer.h index 869b47046..57e121e61 100644 --- a/include/gui/BufferItemConsumer.h +++ b/include/gui/BufferItemConsumer.h @@ -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 diff --git a/include/gui/BufferQueueConsumer.h b/include/gui/BufferQueueConsumer.h index 898c4516c..92127c138 100644 --- a/include/gui/BufferQueueConsumer.h +++ b/include/gui/BufferQueueConsumer.h @@ -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. diff --git a/include/gui/BufferQueueCore.h b/include/gui/BufferQueueCore.h index b23cb083f..797a10825 100644 --- a/include/gui/BufferQueueCore.h +++ b/include/gui/BufferQueueCore.h @@ -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 diff --git a/include/gui/ConsumerBase.h b/include/gui/ConsumerBase.h index f7ab5ac59..46ad20e7b 100644 --- a/include/gui/ConsumerBase.h +++ b/include/gui/ConsumerBase.h @@ -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. diff --git a/include/gui/CpuConsumer.h b/include/gui/CpuConsumer.h index faf6852f8..c99ab297d 100644 --- a/include/gui/CpuConsumer.h +++ b/include/gui/CpuConsumer.h @@ -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 diff --git a/include/gui/GLConsumer.h b/include/gui/GLConsumer.h index 053d1edaf..167ef2057 100644 --- a/include/gui/GLConsumer.h +++ b/include/gui/GLConsumer.h @@ -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. diff --git a/include/gui/IGraphicBufferConsumer.h b/include/gui/IGraphicBufferConsumer.h index 9ac23c230..ae85bd501 100644 --- a/include/gui/IGraphicBufferConsumer.h +++ b/include/gui/IGraphicBufferConsumer.h @@ -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. diff --git a/include/gui/IGraphicBufferProducer.h b/include/gui/IGraphicBufferProducer.h index 4d3cd9a29..374245a7e 100644 --- a/include/gui/IGraphicBufferProducer.h +++ b/include/gui/IGraphicBufferProducer.h @@ -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 // transform - a set of flags from NATIVE_WINDOW_TRANSFORM_* in @@ -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, 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, + 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* outFence, + android_dataspace* outDataSpace, + Rect* outCrop, int* outScalingMode, + uint32_t* outTransform, bool* outAsync, sp* 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; diff --git a/include/gui/Surface.h b/include/gui/Surface.h index 863f22bb0..40e2fc154 100644 --- a/include/gui/Surface.h +++ b/include/gui/Surface.h @@ -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; diff --git a/include/ui/PixelFormat.h b/include/ui/PixelFormat.h index e7e8ffc29..f26fecb8b 100644 --- a/include/ui/PixelFormat.h +++ b/include/ui/PixelFormat.h @@ -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; diff --git a/libs/gui/BufferItem.cpp b/libs/gui/BufferItem.cpp index e6fc79119..389d86713 100644 --- a/libs/gui/BufferItem.cpp +++ b/libs/gui/BufferItem.cpp @@ -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); diff --git a/libs/gui/BufferItemConsumer.cpp b/libs/gui/BufferItemConsumer.cpp index 61de69af9..fb978ddf0 100644 --- a/libs/gui/BufferItemConsumer.cpp +++ b/libs/gui/BufferItemConsumer.cpp @@ -19,6 +19,7 @@ //#define ATRACE_TAG ATRACE_TAG_GRAPHICS #include +#include #include //#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& 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 diff --git a/libs/gui/BufferQueueConsumer.cpp b/libs/gui/BufferQueueConsumer.cpp index a798b18ba..821a7441c 100644 --- a/libs/gui/BufferQueueConsumer.cpp +++ b/libs/gui/BufferQueueConsumer.cpp @@ -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); diff --git a/libs/gui/BufferQueueCore.cpp b/libs/gui/BufferQueueCore.cpp index ec1e63112..edebc4553 100644 --- a/libs/gui/BufferQueueCore.cpp +++ b/libs/gui/BufferQueueCore.cpp @@ -60,6 +60,7 @@ BufferQueueCore::BufferQueueCore(const sp& allocator) : mDefaultBufferFormat(PIXEL_FORMAT_RGBA_8888), mDefaultWidth(1), mDefaultHeight(1), + mDefaultBufferDataSpace(HAL_DATASPACE_UNKNOWN), mDefaultMaxBufferCount(2), mMaxAcquiredBufferCount(1), mBufferHasBeenQueued(false), diff --git a/libs/gui/BufferQueueProducer.cpp b/libs/gui/BufferQueueProducer.cpp index 13b864d29..4c22ba381 100644 --- a/libs/gui/BufferQueueProducer.cpp +++ b/libs/gui/BufferQueueProducer.cpp @@ -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; - input.deflate(×tamp, &isAutoTimestamp, &crop, &scalingMode, &transform, - &async, &fence, &stickyTransform); + input.deflate(×tamp, &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(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(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(mCore->mConsumerUsageBits); break; + case NATIVE_WINDOW_DEFAULT_DATASPACE: + value = static_cast(mCore->mDefaultBufferDataSpace); + break; default: return BAD_VALUE; } diff --git a/libs/gui/ConsumerBase.cpp b/libs/gui/ConsumerBase.cpp index 5fc83eebf..c8b5d0cb9 100644 --- a/libs/gui/ConsumerBase.cpp +++ b/libs/gui/ConsumerBase.cpp @@ -27,6 +27,7 @@ #include +#include #include #include #include @@ -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, const sp& fence) { Mutex::Autolock lock(mMutex); diff --git a/libs/gui/CpuConsumer.cpp b/libs/gui/CpuConsumer.cpp index 73d34eb6e..eb39469b0 100644 --- a/libs/gui/CpuConsumer.cpp +++ b/libs/gui/CpuConsumer.cpp @@ -20,6 +20,7 @@ #include #include +#include #include #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(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(ycbcr.cb); diff --git a/libs/gui/GLConsumer.cpp b/libs/gui/GLConsumer.cpp index a0f68b4c1..d256ae538 100644 --- a/libs/gui/GLConsumer.cpp +++ b/libs/gui/GLConsumer.cpp @@ -29,6 +29,7 @@ #include +#include #include #include #include @@ -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 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, 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; diff --git a/libs/gui/IGraphicBufferConsumer.cpp b/libs/gui/IGraphicBufferConsumer.cpp index 260288447..edf440884 100644 --- a/libs/gui/IGraphicBufferConsumer.cpp +++ b/libs/gui/IGraphicBufferConsumer.cpp @@ -23,6 +23,7 @@ #include #include +#include #include #include @@ -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(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(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(); diff --git a/libs/gui/IGraphicBufferProducer.cpp b/libs/gui/IGraphicBufferProducer.cpp index 63d881efd..a3e6fb2a2 100644 --- a/libs/gui/IGraphicBufferProducer.cpp +++ b/libs/gui/IGraphicBufferProducer.cpp @@ -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); diff --git a/libs/gui/StreamSplitter.cpp b/libs/gui/StreamSplitter.cpp index 8146869b8..43f9214fc 100644 --- a/libs/gui/StreamSplitter.cpp +++ b/libs/gui/StreamSplitter.cpp @@ -20,6 +20,7 @@ #define ATRACE_TAG ATRACE_TAG_GRAPHICS //#define LOG_NDEBUG 0 +#include #include #include #include @@ -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(bufferItem.mScalingMode), + bufferItem.mDataSpace, bufferItem.mCrop, + static_cast(bufferItem.mScalingMode), bufferItem.mTransform, bufferItem.mIsDroppable, bufferItem.mFence); diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp index 98489b1fe..aa6f97e2e 100644 --- a/libs/gui/Surface.cpp +++ b/libs/gui/Surface.cpp @@ -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(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(va_arg(args, int)); + return setBuffersDataSpace(dataspace); +} + int Surface::connect(int api) { static sp 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; diff --git a/libs/gui/tests/BufferQueue_test.cpp b/libs/gui/tests/BufferQueue_test.cpp index 838ad90e8..c38c79781 100644 --- a/libs/gui/tests/BufferQueue_test.cpp +++ b/libs/gui/tests/BufferQueue_test.cpp @@ -17,6 +17,7 @@ #define LOG_TAG "BufferQueue_test" //#define LOG_NDEBUG 0 +#include #include #include @@ -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; sp 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(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(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(0))); ASSERT_EQ(OK, mConsumer->detachBuffer(item.mBuf)); diff --git a/libs/gui/tests/CpuConsumer_test.cpp b/libs/gui/tests/CpuConsumer_test.cpp index abd372449..0beca92de 100644 --- a/libs/gui/tests/CpuConsumer_test.cpp +++ b/libs/gui/tests/CpuConsumer_test.cpp @@ -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& 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& 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[] = { diff --git a/libs/gui/tests/IGraphicBufferProducer_test.cpp b/libs/gui/tests/IGraphicBufferProducer_test.cpp index 8d5fd8f58..c904a6bd4 100644 --- a/libs/gui/tests/IGraphicBufferProducer_test.cpp +++ b/libs/gui/tests/IGraphicBufferProducer_test.cpp @@ -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; diff --git a/libs/gui/tests/SRGB_test.cpp b/libs/gui/tests/SRGB_test.cpp index da2add716..e5907e71f 100644 --- a/libs/gui/tests/SRGB_test.cpp +++ b/libs/gui/tests/SRGB_test.cpp @@ -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(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) { diff --git a/libs/gui/tests/StreamSplitter_test.cpp b/libs/gui/tests/StreamSplitter_test.cpp index 4e63a6f4d..767c7c6e4 100644 --- a/libs/gui/tests/StreamSplitter_test.cpp +++ b/libs/gui/tests/StreamSplitter_test.cpp @@ -17,6 +17,7 @@ #define LOG_TAG "StreamSplitter_test" //#define LOG_NDEBUG 0 +#include #include #include #include @@ -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)); diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp index 5e6aeef35..4f878244b 100644 --- a/libs/gui/tests/Surface_test.cpp +++ b/libs/gui/tests/Surface_test.cpp @@ -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 producer; + sp consumer; + BufferQueue::createBufferQueue(&producer, &consumer); + sp cpuConsumer = new CpuConsumer(consumer, 1); + + cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE); + + sp s = new Surface(producer); + + sp anw(s); + + android_dataspace dataSpace; + + int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE, + reinterpret_cast(&dataSpace)); + + ASSERT_EQ(NO_ERROR, err); + ASSERT_EQ(TEST_DATASPACE, dataSpace); +} + } diff --git a/libs/ui/PixelFormat.cpp b/libs/ui/PixelFormat.cpp index 99ed6f783..cab1dde3f 100644 --- a/libs/ui/PixelFormat.cpp +++ b/libs/ui/PixelFormat.cpp @@ -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 // ---------------------------------------------------------------------------- - diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp index ff08a6b89..11a13c311 100644 --- a/opengl/libs/EGL/eglApi.cpp +++ b/opengl/libs/EGL/eglApi.cpp @@ -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(window); diff --git a/services/surfaceflinger/DisplayHardware/FramebufferSurface.cpp b/services/surfaceflinger/DisplayHardware/FramebufferSurface.cpp index 4885c5fc4..6ef3295b0 100644 --- a/services/surfaceflinger/DisplayHardware/FramebufferSurface.cpp +++ b/services/surfaceflinger/DisplayHardware/FramebufferSurface.cpp @@ -29,8 +29,9 @@ #include #include -#include +#include #include +#include #include #include "FramebufferSurface.h" @@ -86,7 +87,7 @@ status_t FramebufferSurface::advanceFrame() { status_t FramebufferSurface::nextBuffer(sp& outBuffer, sp& outFence) { Mutex::Autolock lock(mMutex); - BufferQueue::BufferItem item; + BufferItem item; status_t err = acquireBufferLocked(&item, 0); if (err == BufferQueue::NO_BUFFER_AVAILABLE) { outBuffer = mCurrentBuffer; diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp index edfed491b..77a9a19b3 100644 --- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp +++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp @@ -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: diff --git a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp index ef10fa7fc..0e94f0d58 100644 --- a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp +++ b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp @@ -18,6 +18,8 @@ #include "VirtualDisplaySurface.h" #include "HWComposer.h" +#include + // --------------------------------------------------------------------------- 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(×tamp, &isAutoTimestamp, &crop, &scalingMode, - &transform, &async, &mFbFence); + input.deflate(×tamp, &isAutoTimestamp, &dataSpace, &crop, + &scalingMode, &transform, &async, &mFbFence); mFbProducerSlot = pslot; mOutputFence = mFbFence; diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp index 9da1efd97..2ac4765a5 100644 --- a/services/surfaceflinger/Layer.cpp +++ b/services/surfaceflinger/Layer.cpp @@ -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& buf, - const IGraphicBufferConsumer::BufferItem& item) { + const BufferItem& item) { if (buf == NULL) { return false; } diff --git a/services/surfaceflinger/SurfaceFlingerConsumer.cpp b/services/surfaceflinger/SurfaceFlingerConsumer.cpp index 7de6ac428..abf39932f 100644 --- a/services/surfaceflinger/SurfaceFlingerConsumer.cpp +++ b/services/surfaceflinger/SurfaceFlingerConsumer.cpp @@ -21,6 +21,8 @@ #include +#include + #include #include #include @@ -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; diff --git a/services/surfaceflinger/SurfaceFlingerConsumer.h b/services/surfaceflinger/SurfaceFlingerConsumer.h index 28f2f6aeb..d1cf9b999 100644 --- a/services/surfaceflinger/SurfaceFlingerConsumer.h +++ b/services/surfaceflinger/SurfaceFlingerConsumer.h @@ -41,13 +41,13 @@ public: class BufferRejecter { friend class SurfaceFlingerConsumer; virtual bool reject(const sp& 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,