xref: /third_party/mesa3d/include/android_stub/hardware/gralloc1.h

45      * and deletes a buffer handle whenever the last reference is removed.
82      * dequeued buffer before. May be ignored by the gralloc device. */
196      * sink for this buffer. If a hardware-protected path is not available, then
197      * do not attempt to display this buffer. */
343  *   outBuffer - the buffer to write the dump output into; may be NULL as
344  *       described above; data written into this buffer need not be
361  * Creates a new, empty buffer descriptor.
364  *   outDescriptor - the new buffer descriptor
376  * Destroys an existing buffer descriptor.
379  *   descriptor - the buffer descriptor to destroy
383  *       buffer descriptor
392  * and a buffer descriptor, so these parameters are omitted from the described
400  * Sets the desired consumer usage flags of the buffer.
409  *   GRALLOC1_ERROR_BAD_DESCRIPTOR - the buffer descriptor is invalid
420  * Sets the desired width and height of the buffer in pixels.
423  * buffer, but does not necessarily represent the offset in columns between the
428  * buffer.
435  *   GRALLOC1_ERROR_BAD_DESCRIPTOR - the buffer descriptor is invalid
445  * Sets the desired format of the buffer.
453  *   GRALLOC1_ERROR_BAD_DESCRIPTOR - the buffer descriptor is invalid
465  * Sets the number of layers in the buffer.
467  * A buffer with multiple layers may be used as the backing store of an array
468  * texture. All layers of a buffer share the same characteristics (e.g.,
477  *   GRALLOC1_ERROR_BAD_DESCRIPTOR - the buffer descriptor is invalid
488  * Sets the desired producer usage flags of the buffer.
497  *   GRALLOC1_ERROR_BAD_DESCRIPTOR - the buffer descriptor is invalid
508  * and a buffer handle, so these parameters are omitted from the described
513  * from the buffer. This is necessary to enable a smooth transition from earlier
523  * Gets a value that uniquely identifies the backing store of the given buffer.
526  * function. If the buffer is present in more than one process, the backing
527  * store value for that buffer is not required to be the same in every process.
530  *   outStore - the backing store identifier for this buffer
533  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
535  *       backing store identifier from the buffer; see note [1] in this
539         gralloc1_device_t* device, buffer_handle_t buffer,
546  * Gets the consumer usage flags which were used to allocate this buffer.
551  *   outUsage - the consumer usage flags used to allocate this buffer; must be
555  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
557  *       dimensions from the buffer; see note [1] in this section's header for
561         gralloc1_device_t* device, buffer_handle_t buffer,
568  * Gets the width and height of the buffer in pixels.
573  *   outWidth - the width of the buffer in pixels, must be non-NULL
574  *   outHeight - the height of the buffer in pixels, must be non-NULL
577  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
579  *       dimensions from the buffer; see note [1] in this section's header for
583         gralloc1_device_t* device, buffer_handle_t buffer, uint32_t* outWidth,
590  * Gets the format of the buffer.
596  *   outFormat - the format of the buffer; must be non-NULL
599  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
601  *       from the buffer; see note [1] in this section's header for more
613  * Gets the number of layers of the buffer.
621  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
623  *       layer count from the buffer; see note [1] in this section's header for
627         gralloc1_device_t* device, buffer_handle_t buffer,
634  * Gets the producer usage flags which were used to allocate this buffer.
639  *   outUsage - the producer usage flags used to allocate this buffer; must be
643  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
645  *       from the buffer; see note [1] in this section's header for more
649         gralloc1_device_t* device, buffer_handle_t buffer,
656  * Gets the stride of the buffer in pixels.
660  * buffer.
666  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
674         gralloc1_device_t* device, buffer_handle_t buffer, uint32_t* outStride);
679  * Get the transport size of a buffer. An imported buffer handle is a raw
680  * buffer handle with the process-local runtime data appended. This
682  * runtime data at the tail when serializing the imported buffer handle.
685  * data when sending an imported buffer handle. The mapper must support
693  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
698         gralloc1_device_t* device, buffer_handle_t buffer, uint32_t *outNumFds,
713  * Validate that the buffer can be safely accessed by a caller who assumes
715  * that the buffer size is large enough. Validating the buffer against
716  * individual buffer attributes is optional.
719  *   descriptor - specifies the attributes of the buffer
720  *   stride - the buffer stride returned by IAllocator::allocate
723  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
724  *   GRALLOC1_ERROR_BAD_VALUE - when buffer cannot be safely accessed
725  *   GRALLOC1_ERROR_UNSUPPORTED - the device is unable to validate the buffer
729         gralloc1_device_t* device, buffer_handle_t buffer,
743  * Each buffer will correspond to one of the descriptors passed into the
749  * buffer_handle_t using release() when it is finished with the buffer. It is
763  *   numDescriptors - the number of buffer descriptors, which must also be equal
765  *   descriptors - the buffer descriptors to attempt to allocate
772  *      valid buffer descriptor
774  *       than one backing store to satisfy all of the buffer descriptors
792  * Explictly imports a buffer into a proccess.
794  * This function can be called in place of retain when a raw buffer handle is
796  * be used to access the underlying graphic buffer. The new import handle has a
805  *   rawHandle - the raw buffer handle to import
806  *   outBuffer - a handle to the newly imported buffer
809  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
811  *       buffer at this time
817 /* retain(..., buffer)
821  * Adds a reference to the given buffer.
824  * process to prevent the buffer's data from being freed when the remote process
825  * releases the buffer. It may also be called to increase the reference count if
826  * two components in the same process want to interact with the buffer
830  *   buffer - the buffer to which a reference should be added
833  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
835  *       buffer at this time
838         gralloc1_device_t* device, buffer_handle_t buffer);
840 /* release(..., buffer)
844  * Removes a reference from the given buffer.
846  * If no references remain, the buffer should be freed. When the last buffer
854  * by the caller when the buffer is not allocated locally through allocate().
857  *   buffer - the buffer from which a reference should be removed
860  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
863         gralloc1_device_t* device, buffer_handle_t buffer);
879 /* getNumFlexPlanes(..., buffer, outNumPlanes)
884  * given buffer. This may be used to efficiently allocate only as many plane
887  * If the given buffer cannot be locked as a flex format, this function may
891  *   buffer - the buffers for which the number of planes should be queried
893  *       buffer; must be non-NULL
896  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
897  *   GRALLOC1_ERROR_UNSUPPORTED - the buffer's format cannot be represented in a
901         gralloc1_device_t* device, buffer_handle_t buffer,
904 /* lock(..., buffer, producerUsage, consumerUsage, accessRegion, outData,
909  * Locks the given buffer for the specified CPU usage.
913  * applicable. Locking a buffer for a non-CPU usage is not supported.
915  * Locking the same buffer simultaneously from multiple threads is permitted,
916  * but if any of the threads attempt to lock the buffer for writing, the
918  * block the client indefinitely. Leaving the buffer content in an indeterminate
921  * The client must not modify the content of the buffer outside of accessRegion,
927  * filled with a pointer to the locked buffer memory. This address will
928  * represent the top-left corner of the entire buffer, even if accessRegion does
933  * of the buffer (prior to locking). If it is already safe to access the buffer
937  *   buffer - the buffer to lock
944  *   accessRegion - the portion of the buffer that the client intends to access;
946  *   outData - will be filled with a CPU-accessible pointer to the buffer data;
951  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
955  *   GRALLOC1_ERROR_NO_RESOURCES - the buffer cannot be locked at this time, but
957  *   GRALLOC1_ERROR_UNSUPPORTED - the buffer cannot be locked with the given
961         gralloc1_device_t* device, buffer_handle_t buffer,
967 /* lockFlex(..., buffer, producerUsage, consumerUsage, accessRegion,
973  * pointer directly to the buffer data, it returns an android_flex_layout
982  * non-YUV formats, but if the buffer format is not compatible with a flexible
986  *   buffer - the buffer to lock
993  *   accessRegion - the portion of the buffer that the client intends to access;
996  *       buffer
1000  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
1004  *   GRALLOC1_ERROR_NO_RESOURCES - the buffer cannot be locked at this time, but
1006  *   GRALLOC1_ERROR_UNSUPPORTED - the buffer cannot be locked with the given
1010         gralloc1_device_t* device, buffer_handle_t buffer,
1016 /* unlock(..., buffer, releaseFence)
1021  * buffer when releaseFence signals.
1025  * contents of the buffer (after the buffer has been unlocked). If it is already
1026  * safe to access the buffer contents, then -1 may be returned instead.
1032  *   buffer - the buffer to unlock
1036  *   GRALLOC1_ERROR_BAD_HANDLE - the buffer handle is invalid
1039         gralloc1_device_t* device, buffer_handle_t buffer,

Indexes created Thu Nov 07 10:32:03 CST 2024