media

package
v0.0.0-...-92056c7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 17, 2024 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	MEDIA_OK = C.AMEDIA_OK

	ERROR_BASE              = C.AMEDIA_ERROR_BASE
	ERROR_UNKNOWN           = C.AMEDIA_ERROR_UNKNOWN
	ERROR_MALFORMED         = C.AMEDIA_ERROR_MALFORMED
	ERROR_UNSUPPORTED       = C.AMEDIA_ERROR_UNSUPPORTED
	ERROR_INVALID_OBJECT    = C.AMEDIA_ERROR_INVALID_OBJECT
	ERROR_INVALID_PARAMETER = C.AMEDIA_ERROR_INVALID_PARAMETER
	ERROR_INVALID_OPERATION = C.AMEDIA_ERROR_INVALID_OPERATION

	DRM_ERROR_BASE         = C.AMEDIA_DRM_ERROR_BASE
	DRM_NOT_PROVISIONED    = C.AMEDIA_DRM_NOT_PROVISIONED
	DRM_RESOURCE_BUSY      = C.AMEDIA_DRM_RESOURCE_BUSY
	DRM_DEVICE_REVOKED     = C.AMEDIA_DRM_DEVICE_REVOKED
	DRM_SHORT_BUFFER       = C.AMEDIA_DRM_SHORT_BUFFER
	DRM_SESSION_NOT_OPENED = C.AMEDIA_DRM_SESSION_NOT_OPENED
	DRM_TAMPER_DETECTED    = C.AMEDIA_DRM_TAMPER_DETECTED
	DRM_VERIFY_FAILED      = C.AMEDIA_DRM_VERIFY_FAILED
	DRM_NEED_KEY           = C.AMEDIA_DRM_NEED_KEY
	DRM_LICENSE_EXPIRED    = C.AMEDIA_DRM_LICENSE_EXPIRED

	IMGREADER_ERROR_BASE          = C.AMEDIA_IMGREADER_ERROR_BASE
	IMGREADER_NO_BUFFER_AVAILABLE = C.AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE
	IMGREADER_MAX_IMAGES_ACQUIRED = C.AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED
	IMGREADER_CANNOT_LOCK_IMAGE   = C.AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE
	IMGREADER_CANNOT_UNLOCK_IMAGE = C.AMEDIA_IMGREADER_CANNOT_UNLOCK_IMAGE
	IMGREADER_IMAGE_NOT_LOCKED    = C.AMEDIA_IMGREADER_IMAGE_NOT_LOCKED
)

Variables

This section is empty.

Functions

func Status 

func Status(i C.media_status_t) error

Types

type Formats 

type Formats int
const (
	/**
	 * 32 bits RGBA format, 8 bits for each of the four channels.
	 *
	 * <p>
	 * Corresponding formats:
	 * <ul>
	 * <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM</li>
	 * <li>Vulkan: VK_FORMAT_R8G8B8A8_UNORM</li>
	 * <li>OpenGL ES: GL_RGBA8</li>
	 * </ul>
	 * </p>
	 *
	 * @see AImage
	 * @see AImageReader
	 * @see AHardwareBuffer
	 */
	FORMAT_RGBA_8888 Formats = C.AIMAGE_FORMAT_RGBA_8888

	/**
	 * 32 bits RGBX format, 8 bits for each of the four channels.
	 *
	 * <p>
	 * Corresponding formats:
	 * <ul>
	 * <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM</li>
	 * <li>Vulkan: VK_FORMAT_R8G8B8A8_UNORM</li>
	 * <li>OpenGL ES: GL_RGBA8</li>
	 * </ul>
	 * </p>
	 *
	 * @see AImage
	 * @see AImageReader
	 * @see AHardwareBuffer
	 */
	FORMAT_RGBX_8888 Formats = C.AIMAGE_FORMAT_RGBX_8888

	/**
	 * 24 bits RGB format, 8 bits for each of the three channels.
	 *
	 * <p>
	 * Corresponding formats:
	 * <ul>
	 * <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM</li>
	 * <li>Vulkan: VK_FORMAT_R8G8B8_UNORM</li>
	 * <li>OpenGL ES: GL_RGB8</li>
	 * </ul>
	 * </p>
	 *
	 * @see AImage
	 * @see AImageReader
	 * @see AHardwareBuffer
	 */
	FORMAT_RGB_888 Formats = C.AIMAGE_FORMAT_RGB_888

	/**
	 * 16 bits RGB format, 5 bits for Red channel, 6 bits for Green channel,
	 * and 5 bits for Blue channel.
	 *
	 * <p>
	 * Corresponding formats:
	 * <ul>
	 * <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM</li>
	 * <li>Vulkan: VK_FORMAT_R5G6B5_UNORM_PACK16</li>
	 * <li>OpenGL ES: GL_RGB565</li>
	 * </ul>
	 * </p>
	 *
	 * @see AImage
	 * @see AImageReader
	 * @see AHardwareBuffer
	 */
	FORMAT_RGB_565 Formats = C.AIMAGE_FORMAT_RGB_565

	/**
	 * 64 bits RGBA format, 16 bits for each of the four channels.
	 *
	 * <p>
	 * Corresponding formats:
	 * <ul>
	 * <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT</li>
	 * <li>Vulkan: VK_FORMAT_R16G16B16A16_SFLOAT</li>
	 * <li>OpenGL ES: GL_RGBA16F</li>
	 * </ul>
	 * </p>
	 *
	 * @see AImage
	 * @see AImageReader
	 * @see AHardwareBuffer
	 */
	FORMAT_RGBA_FP16 Formats = C.AIMAGE_FORMAT_RGBA_FP16

	/**
	 * Multi-plane Android YUV 420 format.
	 *
	 * <p>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.</p>
	 *
	 * <p>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.</p>
	 *
	 * <p>The order of planes is guaranteed such that plane #0 is always Y, plane #1 is always
	 * U (Cb), and plane #2 is always V (Cr).</p>
	 *
	 * <p>The Y-plane is guaranteed not to be interleaved with the U/V planes
	 * (in particular, pixel stride is always 1 in {@link AImage_getPlanePixelStride}).</p>
	 *
	 * <p>The U/V planes are guaranteed to have the same row stride and pixel stride, that is, the
	 * return value of {@link AImage_getPlaneRowStride} for the U/V plane are guaranteed to be the
	 * same, and the return value of {@link AImage_getPlanePixelStride} for the U/V plane are also
	 * guaranteed to be the same.</p>
	 *
	 * <p>For example, the {@link AImage} object can provide data
	 * in this format from a {@link ACameraDevice} through an {@link AImageReader} object.</p>
	 *
	 * <p>This format is always supported as an output format for the android Camera2 NDK API.</p>
	 *
	 * @see AImage
	 * @see AImageReader
	 * @see ACameraDevice
	 */
	FORMAT_YUV_420_888 Formats = C.AIMAGE_FORMAT_YUV_420_888

	/**
	 * Compressed JPEG format.
	 *
	 * <p>This format is always supported as an output format for the android Camera2 NDK API.</p>
	 */
	FORMAT_JPEG Formats = C.AIMAGE_FORMAT_JPEG

	/**
	 * 16 bits per pixel raw camera sensor image format, usually representing a single-channel
	 * Bayer-mosaic image.
	 *
	 * <p>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 {@link ACameraDevice} which produced the image.</p>
	 */
	FORMAT_RAW16 Formats = C.AIMAGE_FORMAT_RAW16

	/**
	 * Private raw camera sensor image format, a single channel image with implementation depedent
	 * pixel layout.
	 *
	 * <p>AIMAGE_FORMAT_RAW_PRIVATE is a format for unprocessed raw image buffers coming from an
	 * image sensor. The actual structure of buffers of this format is implementation-dependent.</p>
	 *
	 */
	FORMAT_RAW_PRIVATE Formats = C.AIMAGE_FORMAT_RAW_PRIVATE

	/**
	 * Android 10-bit raw format.
	 *
	 * <p>
	 * 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.
	 * </p>
	 * <p>
	 * 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):
	 * </p>
	 * <table>
	 * <tr>
	 * <th align="center"></th>
	 * <th align="center">bit 7</th>
	 * <th align="center">bit 6</th>
	 * <th align="center">bit 5</th>
	 * <th align="center">bit 4</th>
	 * <th align="center">bit 3</th>
	 * <th align="center">bit 2</th>
	 * <th align="center">bit 1</th>
	 * <th align="center">bit 0</th>
	 * </tr>
	 * <tr>
	 * <td align="center">Byte 0:</td>
	 * <td align="center">P0[9]</td>
	 * <td align="center">P0[8]</td>
	 * <td align="center">P0[7]</td>
	 * <td align="center">P0[6]</td>
	 * <td align="center">P0[5]</td>
	 * <td align="center">P0[4]</td>
	 * <td align="center">P0[3]</td>
	 * <td align="center">P0[2]</td>
	 * </tr>
	 * <tr>
	 * <td align="center">Byte 1:</td>
	 * <td align="center">P1[9]</td>
	 * <td align="center">P1[8]</td>
	 * <td align="center">P1[7]</td>
	 * <td align="center">P1[6]</td>
	 * <td align="center">P1[5]</td>
	 * <td align="center">P1[4]</td>
	 * <td align="center">P1[3]</td>
	 * <td align="center">P1[2]</td>
	 * </tr>
	 * <tr>
	 * <td align="center">Byte 2:</td>
	 * <td align="center">P2[9]</td>
	 * <td align="center">P2[8]</td>
	 * <td align="center">P2[7]</td>
	 * <td align="center">P2[6]</td>
	 * <td align="center">P2[5]</td>
	 * <td align="center">P2[4]</td>
	 * <td align="center">P2[3]</td>
	 * <td align="center">P2[2]</td>
	 * </tr>
	 * <tr>
	 * <td align="center">Byte 3:</td>
	 * <td align="center">P3[9]</td>
	 * <td align="center">P3[8]</td>
	 * <td align="center">P3[7]</td>
	 * <td align="center">P3[6]</td>
	 * <td align="center">P3[5]</td>
	 * <td align="center">P3[4]</td>
	 * <td align="center">P3[3]</td>
	 * <td align="center">P3[2]</td>
	 * </tr>
	 * <tr>
	 * <td align="center">Byte 4:</td>
	 * <td align="center">P3[1]</td>
	 * <td align="center">P3[0]</td>
	 * <td align="center">P2[1]</td>
	 * <td align="center">P2[0]</td>
	 * <td align="center">P1[1]</td>
	 * <td align="center">P1[0]</td>
	 * <td align="center">P0[1]</td>
	 * <td align="center">P0[0]</td>
	 * </tr>
	 * </table>
	 * <p>
	 * This format assumes
	 * <ul>
	 * <li>a width multiple of 4 pixels</li>
	 * <li>an even height</li>
	 * </ul>
	 * </p>
	 *
	 * <pre>size = row stride * height</pre> where the row stride is in <em>bytes</em>,
	 * not pixels.
	 *
	 * <p>
	 * 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.
	 * </p>
	 * <p>
	 * For example, the {@link AImage} object can provide data in this format from a
	 * {@link ACameraDevice} (if supported) through a {@link AImageReader} object.
	 * The number of planes returned by {@link AImage_getNumberOfPlanes} will always be 1.
	 * The pixel stride is undefined ({@link AImage_getPlanePixelStride} will return
	 * {@link AMEDIA_ERROR_UNSUPPORTED}), and the {@link AImage_getPlaneRowStride} described the
	 * vertical neighboring pixel distance (in bytes) between adjacent rows.
	 * </p>
	 *
	 * @see AImage
	 * @see AImageReader
	 * @see ACameraDevice
	 */
	FORMAT_RAW10 Formats = C.AIMAGE_FORMAT_RAW10

	/**
	 * Android 12-bit raw format.
	 *
	 * <p>
	 * 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.
	 * </p>
	 * <p>
	 * 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):
	 * </p>
	 * <table>
	 * <tr>
	 * <th align="center"></th>
	 * <th align="center">bit 7</th>
	 * <th align="center">bit 6</th>
	 * <th align="center">bit 5</th>
	 * <th align="center">bit 4</th>
	 * <th align="center">bit 3</th>
	 * <th align="center">bit 2</th>
	 * <th align="center">bit 1</th>
	 * <th align="center">bit 0</th>
	 * </tr>
	 * <tr>
	 * <td align="center">Byte 0:</td>
	 * <td align="center">P0[11]</td>
	 * <td align="center">P0[10]</td>
	 * <td align="center">P0[ 9]</td>
	 * <td align="center">P0[ 8]</td>
	 * <td align="center">P0[ 7]</td>
	 * <td align="center">P0[ 6]</td>
	 * <td align="center">P0[ 5]</td>
	 * <td align="center">P0[ 4]</td>
	 * </tr>
	 * <tr>
	 * <td align="center">Byte 1:</td>
	 * <td align="center">P1[11]</td>
	 * <td align="center">P1[10]</td>
	 * <td align="center">P1[ 9]</td>
	 * <td align="center">P1[ 8]</td>
	 * <td align="center">P1[ 7]</td>
	 * <td align="center">P1[ 6]</td>
	 * <td align="center">P1[ 5]</td>
	 * <td align="center">P1[ 4]</td>
	 * </tr>
	 * <tr>
	 * <td align="center">Byte 2:</td>
	 * <td align="center">P1[ 3]</td>
	 * <td align="center">P1[ 2]</td>
	 * <td align="center">P1[ 1]</td>
	 * <td align="center">P1[ 0]</td>
	 * <td align="center">P0[ 3]</td>
	 * <td align="center">P0[ 2]</td>
	 * <td align="center">P0[ 1]</td>
	 * <td align="center">P0[ 0]</td>
	 * </tr>
	 * </table>
	 * <p>
	 * This format assumes
	 * <ul>
	 * <li>a width multiple of 4 pixels</li>
	 * <li>an even height</li>
	 * </ul>
	 * </p>
	 *
	 * <pre>size = row stride * height</pre> where the row stride is in <em>bytes</em>,
	 * not pixels.
	 *
	 * <p>
	 * 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.
	 * </p>
	 * <p>
	 * For example, the {@link AImage} object can provide data in this format from a
	 * {@link ACameraDevice} (if supported) through a {@link AImageReader} object.
	 * The number of planes returned by {@link AImage_getNumberOfPlanes} will always be 1.
	 * The pixel stride is undefined ({@link AImage_getPlanePixelStride} will return
	 * {@link AMEDIA_ERROR_UNSUPPORTED}), and the {@link AImage_getPlaneRowStride} described the
	 * vertical neighboring pixel distance (in bytes) between adjacent rows.
	 * </p>
	 *
	 * @see AImage
	 * @see AImageReader
	 * @see ACameraDevice
	 */
	FORMAT_RAW12 Formats = C.AIMAGE_FORMAT_RAW12

	/**
	 * Android dense depth image format.
	 *
	 * <p>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.</p>
	 *
	 * <p>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.</p>
	 *
	 * <p>As an example, the following sample extracts the range and confidence from the first pixel
	 * of a DEPTH16-format {@link AImage}, and converts the confidence to a floating-point value
	 * between 0 and 1.f inclusive, with 1.f representing maximum confidence:
	 *
	 * <pre>
	 *    uint16_t* data;
	 *    int dataLength;
	 *    AImage_getPlaneData(image, 0, (uint8_t**)&data, &dataLength);
	 *    uint16_t depthSample = data[0];
	 *    uint16_t depthRange = (depthSample & 0x1FFF);
	 *    uint16_t depthConfidence = ((depthSample >> 13) & 0x7);
	 *    float depthPercentage = depthConfidence == 0 ? 1.f : (depthConfidence - 1) / 7.f;
	 * </pre>
	 * </p>
	 *
	 * <p>This format assumes
	 * <ul>
	 * <li>an even width</li>
	 * <li>an even height</li>
	 * <li>a horizontal stride multiple of 16 pixels</li>
	 * </ul>
	 * </p>
	 *
	 * <pre> y_size = stride * height </pre>
	 *
	 * When produced by a camera, the units for the range are millimeters.
	 */
	FORMAT_DEPTH16 Formats = C.AIMAGE_FORMAT_DEPTH16

	/**
	 * Android sparse depth point cloud format.
	 *
	 * <p>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.</p>
	 *
	 * <p>The number of points is ((size of the buffer in bytes) / 16).
	 *
	 * <p>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.</p>
	 *
	 * <p>As an example, the following code extracts the first depth point in a DEPTH_POINT_CLOUD
	 * format {@link AImage}:
	 * <pre>
	 *    float* data;
	 *    int dataLength;
	 *    AImage_getPlaneData(image, 0, (uint8_t**)&data, &dataLength);
	 *    float x = data[0];
	 *    float y = data[1];
	 *    float z = data[2];
	 *    float confidence = data[3];
	 * </pre>
	 *
	 */
	FORMAT_DEPTH_POINT_CLOUD Formats = C.AIMAGE_FORMAT_DEPTH_POINT_CLOUD

	/**
	 * Android private opaque image format.
	 *
	 * <p>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. Also note that the contents of these buffers are not directly
	 * accessible to the application.</p>
	 *
	 * <p>When an {@link AImage} of this format is obtained from an {@link AImageReader} or
	 * {@link AImage_getNumberOfPlanes()} method will return zero.</p>
	 */
	FORMAT_PRIVATE Formats = C.AIMAGE_FORMAT_PRIVATE
)

Formats not listed here will not be supported by AImageReader

func (Formats) String 

func (f Formats) String() string

type Image 

type Image C.AImage

*

  • AImage is an opaque type that provides access to image generated by {@link AImageReader}.

typedef struct AImage AImage;

func (*Image) Delete 

func (i *Image) Delete()

*

  • Return the image back the the system and delete the AImage object from memory. *
  • <p>Do NOT use the image pointer after this method returns.
  • Note that if the parent {@link AImageReader} is closed, all the {@link AImage} objects acquired
  • from the parent reader will be returned to system. All AImage_* methods except this method will
  • return {@link AMEDIA_ERROR_INVALID_OBJECT}. Application still needs to call this method on those
  • {@link AImage} objects to fully delete the {@link AImage} object from memory.</p> *
  • @param image The {@link AImage} to be deleted.

void AImage_delete(AImage* image);

func (*Image) GetCropRect 

func (i *Image) GetCropRect() (ImageCropRect, error)

*

  • Query the cropped rectangle of the input {@link AImage}. *
  • <p>The crop rectangle specifies the region of valid pixels in the image, using coordinates in the
  • largest-resolution plane.</p> *
  • @param image the {@link AImage} of interest.
  • @param rect the cropped rectangle of the image will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or rect is NULL.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
  • image has been deleted.</li></ul>

media_status_t AImage_getCropRect(const AImage* image, /*out*/AImageCropRect* rect);

func (*Image) GetFormat 

func (i *Image) GetFormat() (Formats, error)

*

  • Query the format of the input {@link AImage}. *
  • <p>The format value will be one of AIMAGE_FORMAT_* enum value.</p> *
  • @param image the {@link AImage} of interest.
  • @param format the format of the image will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or format is NULL.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
  • image has been deleted.</li></ul>

media_status_t AImage_getFormat(const AImage* image, /*out*/int32_t* format);

func (*Image) GetHeight 

func (i *Image) GetHeight() (int, error)

*

  • Query the height of the input {@link AImage}. *
  • @param image the {@link AImage} of interest.
  • @param height the height of the image will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or height is NULL.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
  • image has been deleted.</li></ul>

media_status_t AImage_getHeight(const AImage* image, /*out*/int32_t* height);

func (*Image) GetNumberOfPlanes 

func (i *Image) GetNumberOfPlanes() (int, error)

*

  • Query the number of planes of the input {@link AImage}. *
  • <p>The number of plane of an {@link AImage} is determined by its format, which can be queried by
  • {@link AImage_getFormat} method.</p> *
  • @param image the {@link AImage} of interest.
  • @param numPlanes the number of planes of the image will be filled here if the method call
  • succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or numPlanes is NULL.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
  • image has been deleted.</li></ul>

media_status_t AImage_getNumberOfPlanes(const AImage* image, /*out*/int32_t* numPlanes);

func (*Image) GetPlaneData 

func (i *Image) GetPlaneData(planeIdx int) ([]byte, error)

*

  • Get the data pointer of the input image for direct application access. *
  • <p>Note that once the {@link AImage} or the parent {@link AImageReader} is deleted, the data
  • pointer from previous AImage_getPlaneData call becomes invalid. Do NOT use it after the
  • {@link AImage} or the parent {@link AImageReader} is deleted.</p> *
  • @param image the {@link AImage} of interest.
  • @param planeIdx the index of the plane. Must be less than the number of planes of input image.
  • @param data the data pointer of the image will be filled here if the method call succeeeds.
  • @param dataLength the valid length of data will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image, data or dataLength is NULL, or
  • planeIdx is out of the range of [0, numOfPlanes - 1].</li>
  • <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
  • image has been deleted.</li>
  • <li>{@link AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE} if the {@link AImage} cannot be locked
  • for CPU access.</li></ul>

media_status_t AImage_getPlaneData( 

const AImage* image, int planeIdx,
/*out*/uint8_t** data, /*out*/int* dataLength);

func (*Image) GetPlanePixelStride 

func (i *Image) GetPlanePixelStride(planeIdx int) (int, error)

*

  • Query the pixel stride of the input {@link AImage}. *
  • <p>This is the distance between two consecutive pixel values in a row of pixels. It may be
  • larger than the size of a single pixel to account for interleaved image data or padded formats.
  • Note that pixel stride is undefined for some formats such as {@link AIMAGE_FORMAT_RAW_PRIVATE},
  • and calling this method on images of these formats will cause {@link AMEDIA_ERROR_UNSUPPORTED}
  • being returned.
  • For formats where pixel stride is well defined, the pixel stride is always greater than 0.</p> *
  • @param image the {@link AImage} of interest.
  • @param planeIdx the index of the plane. Must be less than the number of planes of input image.
  • @param pixelStride the pixel stride of the image will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or pixelStride is NULL, or planeIdx
  • is out of the range of [0, numOfPlanes - 1].</li>
  • <li>{@link AMEDIA_ERROR_UNSUPPORTED} if pixel stride is undefined for the format of input
  • image.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
  • image has been deleted.</li>
  • <li>{@link AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE} if the {@link AImage} cannot be locked
  • for CPU access.</li></ul>

media_status_t AImage_getPlanePixelStride( 

const AImage* image, int planeIdx, /*out*/int32_t* pixelStride);

func (*Image) GetPlaneRowStride 

func (i *Image) GetPlaneRowStride(planeIdx int) (int, error)

*

  • Query the row stride of the input {@link AImage}. *
  • <p>This is the distance between the start of two consecutive rows of pixels in the image. Note
  • that row stried is undefined for some formats such as {@link AIMAGE_FORMAT_RAW_PRIVATE}, and
  • calling this method on images of these formats will cause {@link AMEDIA_ERROR_UNSUPPORTED}
  • being returned.
  • For formats where row stride is well defined, the row stride is always greater than 0.</p> *
  • @param image the {@link AImage} of interest.
  • @param planeIdx the index of the plane. Must be less than the number of planes of input image.
  • @param rowStride the row stride of the image will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or rowStride is NULL, or planeIdx
  • is out of the range of [0, numOfPlanes - 1].</li>
  • <li>{@link AMEDIA_ERROR_UNSUPPORTED} if row stride is undefined for the format of input
  • image.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
  • image has been deleted.</li>
  • <li>{@link AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE} if the {@link AImage} cannot be locked
  • for CPU access.</li></ul>

media_status_t AImage_getPlaneRowStride( 

const AImage* image, int planeIdx, /*out*/int32_t* rowStride);

func (*Image) GetTimestamp 

func (i *Image) GetTimestamp() (time.Duration, error)

*

  • Query the timestamp of the input {@link AImage}. *
  • <p>
  • The timestamp is measured in nanoseconds, and is normally monotonically increasing. The
  • timestamps for the images from different sources may have different timebases therefore may not
  • be comparable. The specific meaning and timebase of the timestamp depend on the source providing
  • images. For images generated by camera, the timestamp value will match
  • {@link ACAMERA_SENSOR_TIMESTAMP} of the {@link ACameraMetadata} in
  • {@link ACameraCaptureSession_captureCallbacks#onCaptureStarted} and
  • {@link ACameraCaptureSession_captureCallbacks#onCaptureCompleted} callback.
  • </p> *
  • @param image the {@link AImage} of interest.
  • @param timestampNs the timestamp of the image will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or timestampNs is NULL.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
  • image has been deleted.</li></ul>

media_status_t AImage_getTimestamp(const AImage* image, /*out*/int64_t* timestampNs);

func (*Image) GetWidth 

func (i *Image) GetWidth() (int, error)

*

  • Query the width of the input {@link AImage}. *
  • @param image the {@link AImage} of interest.
  • @param width the width of the image will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or width is NULL.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
  • image has been deleted.</li></ul>

media_status_t AImage_getWidth(const AImage* image, /*out*/int32_t* width);

type ImageCropRect 

type ImageCropRect C.AImageCropRect

*

  • Data type describing an cropped rectangle returned by {@link AImage_getCropRect}. *
  • <p>Note that the right and bottom coordinates are exclusive, so the width of the rectangle is
  • (right - left) and the height of the rectangle is (bottom - top).</p>
typedef struct AImageCropRect {
    int32_t left;
    int32_t top;
    int32_t right;
    int32_t bottom;
} AImageCropRect;

type ImageReader 

type ImageReader C.AImageReader

*

  • AImage is an opaque type that allows direct application access to image data rendered into a
  • {@link ANativeWindow}.

func NewImageReader 

func NewImageReader(width, height int, format Formats, maxImages int) (*ImageReader, error)

*

  • Create a new reader for images of the desired size and format. *
  • <p>
  • The maxImages parameter determines the maximum number of {@link AImage} objects that can be
  • acquired from the {@link AImageReader} simultaneously. Requesting more buffers will use up
  • more memory, so it is important to use only the minimum number necessary for the use case.
  • </p>
  • <p>
  • The valid sizes and formats depend on the source of the image data.
  • </p> *
  • @param width The default width in pixels of the Images that this reader will produce.
  • @param height The default height in pixels of the Images that this reader will produce.
  • @param format The format of the Image that this reader will produce. This must be one of the
  • AIMAGE_FORMAT_* enum value defined in {@link AIMAGE_FORMATS}. Note that not all
  • formats are supported. One example is {@link AIMAGE_FORMAT_PRIVATE}, as it is not
  • intended to be read by applications directly. That format is supported by
  • {@link AImageReader_newWithUsage} introduced in API 26.
  • @param maxImages The maximum number of images the user will want to access simultaneously. This
  • should be as small as possible to limit memory use. Once maxImages Images are obtained
  • by the user, one of them has to be released before a new {@link AImage} will become
  • available for access through {@link AImageReader_acquireLatestImage} or
  • {@link AImageReader_acquireNextImage}. Must be greater than 0.
  • @param reader The created image reader will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader is NULL, or one or more of width,
  • height, format, maxImages arguments is not supported.</li>
  • <li>{@link AMEDIA_ERROR_UNKNOWN} if the method fails for some other reasons.</li></ul> *
  • @see AImage

media_status_t AImageReader_new( 

int32_t width, int32_t height, int32_t format, int32_t maxImages,
/*out*/AImageReader** reader) __INTRODUCED_IN(24);

func (*ImageReader) AcquireLatestImage 

func (reader *ImageReader) AcquireLatestImage() (*Image, error)

*

  • Acquire the latest {@link AImage} from the image reader's queue, dropping older images. *
  • <p>
  • This operation will acquire all the images possible from the image reader, but
  • {@link AImage_delete} all images that aren't the latest. This function is recommended to use over
  • {@link AImageReader_acquireNextImage} for most use-cases, as it's more suited for real-time
  • processing.
  • </p>
  • <p>
  • Note that {@link AImageReader_getMaxImages maxImages} should be at least 2 for
  • {@link AImageReader_acquireLatestImage} to be any different than
  • {@link AImageReader_acquireNextImage} - discarding all-but-the-newest {@link AImage} requires
  • temporarily acquiring two {@link AImage}s at once. Or more generally, calling
  • {@link AImageReader_acquireLatestImage} with less than two images of margin, that is
  • (maxImages - currentAcquiredImages < 2) will not discard as expected.
  • </p>
  • <p>
  • This method will fail if {@link AImageReader_getMaxImages maxImages} have been acquired with
  • {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}. In particular
  • a sequence of {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}
  • calls greater than {@link AImageReader_getMaxImages maxImages} without calling
  • {@link AImage_delete} in-between will exhaust the underlying queue. At such a time,
  • {@link AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED} will be returned until more images are released with
  • {@link AImage_delete}.
  • </p> *
  • @param reader The image reader of interest.
  • @param image the acquired {@link AImage} will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or image is NULL.</li>
  • <li>{@link AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED} if the number of concurrently acquired
  • images has reached the limit.</li>
  • <li>{@link AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE} if there is no buffers currently
  • available in the reader queue.</li>
  • <li>{@link AMEDIA_ERROR_UNKNOWN} if the method fails for some other reasons.</li></ul> *
  • @see AImageReader_acquireNextImage

media_status_t AImageReader_acquireLatestImage(AImageReader* reader, /*out*/AImage** image) __INTRODUCED_IN(24);

func (*ImageReader) AcquireNextImage 

func (reader *ImageReader) AcquireNextImage() (*Image, error)

*

  • Acquire the next {@link AImage} from the image reader's queue. *
  • <p>Warning: Consider using {@link AImageReader_acquireLatestImage} instead, as it will
  • automatically release older images, and allow slower-running processing routines to catch
  • up to the newest frame. Usage of {@link AImageReader_acquireNextImage} is recommended for
  • batch/background processing. Incorrectly using this method can cause images to appear
  • with an ever-increasing delay, followed by a complete stall where no new images seem to appear.
  • </p> *
  • <p>
  • This method will fail if {@link AImageReader_getMaxImages maxImages} have been acquired with
  • {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}. In particular
  • a sequence of {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}
  • calls greater than {@link AImageReader_getMaxImages maxImages} without calling
  • {@link AImage_delete} in-between will exhaust the underlying queue. At such a time,
  • {@link AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED} will be returned until more images are released with
  • {@link AImage_delete}.
  • </p> *
  • @param reader The image reader of interest.
  • @param image the acquired {@link AImage} will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or image is NULL.</li>
  • <li>{@link AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED} if the number of concurrently acquired
  • images has reached the limit.</li>
  • <li>{@link AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE} if there is no buffers currently
  • available in the reader queue.</li>
  • <li>{@link AMEDIA_ERROR_UNKNOWN} if the method fails for some other reasons.</li></ul> *
  • @see AImageReader_acquireLatestImage

media_status_t AImageReader_acquireNextImage(AImageReader* reader, /*out*/AImage** image) __INTRODUCED_IN(24);

func (*ImageReader) Delete 

func (reader *ImageReader) Delete()

*

  • Delete an {@link AImageReader} and return all images generated by this reader to system. *
  • <p>This method will return all {@link AImage} objects acquired by this reader (via
  • {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}) to system,
  • making any of data pointers obtained from {@link AImage_getPlaneData} invalid. Do NOT access
  • the reader object or any of those data pointers after this method returns.</p> *
  • @param reader The image reader to be deleted.

void AImageReader_delete(AImageReader* reader) __INTRODUCED_IN(24);

func (*ImageReader) GetFormat 

func (reader *ImageReader) GetFormat() (Formats, error)

*

  • Query the format of the {@link AImage} generated by this reader. *
  • @param reader The image reader of interest.
  • @param format the fromat of the reader will be filled here if the method call succeeeds. The
  • value will be one of the AIMAGE_FORMAT_* enum value defiend in {@link NdkImage.h}. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or format is NULL.</li></ul>

media_status_t AImageReader_getFormat(const AImageReader* reader, /*out*/int32_t* format) __INTRODUCED_IN(24);

func (*ImageReader) GetHeight 

func (reader *ImageReader) GetHeight() (int, error)

*

  • Query the default height of the {@link AImage} generated by this reader, in pixels. *
  • <p>The height may be overridden by the producer sending buffers to this reader's
  • {@link ANativeWindow}. If so, the actual height of the images can be found using
  • {@link AImage_getHeight}.</p> *
  • @param reader The image reader of interest.
  • @param height the default height of the reader will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or height is NULL.</li></ul>

media_status_t AImageReader_getHeight(const AImageReader* reader, /*out*/int32_t* height) __INTRODUCED_IN(24);

func (*ImageReader) GetMaxImages 

func (reader *ImageReader) GetMaxImages() (int, error)

*

  • Query the maximum number of concurrently acquired {@link AImage}s of this reader. *
  • @param reader The image reader of interest.
  • @param maxImages the maximum number of concurrently acquired images of the reader will be filled
  • here if the method call succeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or maxImages is NULL.</li></ul>

media_status_t AImageReader_getMaxImages(const AImageReader* reader, /*out*/int32_t* maxImages) __INTRODUCED_IN(24);

func (*ImageReader) GetWidth 

func (reader *ImageReader) GetWidth() (int, error)

*

  • Query the default width of the {@link AImage} generated by this reader, in pixels. *
  • <p>The width may be overridden by the producer sending buffers to this reader's
  • {@link ANativeWindow}. If so, the actual width of the images can be found using
  • {@link AImage_getWidth}.</p> *
  • @param reader The image reader of interest.
  • @param width the default width of the reader will be filled here if the method call succeeeds. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or width is NULL.</li></ul>

media_status_t AImageReader_getWidth(const AImageReader* reader, /*out*/int32_t* width) __INTRODUCED_IN(24);

func (*ImageReader) GetWindow 

func (reader *ImageReader) GetWindow() (*ndk.Window, error)

*

  • Get a {@link ANativeWindow} that can be used to produce {@link AImage} for this image reader. *
  • @param reader The image reader of interest.
  • @param window The output {@link ANativeWindow} will be filled here if the method call succeeds.
  • The {@link ANativeWindow} is managed by this image reader. Do NOT call
  • {@link ANativeWindow_release} on it. Instead, use {@link AImageReader_delete}. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or window is NULL.</li></ul>

media_status_t AImageReader_getWindow(AImageReader* reader, /*out*/ANativeWindow** window) __INTRODUCED_IN(24);

func (*ImageReader) SetImageListener 

func (reader *ImageReader) SetImageListener(onImageAvailable func(*ImageReader)) error

*

  • Set the onImageAvailable listener of this image reader. *
  • Calling this method will replace previously registered listeners. *
  • @param reader The image reader of interest.
  • @param listener The {@link AImageReader_ImageListener} to be registered. Set this to NULL if
  • the application no longer needs to listen to new images. *
  • @return <ul>
  • <li>{@link AMEDIA_OK} if the method call succeeds.</li>
  • <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader is NULL.</li></ul>

media_status_t AImageReader_setImageListener( 

AImageReader* reader, AImageReader_ImageListener* listener) __INTRODUCED_IN(24);

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.