Causes the current thread to wait until another thread invokes the
notify() method or the
notifyAll() method for this object, or
some other thread interrupts the current thread, or a certain
amount of real time has elapsed.

Constants

DEPTH16

Each pixel is 16 bits, representing a depth ranging measurement from a depth camera or
similar sensor. The 16-bit sample consists of a confidence value and the actual ranging
measurement.

The confidence value is an estimate of correctness for this sample. It is encoded in the
3 most significant bits of the sample, with a value of 0 representing 100% confidence, a
value of 1 representing 0% confidence, a value of 2 representing 1/7, a value of 3
representing 2/7, and so on.

As an example, the following sample extracts the range and confidence from the first pixel
of a DEPTH16-format Image, and converts the confidence to a
floating-point value between 0 and 1.f inclusive, with 1.f representing maximum confidence:

DEPTH_POINT_CLOUD

A variable-length list of 3D points plus a confidence value, with each point represented
by four floats; first the X, Y, Z position coordinates, and then the confidence value.

The number of points is (size of the buffer in bytes) / 16.

The coordinate system and units of the position values depend on the source of the point
cloud data. The confidence value is between 0.f and 1.f, inclusive, with 0 representing 0%
confidence and 1.f representing 100% confidence in the measured position values.

As an example, the following code extracts the first depth point in a DEPTH_POINT_CLOUD
format Image:

FLEX_RGBA_8888

This format is a generic RGBA format, capable of describing most RGBA formats,
with 8 bits per color sample.

Images in this format are always represented by four 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 R (red), plane #1 is always G (green), plane #2 is always B (blue),
and plane #3 is always A (alpha). This format may represent pre-multiplied or
non-premultiplied alpha.

All four planes are guaranteed to have the same row strides and pixel strides.

FLEX_RGB_888

This format is a generic RGB format, capable of describing most RGB formats,
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 R (red), plane #1 is always G (green), and plane #2 is always B
(blue).

All three planes are guaranteed to have the same row strides and pixel strides.

PRIVATE

The choices of the actual format and pixel data layout are entirely up to
the device-specific and framework internal implementations, and may vary
depending on use cases even for the same device. The buffers of this
format can be produced by components like
ImageWriter , and interpreted correctly
by consumers like CameraDevice based on the device/framework private information. However,
these buffers are not directly accessible to the application.

If a buffer of this format is to be used as an OpenGL ES texture, the
framework will assume that sampling the texture will always return an
alpha value of 1.0 (i.e. the buffer contains only opaque pixel values).

RAW10

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

a width multiple of 4 pixels

an even height

size = row stride * height

where 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.

RAW12

This is a single-plane, 12-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 two consecutive pixels are packed into 3 bytes (24 bits). The first
and second byte contains the top 8 bits of first and second pixel. The third
byte contains the 4 least significant bits of the two pixels, the exact layout
data for each two 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[11]

P0[10]

P0[ 9]

P0[ 8]

P0[ 7]

P0[ 6]

P0[ 5]

P0[ 4]

Byte 1:

P1[11]

P1[10]

P1[ 9]

P1[ 8]

P1[ 7]

P1[ 6]

P1[ 5]

P1[ 4]

Byte 2:

P1[ 3]

P1[ 2]

P1[ 1]

P1[ 0]

P0[ 3]

P0[ 2]

P0[ 1]

P0[ 0]

This format assumes

a width multiple of 4 pixels

an even height

size = row stride * height

where 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 * (12 / 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 * (12 / 8), padding
bytes will be present at the end of each row.

RAW_SENSOR

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.

UNKNOWN

YUV_420_888

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()).

YUV_422_888

This format is a generic YCbCr format, capable of describing any 4:2:2
chroma-subsampled (planar, semiplanar or interleaved) format,
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).

YUV_444_888

This format is a generic YCbCr format, capable of describing any 4:4:4
(planar, semiplanar or interleaved) format,
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).