java.lang.Object | |
↳ | android.graphics.ImageFormat |
Constants | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
int | JPEG | Compressed JPEG format. | |||||||||
int | NV16 | YCbCr format, used for video. | |||||||||
int | NV21 | YCrCb format used for images, which uses the NV21 encoding format. | |||||||||
int | RAW10 |
Android 10-bit raw format This is a single-plane, 10-bit per pixel, densely packed (in each row), unprocessed format, usually representing raw Bayer-pattern images coming from an image sensor. |
|||||||||
int | RAW_SENSOR |
General raw camera sensor image format, usually representing a single-channel Bayer-mosaic image. |
|||||||||
int | RGB_565 | RGB format used for pictures encoded as RGB_565. | |||||||||
int | UNKNOWN | ||||||||||
int | YUV_420_888 |
Multi-plane Android YUV format This format is a generic YCbCr format, capable of describing any 4:2:0 chroma-subsampled planar or semiplanar buffer (but not fully interleaved), with 8 bits per color sample. |
|||||||||
int | YUY2 | YCbCr format used for images, which uses YUYV (YUY2) encoding format. | |||||||||
int | YV12 |
Android YUV format. |
Public Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Public Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Use this function to retrieve the number of bits per pixel of an
ImageFormat.
|
[Expand]
Inherited Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
java.lang.Object
|
Compressed JPEG format.
This format is always supported as an output format for the
android.hardware.camera2
API, and as a picture format for the older
Camera
API
YCbCr format, used for video.
For the android.hardware.camera2
API, the YUV_420_888
format is
recommended for YUV output instead.
Whether this format is supported by the old camera API can be determined by
getSupportedPreviewFormats()
.
YCrCb format used for images, which uses the NV21 encoding format.
This is the default format
for Camera
preview images, when not otherwise set with
setPreviewFormat(int)
.
For the android.hardware.camera2
API, the YUV_420_888
format is
recommended for YUV output instead.
Android 10-bit raw format
This is a single-plane, 10-bit per pixel, densely packed (in each row), unprocessed format, usually representing raw Bayer-pattern images coming from an image sensor.
In an image buffer with this format, starting from the first pixel of
each row, each 4 consecutive pixels are packed into 5 bytes (40 bits).
Each one of the first 4 bytes contains the top 8 bits of each pixel, The
fifth byte contains the 2 least significant bits of the 4 pixels, the
exact layout data for each 4 consecutive pixels is illustrated below
(Pi[j]
stands for the jth bit of the ith pixel):
bit 7 | bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 | |
---|---|---|---|---|---|---|---|---|
Byte 0: | P0[9] | P0[8] | P0[7] | P0[6] | P0[5] | P0[4] | P0[3] | P0[2] |
Byte 1: | P1[9] | P1[8] | P1[7] | P1[6] | P1[5] | P1[4] | P1[3] | P1[2] |
Byte 2: | P2[9] | P2[8] | P2[7] | P2[6] | P2[5] | P2[4] | P2[3] | P2[2] |
Byte 3: | P3[9] | P3[8] | P3[7] | P3[6] | P3[5] | P3[4] | P3[3] | P3[2] |
Byte 4: | P3[1] | P3[0] | P2[1] | P2[0] | P1[1] | P1[0] | P0[1] | P0[0] |
This format assumes
size = row stride * heightwhere the row stride is in bytes, not pixels.
Since this is a densely packed format, the pixel stride is always 0. The
application must use the pixel data layout defined in above table to
access each row data. When row stride is equal to width * (10 / 8)
, there
will be no padding bytes at the end of each row, the entire image data is
densely packed. When stride is larger than width * (10 / 8)
, padding
bytes will be present at the end of each row.
For example, the Image
object can provide data in
this format from a CameraDevice
(if
supported) through a ImageReader
object. The
Image#getPlanes()
will return a
single plane containing the pixel data. The pixel stride is always 0 in
getPixelStride()
, and the
getRowStride()
describes the vertical
neighboring pixel distance (in bytes) between adjacent rows.
General raw camera sensor image format, usually representing a single-channel Bayer-mosaic image. Each pixel color sample is stored with 16 bits of precision.
The layout of the color mosaic, the maximum and minimum encoding
values of the raw pixel data, the color space of the image, and all other
needed information to interpret a raw sensor image must be queried from
the CameraDevice
which produced the
image.
RGB format used for pictures encoded as RGB_565. See
setPictureFormat(int)
.
Multi-plane Android YUV format
This format is a generic YCbCr format, capable of describing any 4:2:0 chroma-subsampled planar or semiplanar buffer (but not fully interleaved), with 8 bits per color sample.
Images in this format are always represented by three separate buffers of data, one for each color plane. Additional information always accompanies the buffers, describing the row stride and the pixel stride for each plane.
The order of planes in the array returned by
Image#getPlanes()
is guaranteed such that
plane #0 is always Y, plane #1 is always U (Cb), and plane #2 is always V (Cr).
The Y-plane is guaranteed not to be interleaved with the U/V planes
(in particular, pixel stride is always 1 in
yPlane.getPixelStride()
).
The U/V planes are guaranteed to have the same row stride and pixel stride
(in particular,
uPlane.getRowStride()
== vPlane.getRowStride()
and
uPlane.getPixelStride()
== vPlane.getPixelStride()
;
).
For example, the Image
object can provide data
in this format from a CameraDevice
through a ImageReader
object.
YCbCr format used for images, which uses YUYV (YUY2) encoding format.
For the android.hardware.camera2
API, the YUV_420_888
format is
recommended for YUV output instead.
This is an alternative format for Camera
preview images. Whether
this format is supported by the camera hardware can be determined by
getSupportedPreviewFormats()
.
Android YUV format.
This format is exposed to software decoders and applications.
YV12 is a 4:2:0 YCrCb planar format comprised of a WxH Y plane followed by (W/2) x (H/2) Cr and Cb planes.
This format assumes
y_size = stride * height c_stride = ALIGN(stride/2, 16) c_size = c_stride * height/2 size = y_size + c_size * 2 cr_offset = y_size cb_offset = y_size + c_size
For the android.hardware.camera2
API, the YUV_420_888
format is
recommended for YUV output instead.
For the older camera API, this format is guaranteed to be supported for
Camera
preview images since API level 12; for earlier API versions,
check getSupportedPreviewFormats()
.
Note that for camera preview callback use (see
setPreviewCallback(Camera.PreviewCallback)
), the
stride value is the smallest possible; that is, it is equal
to:
stride = ALIGN(width, 16)
Use this function to retrieve the number of bits per pixel of an ImageFormat.