Make ANW.setSwapInterval(0) work again
we can now queue/dequeue a buffer in asynchrnous mode by using the
async parameter to these calls. async mode is only specified
with those calls (it is not modal anymore).
as a consequence it can only be specified when the buffer count
is not overidden, as error is returned otherwise.
Change-Id: Ic63f4f96f671cb9d65c4cecbcc192615e09a8b6b
diff --git a/include/gui/BufferQueue.h b/include/gui/BufferQueue.h
index b968287..628678f 100644
--- a/include/gui/BufferQueue.h
+++ b/include/gui/BufferQueue.h
@@ -167,7 +167,7 @@
//
// In both cases, the producer will need to call requestBuffer to get a
// GraphicBuffer handle for the returned slot.
- virtual status_t dequeueBuffer(int *buf, sp<Fence>* fence,
+ virtual status_t dequeueBuffer(int *buf, sp<Fence>* fence, bool async,
uint32_t width, uint32_t height, uint32_t format, uint32_t usage);
// queueBuffer returns a filled buffer to the BufferQueue.
@@ -229,7 +229,7 @@
mTimestamp(0),
mFrameNumber(0),
mBuf(INVALID_BUFFER_SLOT),
- mDequeueBufferCannotBlock(false),
+ mIsDroppable(false),
mAcquireCalled(false) {
mCrop.makeInvalid();
}
@@ -260,12 +260,12 @@
// mFence is a fence that will signal when the buffer is idle.
sp<Fence> mFence;
- // mDequeueBufferCannotBlock whether this buffer was queued with the
+ // mIsDroppable whether this buffer was queued with the
// property that it can be replaced by a new buffer for the purpose of
// making sure dequeueBuffer() won't block.
// i.e.: was the BufferQueue in "mDequeueBufferCannotBlock" when this buffer
// was queued.
- bool mDequeueBufferCannotBlock;
+ bool mIsDroppable;
// Indicates whether this buffer has been seen by a consumer yet
bool mAcquireCalled;
@@ -379,9 +379,15 @@
// The initial default is 2.
status_t setDefaultMaxBufferCountLocked(int count);
+ // getMinUndequeuedBufferCount returns the minimum number of buffers
+ // that must remain in a state other than DEQUEUED.
+ // The async parameter tells whether we're in asynchronous mode.
+ int getMinUndequeuedBufferCount(bool async) const;
+
// getMinBufferCountLocked returns the minimum number of buffers allowed
// given the current BufferQueue state.
- int getMinMaxBufferCountLocked() const;
+ // The async parameter tells whether we're in asynchronous mode.
+ int getMinMaxBufferCountLocked(bool async) const;
// getMaxBufferCountLocked returns the maximum number of buffers that can
// be allocated at once. This value depends upon the following member
@@ -391,10 +397,11 @@
// mMaxAcquiredBufferCount
// mDefaultMaxBufferCount
// mOverrideMaxBufferCount
+ // async parameter
//
// Any time one of these member variables is changed while a producer is
// connected, mDequeueCondition must be broadcast.
- int getMaxBufferCountLocked() const;
+ int getMaxBufferCountLocked(bool async) const;
// stillTracking returns true iff the buffer item is still being tracked
// in one of the slots.
@@ -516,11 +523,6 @@
// in dequeueBuffer() if a width and height of zero is specified.
uint32_t mDefaultHeight;
- // mMinUndequeuedBufferCount holds the minimum number of buffers
- // that must remain in a state other than DEQUEUED.
- // This value cannot change while connected.
- int mMinUndequeuedBufferCount;
-
// mMaxAcquiredBufferCount is the number of buffers that the consumer may
// acquire at one time. It defaults to 1 and can be changed by the
// consumer via the setMaxAcquiredBufferCount method, but this may only be
diff --git a/include/gui/IGraphicBufferProducer.h b/include/gui/IGraphicBufferProducer.h
index af5fcfc..9677962 100644
--- a/include/gui/IGraphicBufferProducer.h
+++ b/include/gui/IGraphicBufferProducer.h
@@ -84,7 +84,10 @@
// the buffer. The contents of the buffer must not be overwritten until the
// fence signals. If the fence is NULL, the buffer may be written
// immediately.
- virtual status_t dequeueBuffer(int *slot, sp<Fence>* fence,
+ //
+ // The async parameter sets whether we're in asynchrnous mode for this
+ // deququeBuffer() call.
+ virtual status_t dequeueBuffer(int *slot, sp<Fence>* fence, bool async,
uint32_t w, uint32_t h, uint32_t format, uint32_t usage) = 0;
// queueBuffer indicates that the client has finished filling in the
@@ -96,6 +99,8 @@
// must be monotonically increasing. Its other properties (zero point, etc)
// are client-dependent, and should be documented by the client.
//
+ // The async parameter sets whether we're queuing a buffer in asynchronous mode.
+ //
// outWidth, outHeight and outTransform are filled with the default width
// and height of the window and current transform applied to buffers,
// respectively.
@@ -103,17 +108,18 @@
struct QueueBufferInput : public Flattenable {
inline QueueBufferInput(const Parcel& parcel);
inline QueueBufferInput(int64_t timestamp,
- const Rect& crop, int scalingMode, uint32_t transform,
- sp<Fence> fence)
+ const Rect& crop, int scalingMode, uint32_t transform, bool async,
+ const sp<Fence>& fence)
: timestamp(timestamp), crop(crop), scalingMode(scalingMode),
- transform(transform), fence(fence) { }
+ transform(transform), async(async), fence(fence) { }
inline void deflate(int64_t* outTimestamp, Rect* outCrop,
- int* outScalingMode, uint32_t* outTransform,
+ int* outScalingMode, uint32_t* outTransform, bool* outAsync,
sp<Fence>* outFence) const {
*outTimestamp = timestamp;
*outCrop = crop;
*outScalingMode = scalingMode;
*outTransform = transform;
+ *outAsync = bool(async);
*outFence = fence;
}
@@ -130,6 +136,7 @@
Rect crop;
int scalingMode;
uint32_t transform;
+ int async;
sp<Fence> fence;
};
diff --git a/include/gui/Surface.h b/include/gui/Surface.h
index 6f12e77..2f7406e 100644
--- a/include/gui/Surface.h
+++ b/include/gui/Surface.h
@@ -235,6 +235,10 @@
// by the application
bool mProducerControlledByApp;
+ // mSwapIntervalZero set if we should drop buffers at queue() time to
+ // achieve an asynchronous swap interval
+ bool mSwapIntervalZero;
+
// mConsumerRunningBehind whether the consumer is running more than
// one buffer behind the producer.
mutable bool mConsumerRunningBehind;