Impact Acquire SDK Java
Static Public Attributes | List of all members
TImageDestinationPixelFormat Class Reference
Common

Defines the pixel format of the result image. More...

Static Public Attributes

static final int idpfAuto = acquireJNI.idpfAuto_get()
 The driver will decide which destination format will be used.
 
static final int idpfBGR101010Packed_V2 = acquireJNI.idpfBGR101010Packed_V2_get()
 A three channel 10 bit per color component RGB packed format occupying 32 bit per pixel.
 
static final int idpfBGR888Packed = acquireJNI.idpfBGR888Packed_get()
 A three channel interleaved RGB format with 24 bit per pixel.
 
static final int idpfMono10 = acquireJNI.idpfMono10_get()
 A single channel 10 bit per pixel format.
 
static final int idpfMono12 = acquireJNI.idpfMono12_get()
 A single channel 12 bit per pixel format.
 
static final int idpfMono12Packed_V1 = acquireJNI.idpfMono12Packed_V1_get()
 A single channel 12 bit per pixel packed format occupying 12 bit per pixel.
 
static final int idpfMono12Packed_V2 = acquireJNI.idpfMono12Packed_V2_get()
 A single channel 12 bit per pixel packed format occupying 12 bit per pixel.
 
static final int idpfMono14 = acquireJNI.idpfMono14_get()
 A single channel 14 bit per pixel format.
 
static final int idpfMono16 = acquireJNI.idpfMono16_get()
 A single channel 16 bit per pixel format.
 
static final int idpfMono8 = acquireJNI.idpfMono8_get()
 A single channel 8 bit per pixel format.
 
static final int idpfRaw = acquireJNI.idpfRaw_get()
 An unprocessed block of data.
 
static final int idpfRGB101010Packed = acquireJNI.idpfRGB101010Packed_get()
 A three channel interleaved RGB image occupying 48 bit with 30 bit of usable data per pixel.
 
static final int idpfRGB121212Packed = acquireJNI.idpfRGB121212Packed_get()
 A three channel interleaved RGB image occupying 48 bit with 36 bit of usable data per pixel.
 
static final int idpfRGB141414Packed = acquireJNI.idpfRGB141414Packed_get()
 A three channel interleaved RGB image occupying 48 bit with 42 bit of usable data per pixel.
 
static final int idpfRGB161616Packed = acquireJNI.idpfRGB161616Packed_get()
 A three channel interleaved RGB image occupying 48 bit per pixel.
 
static final int idpfRGB888Packed = acquireJNI.idpfRGB888Packed_get()
 A three channel interleaved RGB format containing 24 bit per pixel.
 
static final int idpfRGB888Planar = acquireJNI.idpfRGB888Planar_get()
 A three channel planar RGB format.
 
static final int idpfRGBx888Packed = acquireJNI.idpfRGBx888Packed_get()
 A four channel interleaved RGB format with 32 bit per pixel containing one alpha byte per pixel.
 
static final int idpfRGBx888Planar = acquireJNI.idpfRGBx888Planar_get()
 A four channel planar RGB format.
 
static final int idpfYUV411_UYYVYY_Packed = acquireJNI.idpfYUV411_UYYVYY_Packed_get()
 A three channel interleaved YUV format occupying 48 bit for four pixels.
 
static final int idpfYUV422_10Packed = acquireJNI.idpfYUV422_10Packed_get()
 A three channel interleaved YUV422 format occupying 64 bit for a pair of pixels.
 
static final int idpfYUV422_UYVY_10Packed = acquireJNI.idpfYUV422_UYVY_10Packed_get()
 A three channel interleaved YUV422 format occupying 64 bit for a pair of pixels.
 
static final int idpfYUV422_UYVYPacked = acquireJNI.idpfYUV422_UYVYPacked_get()
 A three channel interleaved YUV422 format occupying 32 bit for a pair of pixels.
 
static final int idpfYUV422Packed = acquireJNI.idpfYUV422Packed_get()
 A three channel interleaved YUV422 format using 32 bit for a pair of pixels.
 
static final int idpfYUV422Planar = acquireJNI.idpfYUV422Planar_get()
 A three channel planar YUV422 format.
 
static final int idpfYUV444_10Packed = acquireJNI.idpfYUV444_10Packed_get()
 A three channel interleaved YUV format occupying 48 bit per pixel with 30 bit of usable data per pixel.
 
static final int idpfYUV444_UYV_10Packed = acquireJNI.idpfYUV444_UYV_10Packed_get()
 A three channel interleaved YUV format occupying 48 bit per pixel with 30 bit of usable data per pixel.
 
static final int idpfYUV444_UYVPacked = acquireJNI.idpfYUV444_UYVPacked_get()
 A three channel interleaved YUV format occupying 24 bit per pixel.
 
static final int idpfYUV444Packed = acquireJNI.idpfYUV444Packed_get()
 A three channel interleaved YUV format occupying 24 bit per pixel.
 

Detailed Description

Defines the pixel format of the result image.

Also refer to Pixel Formats in Impact Acquire and Other Contexts

Member Data Documentation

◆ idpfAuto

final int idpfAuto = acquireJNI.idpfAuto_get()
static

The driver will decide which destination format will be used.

◆ idpfBGR101010Packed_V2

final int idpfBGR101010Packed_V2 = acquireJNI.idpfBGR101010Packed_V2_get()
static

A three channel 10 bit per color component RGB packed format occupying 32 bit per pixel.

(PFNC name: RGB10p32)

This format will use 4 bytes to store one 10 bit per color component RGB pixel. The following memory layout is used for each pixel:

byte 0 | byte 1 | byte 2 | byte 3 |
0 7 | 890....5 | 6..90..3 | 4 9xx |
RRRRRRRR | RRGGGGGG | GGGGBBBB | BBBBBB |

The last 2 bit of each 32 bit bit may contain undefined data.

See also
Converting packed data to planar formats

◆ idpfBGR888Packed

final int idpfBGR888Packed = acquireJNI.idpfBGR888Packed_get()
static

A three channel interleaved RGB format with 24 bit per pixel.

(PFNC name: RGB8)

This is an interleaved pixel format suitable for most processing functions. Most blit/display function however will expect idpfRGB888Packed. The data is stored pixel-wise:

3 bytes 3 bytes 3 bytes etc.
R(1)G(1)B(1) R(2)G(2)B(2) R(3)G(3)B(3) etc.
..........................................
........................... R(n)G(n)B(n)

So the first byte in memory is the first pixels red component. ImageBuffer.vpData will therefore point to R(1) when using a byte pointer.

See also
Converting packed data to planar formats

◆ idpfMono10

final int idpfMono10 = acquireJNI.idpfMono10_get()
static

A single channel 10 bit per pixel format.

(PFNC name: Mono10)

Each pixel in this format consumes 2 bytes of memory. The lower 10 bit of this 2 bytes will contain valid data.

◆ idpfMono12

final int idpfMono12 = acquireJNI.idpfMono12_get()
static

A single channel 12 bit per pixel format.

(PFNC name: Mono12)

Each pixel in this format consumes 2 bytes of memory. The lower 12 bit of this 2 bytes will contain valid data.

◆ idpfMono12Packed_V1

final int idpfMono12Packed_V1 = acquireJNI.idpfMono12Packed_V1_get()
static

A single channel 12 bit per pixel packed format occupying 12 bit per pixel.

(PFNC name: Mono12p)

This format will use 3 bytes to store 2 12 bit pixel. Every 3 bytes will use the following layout in memory:

3 bytes 3 bytes etc.
bits 0..7(1) bits 8..11(1) bits 0..3(2) bits 4..11(2) bits 0..7(3) bits 8..11(3) bits 0..3(4) bits 4..11(4) etc.
Note
When the width is not divisible by 2 the line pitch of a buffer can't be used to calculate line start offsets in a buffer! In that case something like this can be used to access a certain pixel (pseudo code assuming 'pointerToStartOfTheBuffer' is a 'byte pointer'):
GetMono12Packed_V1Pixel( pointerToStartOfTheBuffer, pixelIndex )
const int offsetFromStartOfTheBuffer = pixel + pixel/2
if pixel divisible by 2
return (pointerToStartOfTheBuffer[offset] >> 4) | (pointerToStartOfTheBuffer[offset+1] << 4)
return pointerToStartOfTheBuffer[offset]) | (pointerToStartOfTheBuffer[offset+1] & 0xF) << 8)
Since
2.5.0

◆ idpfMono12Packed_V2

final int idpfMono12Packed_V2 = acquireJNI.idpfMono12Packed_V2_get()
static

A single channel 12 bit per pixel packed format occupying 12 bit per pixel.

(PFNC name: Mono12Packed)

This format will use 3 bytes to store 2 12 bit pixel. Every 3 bytes will use the following layout in memory:

3 bytes 3 bytes etc.
bits 11..4(1) bits 3..0(1) bits 3..0(2) bits 11..4(2) bits 11..4(3) bits 3..0(3) bits 3..0(4) bits 11..4(4) etc.
Note
When the width is not divisible by 2 the line pitch of a buffer can't be used to calculate line start offsets in a buffer! In that case something like this can be used to access a certain pixel (pseudo code assuming 'pointerToStartOfTheBuffer' is a 'byte pointer'):
GetMono12Packed_V1Pixel( pointerToStartOfTheBuffer, pixelIndex )
const int offsetFromStartOfTheBuffer = (3*pixel)/2
if pixel divisible by 2
return (pointerToStartOfTheBuffer[offset+1] << shift) | (pointerToStartOfTheBuffer[offset] >> 4)
return pointerToStartOfTheBuffer[offset] << shift) | (pointerToStartOfTheBuffer[offset+1] & 0xF)

◆ idpfMono14

final int idpfMono14 = acquireJNI.idpfMono14_get()
static

A single channel 14 bit per pixel format.

(PFNC name: Mono14)

Each pixel in this format consumes 2 bytes of memory. The lower 14 bit of this 2 bytes will contain valid data.

◆ idpfMono16

final int idpfMono16 = acquireJNI.idpfMono16_get()
static

A single channel 16 bit per pixel format.

(PFNC name: Mono16)

◆ idpfMono8

final int idpfMono8 = acquireJNI.idpfMono8_get()
static

A single channel 8 bit per pixel format.

(PFNC name: Mono8)

◆ idpfRaw

final int idpfRaw = acquireJNI.idpfRaw_get()
static

An unprocessed block of data.

◆ idpfRGB101010Packed

final int idpfRGB101010Packed = acquireJNI.idpfRGB101010Packed_get()
static

A three channel interleaved RGB image occupying 48 bit with 30 bit of usable data per pixel.

(PFNC name: BGR10)

This is an interleaved pixel format with 2 bytes per color component. The data is stored pixel-wise:

6 bytes 6 bytes 6 bytes etc.
B(1)G(1)R(1) B(2)G(2)R(2) B(3)G(3)R(3) etc.
..........................................
........................... B(n)G(n)R(n)

The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will not contain valid data.

So the first 2 bytes in memory are the first pixels blue component. ImageBuffer.vpData will therefore point to B(1) when using a 16 bit pointer.

See also
Converting packed data to planar formats

◆ idpfRGB121212Packed

final int idpfRGB121212Packed = acquireJNI.idpfRGB121212Packed_get()
static

A three channel interleaved RGB image occupying 48 bit with 36 bit of usable data per pixel.

(PFNC name: BGR12)

This is an interleaved pixel format with 2 bytes per color component. The data is stored pixel-wise:

6 bytes 6 bytes 6 bytes etc.
B(1)G(1)R(1) B(2)G(2)R(2) B(3)G(3)R(3) etc.
..........................................
........................... B(n)G(n)R(n)

The data of each color component will be LSB aligned, thus the 4 MSB of each 16 bit will not contain valid data.

So the first 2 bytes in memory are the first pixels blue component. ImageBuffer.vpData will therefore point to B(1) when using a 16 bit pointer.

See also
Converting packed data to planar formats

◆ idpfRGB141414Packed

final int idpfRGB141414Packed = acquireJNI.idpfRGB141414Packed_get()
static

A three channel interleaved RGB image occupying 48 bit with 42 bit of usable data per pixel.

(PFNC name: BGR14)

This is an interleaved pixel format with 2 bytes per color component. The data is stored pixel-wise:

6 bytes 6 bytes 6 bytes etc.
B(1)G(1)R(1) B(2)G(2)R(2) B(3)G(3)R(3) etc.
..........................................
........................... B(n)G(n)R(n)

The data of each color component will be LSB aligned, thus the 2 MSB of each 16 bit will not contain valid data.

So the first 2 bytes in memory are the first pixels blue component. ImageBuffer.vpData will therefore point to B(1) when using a 16 bit pointer.

See also
Converting packed data to planar formats

◆ idpfRGB161616Packed

final int idpfRGB161616Packed = acquireJNI.idpfRGB161616Packed_get()
static

A three channel interleaved RGB image occupying 48 bit per pixel.

(PFNC name: BGR16)

This is an interleaved pixel format with 2 bytes per color component. The data is stored pixel-wise:

6 bytes 6 bytes 6 bytes etc.
B(1)G(1)R(1) B(2)G(2)R(2) B(3)G(3)R(3) etc.
..........................................
........................... B(n)G(n)R(n)

The data of each color component will be LSB aligned.

So the first 2 bytes in memory are the first pixels blue component. ImageBuffer.vpData will therefore point to B(1) when using a 16 bit pointer.

See also
Converting packed data to planar formats

◆ idpfRGB888Packed

final int idpfRGB888Packed = acquireJNI.idpfRGB888Packed_get()
static

A three channel interleaved RGB format containing 24 bit per pixel.

(PFNC name: BGR8)

This is an interleaved pixel format suitable for most display and processing functions. The data is stored pixel-wise:

3 bytes 3 bytes 3 bytes etc.
B(1)G(1)R(1) B(2)G(2)R(2) B(3)G(3)R(3) etc.
..........................................
........................... B(n)G(n)R(n)

So the first byte in memory is the first pixels blue component. ImageBuffer.vpData will therefore point to B(1) when using a byte pointer.

See also
Converting packed data to planar formats

◆ idpfRGB888Planar

final int idpfRGB888Planar = acquireJNI.idpfRGB888Planar_get()
static

A three channel planar RGB format.

(PFNC name: RGB8_Planar)

This is a format best suitable for most image processing functions. The image will be converted into 3 planes(a plane for each color component).

R(1) R(2) R(3) R(4) etc.
...................
.............. R(n)
G(1) G(2) G(3) G(4) etc.
...................
.............. G(n)
B(1) B(2) B(3) B(4) etc.
...................
.............. B(n)

So the first byte in memory is the first pixels red component. ImageBuffer.vpData will therefore point to R(1) when using a byte pointer.

Since
2.17.0

◆ idpfRGBx888Packed

final int idpfRGBx888Packed = acquireJNI.idpfRGBx888Packed_get()
static

A four channel interleaved RGB format with 32 bit per pixel containing one alpha byte per pixel.

(PFNC name: BGRa8)

This is an interleaved pixel format suitable for most display functions. The data is stored pixel-wise. The memory layout of the pixel data is like this:

4 bytes 4 bytes etc.
B(1) G(1) R(1) A(1) B(2) G(2) R(2) A(2) etc.
.......................................
B(n) G(n) R(n) A(n)

So the first byte in memory is the first pixels blue component. ImageBuffer.vpData will therefore point to B(1) when using a byte pointer. The 4th byte could be used for alpha information but isn't used by this framework.

Note
This format reports 3 channels only for backward compatibility reasons while in fact memory is allocated for 4 channels! Use this format with some extra care!
See also
Converting packed data to planar formats

◆ idpfRGBx888Planar

final int idpfRGBx888Planar = acquireJNI.idpfRGBx888Planar_get()
static

A four channel planar RGB format.

(PFNC name: RGBa8_Planar)

This is a format best suitable for most image processing functions. The data is stored in 4 separate planes (one plane for each color component and one alpha plane).

R(1) R(2) R(3) R(4) etc.
...................
.............. R(n)
G(1) G(2) G(3) G(4) etc.
...................
.............. G(n)
B(1) B(2) B(3) B(4) etc.
...................
.............. B(n)
A(1) A(2) A(3) A(4) etc.
...................
.............. A(n)

So the first byte in memory is the first pixels red component. ImageBuffer.vpData will therefore point to R(1) when using a byte pointer. All red data will follow!

Note
This format reports 3 channels only for backward compatibility reasons while in fact memory is allocated for 4 channels! Use this format with some extra care!

◆ idpfYUV411_UYYVYY_Packed

final int idpfYUV411_UYYVYY_Packed = acquireJNI.idpfYUV411_UYYVYY_Packed_get()
static

A three channel interleaved YUV format occupying 48 bit for four pixels.

(PFNC name: YUV411_8_UYYVYY)

This format uses 4:1 horizontal downsampling, meaning the Y component is sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 4 pixels in horizontal direction. If each component takes 8 bits, four pixels require 48 bits.

Four consecutive pixels (48 bit, 0xaabbccddeeff ) contain 8 bit chrominance blue of pixels 1, 2, 3 and 4(aa), 8 bit luminance of pixel 1(bb),8 bit luminance of pixel 2(cc), 8 bit chrominance red of pixels 1, 2, 3 and 4(dd), 8 bit luminance of pixel 3(ee) and finally 8 bit luminance of pixel 4(ff).

Thus in memory the data will be stored like this:

6 bytes 6 bytes etc.
Cb(1,2,3,4) Y(1) Y(2) Cr(1,2,3,4) Y(3) Y(4) Cb(5,6,7,8) Y(5) Y(6) Cr(5,6,7,8) Y(7) Y(8) etc.
.................. Cb(n,n+1,n+2,n+3) Y(n) Y(n+1) Cr(n,n+1,n+2,n+3) Y(n+2) Y(n+3)

So the first byte in memory is the chrominance blue component. ImageBuffer.vpData will therefore point to Cb when using a byte pointer.

See also
Converting packed data to planar formats
Since
2.13.0

◆ idpfYUV422_10Packed

final int idpfYUV422_10Packed = acquireJNI.idpfYUV422_10Packed_get()
static

A three channel interleaved YUV422 format occupying 64 bit for a pair of pixels.

(PFNC name: YUV422_10)

This format uses 2:1 horizontal downsampling, meaning the Y component is sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in horizontal direction. If each component takes 16 bits, the pair of pixels requires 64 bits.

Two consecutive pixels (64 bit, 0xaaaabbbbccccdddd ) contain 10 bit luminance of pixel 1(aaaa), 10 bit chrominance blue of pixel 1 and 2(bbbb), 10 bit luminance of pixel 2(cccc) and finally 10 bit chrominance red of pixels 1 and 2(dddd). The upper 6 bits of each component will be 0.

Thus in memory the data will be stored like this:

8 bytes 8 bytes etc.
Y(1) Cb(1,2) Y(2) Cr(1,2) Y(3) Cb(3,4) Y(4) Cr(3,4) etc.
..........................Y(n-1) Cb(n-1,n) Y(n) Cr(n-1,n)

So the first 2 bytes in memory are the first pixels luminance component. ImageBuffer.vpData will therefore point to Y(1) when using a 16 bit pointer.

See also
Converting packed data to planar formats

◆ idpfYUV422_UYVY_10Packed

final int idpfYUV422_UYVY_10Packed = acquireJNI.idpfYUV422_UYVY_10Packed_get()
static

A three channel interleaved YUV422 format occupying 64 bit for a pair of pixels.

(PFNC name: YUV422_10_UYV)

This format uses 2:1 horizontal downsampling, meaning the Y component is sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in horizontal direction. If each component takes 16 bits, the pair of pixels requires 64 bits.

Two consecutive pixels (64 bit, 0xaaaabbbbccccdddd ) will contain 10 bit chrominance blue of pixel 1 and 2(aaaa), 10 bit luminance of pixel 1(bbbb), 10 bit chrominance red of pixel 1 and 2 (cccc) and finally 10 bit luminance of pixel 2(dddd). The upper 6 bits of each component will be 0.

Thus in memory the data will be stored like this:

8 bytes 8 bytes etc.
Cb(1,2) Y(1) Cr(1,2) Y(2) Cb(3,4) Y(3) Cr(3,4) Y(4) etc.
..........................Cb(n-1,n) Y(n-1) Cr(n-1,n) Y(n)

So the first 2 bytes in memory are the first pixels luminance component. ImageBuffer.vpData will therefore point to Cb(1,2) when using a 16 bit pointer.

See also
Converting packed data to planar formats

◆ idpfYUV422_UYVYPacked

final int idpfYUV422_UYVYPacked = acquireJNI.idpfYUV422_UYVYPacked_get()
static

A three channel interleaved YUV422 format occupying 32 bit for a pair of pixels.

(PFNC name: YUV422_8_UYV)

This format uses 2:1 horizontal downsampling, meaning the Y component is sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.

Two consecutive pixels (32 bit, 0xaabbccdd ) will contain 8 bit chrominance blue of pixel 1 and 2(aa), 8 bit luminance of pixel 1(bb), 8 bit chrominance red of pixel 1 and 2 (cc) and finally 8 bit luminance of pixel 2(dd).

Thus in memory the data will be stored like this:

4 bytes 4 bytes etc.
Cb(1,2) Y(1) Cr(1,2) Y(2) Cb(3,4) Y(3) Cr(3,4) Y(4) etc.
..........................Cb(n-1,n) Y(n-1) Cr(n-1,n) Y(n)

So the first byte in memory is the first pixels Cb component. ImageBuffer.vpData will therefore point to Cb(1,2) when using a byte pointer.

See also
Converting packed data to planar formats

◆ idpfYUV422Packed

final int idpfYUV422Packed = acquireJNI.idpfYUV422Packed_get()
static

A three channel interleaved YUV422 format using 32 bit for a pair of pixels.

(PFNC name: YUV422_8)

This format uses 2:1 horizontal downsampling, meaning the Y component is sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in horizontal direction. Each component takes 8 bits, therefore a pair of pixels requires 32 bits.

Two consecutive pixels (32 bit, 0xaabbccdd ) contain 8 bit luminance of pixel 1(aa), 8 bit chrominance blue of pixel 1 and 2(bb), 8 bit luminance of pixel 2(cc) and finally 8 bit chrominance red of pixels 1 and 2(dd).

Thus in memory the data will be stored like this:

4 bytes 4 bytes etc.
Y(1) Cb(1,2) Y(2) Cr(1,2) Y(3) Cb(3,4) Y(4) Cr(3,4) etc.
..........................Y(n-1) Cb(n-1,n) Y(n) Cr(n-1,n)

So the first byte in memory is the first pixels luminance component. ImageBuffer.vpData will therefore point to Y(1) when using a byte pointer.

See also
Converting packed data to planar formats

◆ idpfYUV422Planar

final int idpfYUV422Planar = acquireJNI.idpfYUV422Planar_get()
static

A three channel planar YUV422 format.

(PFNC name: YUV422_8_YVU_Planar)

This format uses 2:1 horizontal downsampling, meaning the Y component is sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.

In memory the data will be stored like this:

Y(1) Y(2) Y(3) Y(4) etc.
............................
.............. Y(n-1) Y(n)
Cr(1,2) Cr(3,4) etc.
...............
....... Cr(n/2)
Cb(1,2) Cb(3,4) etc.
...............
....... Cb(n/2)

Thus the Y planes size in bytes equals the sum of the 2 other planes.

So the first byte in memory is the first pixels luminance component. ImageBuffer.vpData will therefore point to Y(1) when using a byte pointer.

◆ idpfYUV444_10Packed

final int idpfYUV444_10Packed = acquireJNI.idpfYUV444_10Packed_get()
static

A three channel interleaved YUV format occupying 48 bit per pixel with 30 bit of usable data per pixel.

(PFNC name: YUV10)

This is an interleaved pixel format with 2 bytes per color component. The data is stored pixel-wise:

6 bytes 6 bytes 6 bytes etc.
Y(1)Cb(1)Cr(1) Y(2)Cb(2)Cr(2) Y(3)Cb(3)Cr(3) etc.
..........................................
........................... Y(n)Cb(n)Cr(n)

The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will not contain valid data.

So the first byte in memory is the first pixels luminance component. ImageBuffer.vpData will therefore point to Y(1) when using a 16 bit pointer.

See also
Converting packed data to planar formats

◆ idpfYUV444_UYV_10Packed

final int idpfYUV444_UYV_10Packed = acquireJNI.idpfYUV444_UYV_10Packed_get()
static

A three channel interleaved YUV format occupying 48 bit per pixel with 30 bit of usable data per pixel.

(PFNC name: YUV422_8_UYV)

This is an interleaved pixel format with 2 bytes per color component. The data is stored pixel-wise:

6 bytes 6 bytes 6 bytes etc.
Cb(1)Y(1)Cr(1) Cb(2)Y(2)Cr(2) Cb(3)Y(3)Cr(3) etc.
..........................................
........................... Cb(n)Y(n)Cr(n)

The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will not contain valid data.

So the first byte in memory is the first pixels Cb component. ImageBuffer.vpData will therefore point to Cb(1) when using a 16 bit pointer.

See also
Converting packed data to planar formats

◆ idpfYUV444_UYVPacked

final int idpfYUV444_UYVPacked = acquireJNI.idpfYUV444_UYVPacked_get()
static

A three channel interleaved YUV format occupying 24 bit per pixel.

(PFNC name: YUV8_UYV)

This is an interleaved pixel format.

The data is stored pixel-wise:

3 bytes 3 bytes 3 bytes etc.
Cb(1)Y(1)Cr(1) Cb(2)Y(2)Cr(2) Cb(3)Y(3)Cr(3) etc.
..........................................
........................... Cb(n)Y(n)Cr(n)

So the first byte in memory is the first pixels Cb component. ImageBuffer.vpData will therefore point to Cb(1) when using a byte pointer.

See also
Converting packed data to planar formats

◆ idpfYUV444Packed

final int idpfYUV444Packed = acquireJNI.idpfYUV444Packed_get()
static

A three channel interleaved YUV format occupying 24 bit per pixel.

(PFNC name: YUV8)

This is an interleaved pixel format.

The data is stored pixel-wise:

3 bytes 3 bytes 3 bytes etc.
Y(1)Cb(1)Cr(1) Y(2)Cb(2)Cr(2) Y(3)Cb(3)Cr(3) etc.
..........................................
........................... Y(n)Cb(n)Cr(n)

So the first byte in memory is the first pixels luminance component. ImageBuffer.vpData will therefore point to Y(1) when using a byte pointer.

See also
Converting packed data to planar formats