Move IGraphicBufferProducer to graphics/bufferqueue.
Test: With CtsMediaTestCases.apk installed,
adb shell am instrument -e size small -w
'android.media.cts/android.support.test.runner.AndroidJUnitRunner'
Bug: 35442034
Change-Id: Ia1ef0eb069fcd97f7afcf42bf3bb16c8c6a752c4
diff --git a/graphics/bufferqueue/1.0/IGraphicBufferProducer.hal b/graphics/bufferqueue/1.0/IGraphicBufferProducer.hal
new file mode 100644
index 0000000..c59a16c
--- /dev/null
+++ b/graphics/bufferqueue/1.0/IGraphicBufferProducer.hal
@@ -0,0 +1,718 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http: *www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.graphics.bufferqueue@1.0;
+
+import android.hardware.media@1.0::Fence;
+import android.hardware.media@1.0::AnwBuffer;
+import android.hardware.media@1.0::Rect;
+import android.hardware.media@1.0::Region;
+
+import android.hardware.graphics.common@1.0::Dataspace;
+import android.hardware.graphics.common@1.0::PixelFormat;
+
+import IProducerListener;
+
+/**
+ * Ref: frameworks/native/include/gui/IGraphicBufferProducer.h:
+ * IGraphicBufferProducer
+ * This is a wrapper/wrapped HAL interface for the actual binder interface.
+ */
+interface IGraphicBufferProducer {
+
+ /**
+ * Type for return values of functions in IGraphicBufferProducer.
+ */
+ typedef int32_t Status;
+
+ /**
+ * Ref: frameworks/native/include/ui/FenceTime.h: FenceTime::Snapshot
+ *
+ * An atomic snapshot of the FenceTime that is flattenable.
+ */
+ struct FenceTimeSnapshot {
+ enum State : int32_t {
+ EMPTY,
+ FENCE,
+ SIGNAL_TIME,
+ };
+ State state;
+ Fence fence;
+ int64_t signalTimeNs;
+ };
+
+ /**
+ * Ref: frameworks/native/include/gui/FrameTimestamp.h: FrameEventsDelta
+ *
+ * A single frame update from the consumer to producer that can be sent
+ * through a HIDL interface. Although this may be sent multiple times for
+ * the same frame as new timestamps are set, Fences only need to be sent
+ * once.
+ */
+ struct FrameEventsDelta {
+ uint32_t index;
+ uint64_t frameNumber;
+ bool addPostCompositeCalled;
+ bool addRetireCalled;
+ bool addReleaseCalled;
+ int64_t postedTimeNs;
+ int64_t requestedPresentTimeNs;
+ int64_t latchTimeNs;
+ int64_t firstRefreshStartTimeNs;
+ int64_t lastRefreshStartTimeNs;
+ int64_t dequeueReadyTime;
+ FenceTimeSnapshot gpuCompositionDoneFence;
+ FenceTimeSnapshot displayPresentFence;
+ FenceTimeSnapshot displayRetireFence;
+ FenceTimeSnapshot releaseFence;
+ };
+
+ /**
+ * Ref: frameworks/native/include/gui/FrameTimestamp.h: CompositorTiming
+ *
+ * The most recent compositor timing info sent from consumer to producer
+ * through a HIDL interface.
+ */
+ struct CompositorTiming {
+ int64_t deadlineNs;
+ int64_t intervalNs;
+ int64_t presentLatencyNs;
+ };
+
+ /**
+ * Ref: frameworks/native/include/gui/FrameTimestamp.h: FrameEventHistoryDelta
+ *
+ * A collection of updates from consumer to producer that can be sent
+ * through a HIDL interface.
+ */
+ struct FrameEventHistoryDelta {
+ vec<FrameEventsDelta> deltas;
+ CompositorTiming compositorTiming;
+ };
+
+ /**
+ * Modes for disconnection.
+ */
+ enum DisconnectMode : int32_t {
+ /** Disconnect only the specified API. */
+ API,
+ /** Disconnect any API originally connected from the process calling
+ * disconnect. */
+ ALL_LOCAL
+ };
+
+ struct QueueBufferInput {
+ /** A monotonically increasing value in nanoseconds. */
+ int64_t timestamp;
+ /** Whether the timestamp was synthesized at queue time. */
+ int32_t isAutoTimestamp;
+ /** Description of the contents, interpretation depends on format. */
+ Dataspace dataSpace;
+ /** A crop rectangle that's used as a hint to the consumer. */
+ Rect crop;
+ /** A set of flags from NATIVE_WINDOW_SCALING_* in <window.h>. */
+ int32_t scalingMode;
+ /** A set of flags from NATIVE_WINDOW_TRANSFORM_* in <window.h>. */
+ uint32_t transform;
+ /** The sticky transform set in Surface (only used by the LEGACY camera
+ * mode). */
+ uint32_t stickyTransform;
+ /** A fence that the consumer must wait on before reading the buffer;
+ * set this to Fence::NO_FENCE if the buffer is ready immediately. */
+ Fence fence;
+ Region surfaceDamage;
+ /** Whether or not the latest frame timestamps should be retrieved from
+ * the consumer. */
+ bool getFrameTimestamps;
+ };
+
+ struct QueueBufferOutput {
+ uint32_t width;
+ uint32_t height;
+ uint32_t transformHint;
+ uint32_t numPendingBuffers;
+ uint64_t nextFrameNumber;
+ bool bufferReplaced;
+ FrameEventHistoryDelta frameTimestamps;
+ };
+
+ /**
+ * requestBuffer requests a new buffer for the given index. The server (i.e.
+ * the IProducerListener implementation) assigns the newly created
+ * buffer to the given slot index, and the client is expected to mirror the
+ * slot->buffer mapping so that it's not necessary to transfer an
+ * AnwBuffer for every dequeue operation.
+ *
+ * The slot must be in the range of [0, NUM_BUFFER_SLOTS).
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned or the producer is not
+ * connected.
+ * * BAD_VALUE - one of the two conditions occurred:
+ * * slot was out of range (see above)
+ * * buffer specified by the slot is not dequeued
+ */
+ requestBuffer(
+ int32_t slot
+ ) generates (
+ Status status,
+ AnwBuffer buffer
+ );
+
+ /**
+ * setMaxDequeuedBufferCount sets the maximum number of buffers that can be
+ * dequeued by the producer at one time. If this method succeeds, any new
+ * buffer slots will be both unallocated and owned by the BufferQueue object
+ * (i.e. they are not owned by the producer or consumer). Calling this may
+ * also cause some buffer slots to be emptied. If the caller is caching the
+ * contents of the buffer slots, it should empty that cache after calling
+ * this method.
+ *
+ * This function should not be called with a value of maxDequeuedBuffers
+ * that is less than the number of currently dequeued buffer slots. Doing so
+ * will result in a BAD_VALUE error.
+ *
+ * The buffer count should be at least 1 (inclusive), but at most
+ * (NUM_BUFFER_SLOTS - the minimum undequeued buffer count) (exclusive). The
+ * minimum undequeued buffer count can be obtained by calling
+ * query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS).
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned.
+ * * BAD_VALUE - one of the below conditions occurred:
+ * * bufferCount was out of range (see above).
+ * * client would have more than the requested number of dequeued
+ * buffers after this call.
+ * * this call would cause the maxBufferCount value to be exceeded.
+ * * failure to adjust the number of available slots.
+ */
+ setMaxDequeuedBufferCount(
+ int32_t maxDequeuedBuffers
+ ) generates (
+ Status status
+ );
+
+ /**
+ * Set the async flag if the producer intends to asynchronously queue
+ * buffers without blocking. Typically this is used for triple-buffering
+ * and/or when the swap interval is set to zero.
+ *
+ * Enabling async mode will internally allocate an additional buffer to
+ * allow for the asynchronous behavior. If it is not enabled queue/dequeue
+ * calls may block.
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned.
+ * * BAD_VALUE - one of the following has occurred:
+ * * this call would cause the maxBufferCount value to be
+ * exceeded
+ * * failure to adjust the number of available slots.
+ */
+ setAsyncMode(
+ bool async
+ ) generates (
+ Status status
+ );
+
+ /**
+ * dequeueBuffer requests a new buffer slot for the client to use. Ownership
+ * of the slot is transfered to the client, meaning that the server will not
+ * use the contents of the buffer associated with that slot.
+ *
+ * The slot index returned may or may not contain a buffer (client-side).
+ * If the slot is empty the client should call requestBuffer to assign a new
+ * buffer to that slot.
+ *
+ * Once the client is done filling this buffer, it is expected to transfer
+ * buffer ownership back to the server with either cancelBuffer on
+ * the dequeued slot or to fill in the contents of its associated buffer
+ * contents and call queueBuffer.
+ *
+ * If dequeueBuffer returns the BUFFER_NEEDS_REALLOCATION flag, the client is
+ * expected to call requestBuffer immediately.
+ *
+ * If dequeueBuffer returns the RELEASE_ALL_BUFFERS flag, the client is
+ * expected to release all of the mirrored slot->buffer mappings.
+ *
+ * The fence parameter will be updated to hold the fence associated with
+ * the buffer. The contents of the buffer must not be overwritten until the
+ * fence signals. If the fence is Fence::NO_FENCE, the buffer may be written
+ * immediately.
+ *
+ * The width and height parameters must be no greater than the minimum of
+ * GL_MAX_VIEWPORT_DIMS and GL_MAX_TEXTURE_SIZE (see: glGetIntegerv).
+ * An error due to invalid dimensions might not be reported until
+ * updateTexImage() is called. If width and height are both zero, the
+ * default values specified by setDefaultBufferSize() are used instead.
+ *
+ * If the format is 0, the default format will be used.
+ *
+ * The usage argument specifies gralloc buffer usage flags. The values
+ * are enumerated in <gralloc.h>, e.g. GRALLOC_USAGE_HW_RENDER. These
+ * will be merged with the usage flags specified by
+ * IGraphicBufferConsumer::setConsumerUsageBits.
+ *
+ * This call will block until a buffer is available to be dequeued. If
+ * both the producer and consumer are controlled by the app, then this call
+ * can never block and will return WOULD_BLOCK if no buffer is available.
+ *
+ * A non-negative value with flags set (see above) will be returned upon
+ * success as status.
+ *
+ * Return of a negative means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned or the producer is not
+ * connected.
+ * * BAD_VALUE - both in async mode and buffer count was less than the
+ * max numbers of buffers that can be allocated at once.
+ * * INVALID_OPERATION - cannot attach the buffer because it would cause
+ * too many buffers to be dequeued, either because
+ * the producer already has a single buffer dequeued
+ * and did not set a buffer count, or because a
+ * buffer count was set and this call would cause
+ * it to be exceeded.
+ * * WOULD_BLOCK - no buffer is currently available, and blocking is disabled
+ * since both the producer/consumer are controlled by app
+ * * NO_MEMORY - out of memory, cannot allocate the graphics buffer.
+ * * TIMED_OUT - the timeout set by setDequeueTimeout was exceeded while
+ * waiting for a buffer to become available.
+ *
+ * All other negative values are an unknown error returned downstream
+ * from the graphics allocator (typically errno).
+ */
+ dequeueBuffer(
+ uint32_t width,
+ uint32_t height,
+ PixelFormat format,
+ uint32_t usage,
+ bool getFrameTimestamps
+ ) generates (
+ Status status,
+ int32_t slot,
+ Fence fence,
+ FrameEventHistoryDelta outTimestamps
+ );
+
+ /**
+ * 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
+ * freed, and there will be no way to obtain the buffer from this interface.
+ * The freed slot will remain unallocated until either it is selected to
+ * hold a freshly allocated buffer in dequeueBuffer or a buffer is attached
+ * to the slot. The buffer must have already been dequeued, and the caller
+ * must already possesses the sp<AnwBuffer> (i.e., must have called
+ * requestBuffer).
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned or the producer is not
+ * connected.
+ * * BAD_VALUE - the given slot number is invalid, either because it is
+ * out of the range [0, NUM_BUFFER_SLOTS), or because the slot
+ * it refers to is not currently dequeued and requested.
+ */
+ detachBuffer(
+ int32_t slot
+ ) generates (
+ Status status
+ );
+
+ /**
+ * detachNextBuffer is equivalent to calling dequeueBuffer, requestBuffer,
+ * and detachBuffer in sequence, except for two things:
+ *
+ * 1) It is unnecessary to know the dimensions, format, or usage of the
+ * next buffer.
+ * 2) It will not block, since if it cannot find an appropriate buffer to
+ * return, it will return an error instead.
+ *
+ * Only slots that are free but still contain an AnwBuffer will be
+ * considered, and the oldest of those will be returned. buffer is
+ * equivalent to buffer from the requestBuffer call, and fence is
+ * equivalent to fence from the dequeueBuffer call.
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned or the producer is not
+ * connected.
+ * * BAD_VALUE - either outBuffer or outFence were NULL.
+ * * NO_MEMORY - no slots were found that were both free and contained a
+ * AnwBuffer.
+ */
+ detachNextBuffer(
+ ) generates (
+ Status status,
+ AnwBuffer buffer,
+ Fence fence
+ );
+
+ /**
+ * attachBuffer attempts to transfer ownership of a buffer to the buffer
+ * queue. If this call succeeds, it will be as if this buffer was dequeued
+ * from the returned slot number. As such, this call will fail if attaching
+ * this buffer would cause too many buffers to be simultaneously dequeued.
+ *
+ * If attachBuffer returns the RELEASE_ALL_BUFFERS flag, the caller is
+ * expected to release all of the mirrored slot->buffer mappings.
+ *
+ * A non-negative value with flags set (see above) will be returned upon
+ * success.
+ *
+ * Return of a negative value means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned or the producer is not
+ * connected.
+ * * BAD_VALUE - outSlot or buffer were NULL, invalid combination of
+ * async mode and buffer count override, or the generation
+ * number of the buffer did not match the buffer queue.
+ * * INVALID_OPERATION - cannot attach the buffer because it would cause
+ * too many buffers to be dequeued, either because
+ * the producer already has a single buffer dequeued
+ * and did not set a buffer count, or because a
+ * buffer count was set and this call would cause
+ * it to be exceeded.
+ * * WOULD_BLOCK - no buffer slot is currently available, and blocking is
+ * disabled since both the producer/consumer are
+ * controlled by the app.
+ * * TIMED_OUT - the timeout set by setDequeueTimeout was exceeded while
+ * waiting for a slot to become available.
+ */
+ attachBuffer(
+ AnwBuffer buffer
+ ) generates (
+ Status status,
+ int32_t slot
+ );
+
+ /**
+ * queueBuffer indicates that the client has finished filling in the
+ * contents of the buffer associated with slot and transfers ownership of
+ * that slot back to the server.
+ *
+ * It is not valid to call queueBuffer on a slot that is not owned
+ * by the client or one for which a buffer associated via requestBuffer
+ * (an attempt to do so will fail with a return value of BAD_VALUE).
+ *
+ * In addition, the input must be described by the client (as documented
+ * below). Any other properties (zero point, etc)
+ * are client-dependent, and should be documented by the client.
+ *
+ * The slot must be in the range of [0, NUM_BUFFER_SLOTS).
+ *
+ * Upon success, the output will be filled with meaningful values
+ * (refer to the documentation below).
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned or the producer is not
+ * connected.
+ * * BAD_VALUE - one of the below conditions occurred:
+ * * fence was NULL
+ * * scaling mode was unknown
+ * * both in async mode and buffer count was less than the
+ * max numbers of buffers that can be allocated at once
+ * * slot index was out of range (see above).
+ * * the slot was not in the dequeued state
+ * * the slot was enqueued without requesting a buffer
+ * * crop rect is out of bounds of the buffer dimensions
+ */
+ queueBuffer(
+ int32_t slot,
+ QueueBufferInput input
+ ) generates (
+ Status status,
+ QueueBufferOutput output
+ );
+
+ /**
+ * cancelBuffer indicates that the client does not wish to fill in the
+ * buffer associated with slot and transfers ownership of the slot back to
+ * the server.
+ *
+ * The buffer is not queued for use by the consumer.
+ *
+ * The slot must be in the range of [0, NUM_BUFFER_SLOTS).
+ *
+ * The buffer will not be overwritten until the fence signals. The fence
+ * will usually be the one obtained from dequeueBuffer.
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned or the producer is not
+ * connected.
+ * * BAD_VALUE - one of the below conditions occurred:
+ * * fence was NULL
+ * * slot index was out of range (see above).
+ * * the slot was not in the dequeued state
+ */
+ cancelBuffer(
+ int32_t slot,
+ Fence fence
+ ) generates (
+ Status status
+ );
+
+ /**
+ * query retrieves some information for this surface
+ * 'what' tokens allowed are that of NATIVE_WINDOW_* in <window.h>
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * NO_INIT - the buffer queue has been abandoned.
+ * * BAD_VALUE - what was out of range
+ */
+ query(
+ int32_t what
+ ) generates (
+ int32_t result,
+ int32_t value
+ );
+
+ /**
+ * connect attempts to connect a client API to the IGraphicBufferProducer.
+ * This must be called before any other IGraphicBufferProducer methods are
+ * called except for getAllocator. A consumer must be already connected.
+ *
+ * This method will fail if the connect was previously called on the
+ * IGraphicBufferProducer and no corresponding disconnect call was made.
+ *
+ * The listener is an optional binder callback object that can be used if
+ * the producer wants to be notified when the consumer releases a buffer
+ * back to the BufferQueue. It is also used to detect the death of the
+ * producer. If only the latter functionality is desired, there is a
+ * DummyProducerListener class in IProducerListener.h that can be used.
+ *
+ * The api should be one of the NATIVE_WINDOW_API_* values in <window.h>
+ *
+ * The producerControlledByApp should be set to true if the producer is hosted
+ * by an untrusted process (typically app_process-forked processes). If both
+ * the producer and the consumer are app-controlled then all buffer queues
+ * will operate in async mode regardless of the async flag.
+ *
+ * Upon success, the output will be filled with meaningful data
+ * (refer to QueueBufferOutput documentation above).
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * NO_INIT - one of the following occurred:
+ * * the buffer queue was abandoned
+ * * no consumer has yet connected
+ * * BAD_VALUE - one of the following has occurred:
+ * * the producer is already connected
+ * * api was out of range (see above).
+ * * output was NULL.
+ * * Failure to adjust the number of available slots. This can
+ * happen because of trying to allocate/deallocate the async
+ * buffer in response to the value of producerControlledByApp.
+ * * DEAD_OBJECT - the token is hosted by an already-dead process
+ *
+ * Additional negative errors may be returned by the internals, they
+ * should be treated as opaque fatal unrecoverable errors.
+ */
+ connect(
+ IProducerListener listener,
+ int32_t api,
+ bool producerControlledByApp
+ ) generates (
+ Status status,
+ QueueBufferOutput output
+ );
+
+ /**
+ * disconnect attempts to disconnect a client API from the
+ * IGraphicBufferProducer. Calling this method will cause any subsequent
+ * calls to other IGraphicBufferProducer methods to fail except for
+ * getAllocator and connect. Successfully calling connect after this will
+ * allow the other methods to succeed again.
+ *
+ * The api should be one of the NATIVE_WINDOW_API_* values in <window.h>
+ *
+ * Alternatively if mode is AllLocal, then the API value is ignored, and any API
+ * connected from the same PID calling disconnect will be disconnected.
+ *
+ * Disconnecting from an abandoned IGraphicBufferProducer is legal and
+ * is considered a no-op.
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * BAD_VALUE - one of the following has occurred:
+ * * the api specified does not match the one that was connected
+ * * api was out of range (see above).
+ * * DEAD_OBJECT - the token is hosted by an already-dead process
+ */
+ disconnect(
+ int32_t api,
+ DisconnectMode mode /* = DisconnectMode::API */
+ ) generates (
+ Status status
+ );
+
+ /**
+ * Attaches a sideband buffer stream to the IGraphicBufferProducer.
+ *
+ * A sideband stream is a device-specific mechanism for passing buffers
+ * from the producer to the consumer without using dequeueBuffer/
+ * queueBuffer. If a sideband stream is present, the consumer can choose
+ * whether to acquire buffers from the sideband stream or from the queued
+ * buffers.
+ *
+ * Passing NULL or a different stream handle will detach the previous
+ * handle if any.
+ */
+ setSidebandStream(
+ handle stream
+ ) generates (
+ Status status
+ );
+
+ /**
+ * Allocates buffers based on the given dimensions/format.
+ *
+ * This function will allocate up to the maximum number of buffers
+ * permitted by the current BufferQueue configuration. It will use the
+ * given format, dimensions, and usage bits, which are interpreted in the
+ * same way as for dequeueBuffer, and the async flag must be set the same
+ * way as for dequeueBuffer to ensure that the correct number of buffers are
+ * allocated. This is most useful to avoid an allocation delay during
+ * dequeueBuffer. If there are already the maximum number of buffers
+ * allocated, this function has no effect.
+ */
+ allocateBuffers(
+ uint32_t width,
+ uint32_t height,
+ PixelFormat format,
+ uint32_t usage
+ );
+
+ /**
+ * Sets whether dequeueBuffer is allowed to allocate new buffers.
+ *
+ * Normally dequeueBuffer does not discriminate between free slots which
+ * already have an allocated buffer and those which do not, and will
+ * allocate a new buffer if the slot doesn't have a buffer or if the slot's
+ * buffer doesn't match the requested size, format, or usage. This method
+ * allows the producer to restrict the eligible slots to those which already
+ * have an allocated buffer of the correct size, format, and usage. If no
+ * eligible slot is available, dequeueBuffer will block or return an error
+ * as usual.
+ */
+ allowAllocation(
+ bool allow
+ ) generates (
+ Status status
+ );
+
+ /**
+ * Sets the current generation number of the BufferQueue.
+ *
+ * This generation number will be inserted into any buffers allocated by the
+ * BufferQueue, and any attempts to attach a buffer with a different
+ * generation number will fail. Buffers already in the queue are not
+ * affected and will retain their current generation number. The generation
+ * number defaults to 0.
+ */
+ setGenerationNumber(
+ uint32_t generationNumber
+ ) generates (
+ Status status
+ );
+
+ /**
+ * Returns the name of the connected consumer.
+ */
+ getConsumerName(
+ ) generates (
+ string name
+ );
+
+ /**
+ * Used to enable/disable shared buffer mode.
+ *
+ * When shared buffer mode is enabled the first buffer that is queued or
+ * dequeued will be cached and returned to all subsequent calls to
+ * dequeueBuffer and acquireBuffer. This allows the producer and consumer to
+ * simultaneously access the same buffer.
+ */
+ setSharedBufferMode(
+ bool sharedBufferMode
+ ) generates (
+ Status status
+ );
+
+ /**
+ * Used to enable/disable auto-refresh.
+ *
+ * Auto refresh has no effect outside of shared buffer mode. In shared
+ * buffer mode, when enabled, it indicates to the consumer that it should
+ * attempt to acquire buffers even if it is not aware of any being
+ * available.
+ */
+ setAutoRefresh(
+ bool autoRefresh
+ ) generates (
+ Status status
+ );
+
+ /**
+ * Sets how long dequeueBuffer will wait for a buffer to become available
+ * before returning an error (TIMED_OUT).
+ *
+ * This timeout also affects the attachBuffer call, which will block if
+ * there is not a free slot available into which the attached buffer can be
+ * placed.
+ *
+ * By default, the BufferQueue will wait forever, which is indicated by a
+ * timeout of -1. If set (to a value other than -1), this will disable
+ * non-blocking mode and its corresponding spare buffer (which is used to
+ * ensure a buffer is always available).
+ *
+ * Return of a value other than NO_ERROR means an error has occurred:
+ * * BAD_VALUE - Failure to adjust the number of available slots. This can
+ * happen because of trying to allocate/deallocate the async
+ * buffer.
+ */
+ setDequeueTimeout(
+ int64_t timeoutNs
+ ) generates (
+ Status status
+ );
+
+ /**
+ * Returns the last queued buffer along with a fence which must signal
+ * before the contents of the buffer are read. If there are no buffers in
+ * the queue, buffer.nativeHandle and fence will be null handles.
+ *
+ * transformMatrix is meaningless if buffer.nativeHandle is null.
+ */
+ getLastQueuedBuffer(
+ ) generates (
+ Status status,
+ AnwBuffer buffer,
+ Fence fence,
+ float[16] transformMatrix
+ );
+
+ /**
+ * Gets the frame events that haven't already been retrieved.
+ */
+ getFrameTimestamps(
+ ) generates (
+ FrameEventHistoryDelta timeStamps
+ );
+
+ /**
+ * Returns a unique id for this BufferQueue.
+ */
+ getUniqueId(
+ ) generates (
+ Status status,
+ uint64_t outId
+ );
+
+};
+
+