709 lines
28 KiB
Text
709 lines
28 KiB
Text
/*
|
|
* Copyright (C) 2016 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.media.omx@1.0;
|
|
|
|
import android.hardware.graphics.common@1.0::Dataspace;
|
|
import android.hardware.graphics.common@1.0::PixelFormat;
|
|
|
|
import android.hardware.media@1.0::types;
|
|
import IOmxProducerListener;
|
|
|
|
/**
|
|
* Ref: frameworks/native/include/gui/IGraphicBufferProducer.h:
|
|
* IGraphicBufferProducer
|
|
* This is a wrapper/wrapped HAL interface for the actual binder interface.
|
|
*/
|
|
interface IOmxBufferProducer {
|
|
|
|
/**
|
|
* 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 IOmxBufferProducer 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 IOmxBufferProducer.
|
|
* This must be called before any other IOmxBufferProducer methods are
|
|
* called except for getAllocator. A consumer must be already connected.
|
|
*
|
|
* This method will fail if the connect was previously called on the
|
|
* IOmxBufferProducer 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(
|
|
IOmxProducerListener listener,
|
|
int32_t api,
|
|
bool producerControlledByApp
|
|
) generates (
|
|
Status status,
|
|
QueueBufferOutput output
|
|
);
|
|
|
|
/**
|
|
* disconnect attempts to disconnect a client API from the
|
|
* IOmxBufferProducer. Calling this method will cause any subsequent
|
|
* calls to other IOmxBufferProducer 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 IOmxBufferProducer 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 IOmxBufferProducer.
|
|
*
|
|
* 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
|
|
);
|
|
|
|
};
|
|
|
|
|