Struct BlobPlane 

pub struct BlobPlane<'a> {
    pub handle: i64,
    pub offset: u64,
    pub stride: u64,
    pub size: u64,
    pub used: u64,
    pub modifier: u64,
    pub handle_bytes: &'a [u8],
    pub data: &'a [u8],
}

One plane record, borrowed from the buffer.

Field names and widths mirror TensorPlane.msg so the two map 1:1. All scalars are 64-bit, and handle is i64 rather than an fd-sized i32: cheap now, and the alternative breaks the round-trip property, since a u32 size would cap a plane at 4 GiB — which camera frames never reach but a tensor carrying model weights plausibly does.

The two transport modes are distinguished by handle:

• handle >= 0 — reference: the bytes live behind the handle, and data is empty.
• handle == -1 — inline: the bytes are in data, offset is ignored, size describes data, and modifier must be 0.

Fields

handle: i64

In reference mode, an INDEX into the accompanying fd table — not a raw file descriptor. -1 when inline.

This is an ABI decision, not an implementation detail. A raw fd is meaningless in the receiving process: fds travel out of band via SCM_RIGHTS or pidfd_getfd, and the receiver is handed different numbers than the sender used. Wayland, D-Bus and CameraFrame all carry the same (payload, fds) split for the same reason.

Indices also let planes share a descriptor: NV12’s luma and chroma commonly live in one dma-buf at different offsets, and both planes then carry index 0 while the table holds a single fd.

Windows has no fd table: a D3D11 texture is shared by NT handle, which is a value in the exporting process’s handle table rather than a descriptor an out-of-band table can carry. Such a plane carries index 0 over an empty table — non-negative, so the record is still a reference and not an inline one — and its handles live in Self::handle_bytes.

offset: u64

Byte offset of this plane within the handle; ignored when inline.

stride: u64

Bytes per line of this plane.

size: u64

Plane capacity in bytes.

used: u64

Valid payload bytes; used <= size.

modifier: u64

DRM format modifier. 0 = linear. A consumer that does not recognise a non-zero value must refuse, not read the plane as linear.

handle_bytes: &'a [u8]

Opaque handle for backends whose handle is not an integer (a cudaIpcMemHandle_t is 64 bytes), or whose handle does not travel in the fd table at all.

Windows D3D11 textures are the one storage kind that fills this in today: D3D11_HANDLE_BYTES bytes holding the texture’s NT handle value, the process device fence’s NT handle value and the fence value of the producer’s last recorded GPU write, each a little-endian u64. All three are values in the exporting process’s handle table, which is why the header’s BlobHeader::pid is what makes them reachable – and why that field documents the trust boundary they share.

data: &'a [u8]

Inlined plane bytes; non-empty only when handle == -1.

Implementations

impl BlobPlane<'_>

pub fn is_inline(&self) -> bool

True when this plane carries its bytes rather than a reference to them.

pub fn encoded_len(&self) -> usize

Encoded length of this record, including the padding that keeps the following record 8-aligned.

Trait Implementations

impl<'a> Clone for BlobPlane<'a>

fn clone(&self) -> BlobPlane<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for BlobPlane<'a>

impl<'a> Debug for BlobPlane<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Eq for BlobPlane<'a>

impl<'a> PartialEq for BlobPlane<'a>

fn eq(&self, other: &BlobPlane<'a>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> StructuralPartialEq for BlobPlane<'a>