HardwareBuffer
class HardwareBuffer : AutoCloseable, Parcelable
| kotlin.Any | |
| ↳ | android.hardware.HardwareBuffer |
HardwareBuffer wraps a native AHardwareBuffer object, which is a low-level object representing a memory buffer accessible by various hardware units. HardwareBuffer allows sharing buffers across different application processes. In particular, HardwareBuffers may be mappable to memory accessible to various hardware systems, such as the GPU, a sensor or context hub, or other auxiliary processing units. For more information, see the NDK documentation for AHardwareBuffer.
Summary
| Constants | |
|---|---|
| static Int |
32-bit packed format that has 2-bit A, 10-bit R, G, and B components, in that order, from the most-significant bits to the least-significant bits. |
| static Int |
32-bit packed format that has 2-bit unused, 10-bit R, G, and B components, in that order, from the most-significant bits to the least-significant bits. |
| static Int |
Format: opaque format used for raw data transfer; must have a height of 1 |
| static Int |
Format: 24 bits depth, 8 bits stencil |
| static Int |
Format: 32 bits depth, 8 bits stencil |
| static Int |
Format: 16 bits depth |
| static Int |
Format: 24 bits depth |
| static Int |
Format: 32 bits depth |
| static Int |
Format: 10 bits each red, green, blue, alpha |
| static Int |
Format: 10 bits each red, green, blue, 2 bits alpha |
| static Int |
Value is one of the following: |
| static Int |
Format: 16 bits each red, green, blue, alpha |
| static Int |
Format: 8 bits each red, green, blue, alpha, alpha is always 0xFF |
| static Int |
Format: 5 bits each red and blue, 6 bits green, no alpha |
| static Int |
Format: 8 bits each red, green, blue, no alpha |
| static Int |
Format: 16 bits each red, green. |
| static Int |
Format: 16 bits red. |
| static Int |
Format: 8 bits red |
| static Int |
Format: 8 bits stencil |
| static Long |
The buffer will be used as a hardware composer overlay layer. |
| static Long |
Usage: The buffer will often be read by the CPU |
| static Long |
Value is either
|
| static Long |
Usage: The buffer will often be written to by the CPU |
| static Long |
Usage: The buffer will sometimes be written to by the CPU |
| static Long |
Usage: The buffer is used for front-buffer rendering. |
| static Long |
Usage: The buffer will be written to by the GPU |
| static Long |
Usage: The buffer will be used as a cube map texture |
| static Long |
Usage: The buffer will be used as a shader storage or uniform buffer object |
| static Long |
Usage: The buffer contains a complete mipmap hierarchy |
| static Long |
Usage: The buffer will be read from by the GPU |
| static Long |
Usage: The buffer must not be used outside of a protected hardware path |
| static Long |
Usage: The buffer will be used for sensor direct data |
| static Long |
Usage: The buffer will be read by a hardware video encoder |
| static Int |
Format: Planar YCbCr 420; must have an even width and height |
| static Int |
Android YUV P010 format. |
| static Int |
Android YUV P210 format. |
| Inherited constants | |
|---|---|
| Public methods | |
|---|---|
| Unit |
close()Destroys this buffer immediately. |
| static HardwareBuffer |
Creates a new |
| Int |
Describe the kinds of special objects contained in this Parcelable instance's marshaled representation. |
| Int |
Returns the @Format of this buffer. |
| Int |
Returns the height of this buffer in pixels. |
| Long |
getId()Returns the system-wide unique id for this buffer This can be useful as a cache key for associating additional objects with a given HardwareBuffer, such as associating an imported EGLImage with the target HardwareBuffer when processing a stream of buffers from ImageReader. |
| Int |
Returns the number of layers in this buffer. |
| Long |
getUsage()Returns the usage flags of the usage hints set on this buffer. |
| Int |
getWidth()Returns the width of this buffer in pixels. |
| Boolean |
isClosed()Indicates whether this buffer has been closed. |
| static Boolean |
Queries whether the given buffer description is supported by the system. |
| Unit |
writeToParcel(dest: Parcel, flags: Int)Flatten this object in to a Parcel. |
| Protected methods | |
|---|---|
| Unit |
finalize()Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. |
| Properties | |
|---|---|
| static Parcelable.Creator<HardwareBuffer!> | |
Constants
BGRA_1010102
static val BGRA_1010102: Int
32-bit packed format that has 2-bit A, 10-bit R, G, and B components, in that order, from the most-significant bits to the least-significant bits. The component values are unsigned normalized to the range [0, 1], whose interpretation is defined by the dataspace.
Value: 67BGRX_1010102
static val BGRX_1010102: Int
32-bit packed format that has 2-bit unused, 10-bit R, G, and B components, in that order, from the most-significant bits to the least-significant bits. The component values are unsigned normalized to the range [0, 1], whose interpretation is defined by the dataspace.
Value: 68BLOB
static val BLOB: Int
Format: opaque format used for raw data transfer; must have a height of 1
Value: 33DS_24UI8
static val DS_24UI8: Int
Format: 24 bits depth, 8 bits stencil
Value: 50DS_FP32UI8
static val DS_FP32UI8: Int
Format: 32 bits depth, 8 bits stencil
Value: 52RGBA_10101010
static val RGBA_10101010: Int
Format: 10 bits each red, green, blue, alpha
Value: 59RGBA_1010102
static val RGBA_1010102: Int
Format: 10 bits each red, green, blue, 2 bits alpha
Value: 43RGBA_8888
static val RGBA_8888: Int
Value is one of the following:
RGBA_8888RGBA_FP16RGBA_1010102RGBX_8888RGB_888RGB_565BLOBYCBCR_420_888D_16D_24DS_24UI8D_FP32DS_FP32UI8S_UI8YCBCR_P010YCBCR_P210R_8R_16RG_1616RGBA_10101010BGRA_1010102BGRX_1010102
Value: 1RGBA_FP16
static val RGBA_FP16: Int
Format: 16 bits each red, green, blue, alpha
Value: 22RGBX_8888
static val RGBX_8888: Int
Format: 8 bits each red, green, blue, alpha, alpha is always 0xFF
Value: 2RGB_565
static val RGB_565: Int
Format: 5 bits each red and blue, 6 bits green, no alpha
Value: 4RGB_888
static val RGB_888: Int
Format: 8 bits each red, green, blue, no alpha
Value: 3RG_1616
static val RG_1616: Int
Format: 16 bits each red, green. When sampled on the GPU this is represented as an unsigned integer instead of implicit unsigned normalize. For more information see https://www.khronos.org/opengl/wiki/Normalized_Integer
Value: 58R_16
static val R_16: Int
Format: 16 bits red. When sampled on the GPU this is represented as an unsigned integer instead of implicit unsigned normalize. For more information see https://www.khronos.org/opengl/wiki/Normalized_Integer
Value: 57USAGE_COMPOSER_OVERLAY
static val USAGE_COMPOSER_OVERLAY: Long
The buffer will be used as a hardware composer overlay layer. That is, it will be displayed using the system compositor via SurfaceControl This flag is currently only needed when using android.view.SurfaceControl.Transaction#setBuffer(SurfaceControl, HardwareBuffer) to set a buffer. In all other cases, the framework adds this flag internally to buffers that could be presented in a composer overlay.
Value: 2048LUSAGE_CPU_READ_OFTEN
static val USAGE_CPU_READ_OFTEN: Long
Usage: The buffer will often be read by the CPU
Value: 3LUSAGE_CPU_READ_RARELY
static val USAGE_CPU_READ_RARELY: Long
Value is either 0 or a combination of the following:
USAGE_CPU_READ_RARELYUSAGE_CPU_READ_OFTENUSAGE_CPU_WRITE_RARELYUSAGE_CPU_WRITE_OFTENUSAGE_GPU_SAMPLED_IMAGEUSAGE_GPU_COLOR_OUTPUTUSAGE_COMPOSER_OVERLAYUSAGE_PROTECTED_CONTENTUSAGE_VIDEO_ENCODEUSAGE_GPU_DATA_BUFFERUSAGE_SENSOR_DIRECT_DATAUSAGE_GPU_CUBE_MAPUSAGE_GPU_MIPMAP_COMPLETEUSAGE_FRONT_BUFFER
Value: 2LUSAGE_CPU_WRITE_OFTEN
static val USAGE_CPU_WRITE_OFTEN: Long
Usage: The buffer will often be written to by the CPU
Value: 48LUSAGE_CPU_WRITE_RARELY
static val USAGE_CPU_WRITE_RARELY: Long
Usage: The buffer will sometimes be written to by the CPU
Value: 32LUSAGE_FRONT_BUFFER
static val USAGE_FRONT_BUFFER: Long
Usage: The buffer is used for front-buffer rendering. When front-buffering rendering is specified, different usages may adjust their behavior as a result. For example, when used as USAGE_GPU_COLOR_OUTPUT the buffer will behave similar to a single-buffered window. When used with USAGE_COMPOSER_OVERLAY, the system will try to prioritize the buffer receiving an overlay plane & avoid caching it in intermediate composition buffers.
Value: 4294967296LUSAGE_GPU_COLOR_OUTPUT
static val USAGE_GPU_COLOR_OUTPUT: Long
Usage: The buffer will be written to by the GPU
Value: 512LUSAGE_GPU_CUBE_MAP
static val USAGE_GPU_CUBE_MAP: Long
Usage: The buffer will be used as a cube map texture
Value: 33554432LUSAGE_GPU_DATA_BUFFER
static val USAGE_GPU_DATA_BUFFER: Long
Usage: The buffer will be used as a shader storage or uniform buffer object
Value: 16777216LUSAGE_GPU_MIPMAP_COMPLETE
static val USAGE_GPU_MIPMAP_COMPLETE: Long
Usage: The buffer contains a complete mipmap hierarchy
Value: 67108864LUSAGE_GPU_SAMPLED_IMAGE
static val USAGE_GPU_SAMPLED_IMAGE: Long
Usage: The buffer will be read from by the GPU
Value: 256LUSAGE_PROTECTED_CONTENT
static val USAGE_PROTECTED_CONTENT: Long
Usage: The buffer must not be used outside of a protected hardware path
Value: 16384LUSAGE_SENSOR_DIRECT_DATA
static val USAGE_SENSOR_DIRECT_DATA: Long
Usage: The buffer will be used for sensor direct data
Value: 8388608LUSAGE_VIDEO_ENCODE
static val USAGE_VIDEO_ENCODE: Long
Usage: The buffer will be read by a hardware video encoder
Value: 65536LYCBCR_420_888
static val YCBCR_420_888: Int
Format: Planar YCbCr 420; must have an even width and height
Value: 35YCBCR_P010
static val YCBCR_P010: Int
Android YUV P010 format.
P010 is a 4:2:0 YCbCr semiplanar format comprised of a WxH Y plane followed by a Wx(H/2) CbCr plane. Each sample is represented by a 16-bit little-endian value, with the lower 6 bits set to zero.Value: 54YCBCR_P210
static val YCBCR_P210: Int
Android YUV P210 format.
P210 is a 4:2:2 YCbCr semiplanar format comprised of a WxH Y plane followed by a WxH CbCr plane. Each sample is represented by a 16-bit little-endian value, with the lower 6 bits set to zero.Value: 60Public methods
close
fun close(): Unit
Destroys this buffer immediately. Calling this method frees up any underlying native resources. After calling this method, this buffer must not be used in any way.
| Exceptions | |
|---|---|
java.lang.Exception |
if this resource cannot be closed |
See Also
create
static fun create(
width: Int,
height: Int,
format: Int,
layers: Int,
usage: Long
): HardwareBuffer
Creates a new HardwareBuffer instance.
Calling this method will throw an IllegalStateException if format is not a supported Format type.
| Parameters | |
|---|---|
width |
Int: The width in pixels of the buffer. Value is 1 or greater |
height |
Int: The height in pixels of the buffer. Value is 1 or greater |
format |
Int: The @Format of each pixel. Value is one of the following: |
layers |
Int: The number of layers in the buffer. Value is 1 or greater |
usage |
Long: The @Usage flags describing how the buffer will be used. Value is either 0 or a combination of the following:
|
| Return | |
|---|---|
HardwareBuffer |
A HardwareBuffer instance if successful, or throws an IllegalArgumentException if the dimensions passed are invalid (either zero, negative, or too large to allocate), if the format is not supported, if the requested number of layers is less than one or not supported, or if the passed usage flags are not a supported set. This value cannot be null. |
describeContents
fun describeContents(): Int
Describe the kinds of special objects contained in this Parcelable instance's marshaled representation. For example, if the object will include a file descriptor in the output of writeToParcel(android.os.Parcel,int), the return value of this method must include the CONTENTS_FILE_DESCRIPTOR bit.
| Return | |
|---|---|
Int |
a bitmask indicating the set of special object types marshaled by this Parcelable object instance. Value is either 0 or
|
getFormat
fun getFormat(): Int
Returns the @Format of this buffer.
| Return | |
|---|---|
Int |
Value is one of the following: |
getId
fun getId(): Long
Returns the system-wide unique id for this buffer This can be useful as a cache key for associating additional objects with a given HardwareBuffer, such as associating an imported EGLImage with the target HardwareBuffer when processing a stream of buffers from ImageReader. This can also be useful for doing cross-process buffer caching. As sending a HardwareBuffer over Binder is slower than sending a long, this can be used as reliable cache key after an initial handshake that passes the HardwareBuffers themselves to later be referred to using only the id.
getUsage
fun getUsage(): Long
Returns the usage flags of the usage hints set on this buffer.
isClosed
fun isClosed(): Boolean
Indicates whether this buffer has been closed. A closed buffer cannot be used in any way: the buffer cannot be written to a parcel, etc.
| Return | |
|---|---|
Boolean |
True if this HardwareBuffer is in a closed state, false otherwise. |
See Also
isSupported
static fun isSupported(
width: Int,
height: Int,
format: Int,
layers: Int,
usage: Long
): Boolean
Queries whether the given buffer description is supported by the system. If this returns true, then the allocation may succeed until resource exhaustion occurs. If this returns false then this combination will never succeed.
| Parameters | |
|---|---|
width |
Int: The width in pixels of the buffer. Value is 1 or greater |
height |
Int: The height in pixels of the buffer. Value is 1 or greater |
format |
Int: The @Format of each pixel. Value is one of the following: |
layers |
Int: The number of layers in the buffer. Value is 1 or greater |
usage |
Long: The @Usage flags describing how the buffer will be used. Value is either 0 or a combination of the following:
|
| Return | |
|---|---|
Boolean |
True if the combination is supported, false otherwise. |
writeToParcel
fun writeToParcel(
dest: Parcel,
flags: Int
): Unit
Flatten this object in to a Parcel.
Calling this method will throw an IllegalStateException if close() has been previously called.
| Parameters | |
|---|---|
dest |
Parcel: The Parcel in which the object should be written. |
flags |
Int: Additional flags about how the object should be written. May be 0 or PARCELABLE_WRITE_RETURN_VALUE. |
Protected methods
finalize
protected fun finalize(): Unit
Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A subclass overrides the finalize method to dispose of system resources or to perform other cleanup.
The general contract of finalize is that it is invoked if and when the Java virtual machine has determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, except as a result of an action taken by the finalization of some other object or class which is ready to be finalized. The finalize method may take any action, including making this object available again to other threads; the usual purpose of finalize, however, is to perform cleanup actions before the object is irrevocably discarded. For example, the finalize method for an object that represents an input/output connection might perform explicit I/O transactions to break the connection before the object is permanently discarded.
The finalize method of class Object performs no special action; it simply returns normally. Subclasses of Object may override this definition.
The Java programming language does not guarantee which thread will invoke the finalize method for any given object. It is guaranteed, however, that the thread that invokes finalize will not be holding any user-visible synchronization locks when finalize is invoked. If an uncaught exception is thrown by the finalize method, the exception is ignored and finalization of that object terminates.
After the finalize method has been invoked for an object, no further action is taken until the Java virtual machine has again determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, including possible actions by other objects or classes which are ready to be finalized, at which point the object may be discarded.
The finalize method is never invoked more than once by a Java virtual machine for any given object.
Any exception thrown by the finalize method causes the finalization of this object to be halted, but is otherwise ignored.
| Exceptions | |
|---|---|
java.lang.Throwable |
the Exception raised by this method |