Enum TensorDyn 

#[non_exhaustive]
pub enum TensorDyn {
    U8(Tensor<u8>),
    I8(Tensor<i8>),
    U16(Tensor<u16>),
    I16(Tensor<i16>),
    U32(Tensor<u32>),
    I32(Tensor<i32>),
    U64(Tensor<u64>),
    I64(Tensor<i64>),
    F16(Tensor<f16>),
    F32(Tensor<f32>),
    F64(Tensor<f64>),
}

Type-erased tensor. Wraps a Tensor<T> with runtime element type.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

U8(Tensor<u8>)

Unsigned 8-bit integer tensor.

I8(Tensor<i8>)

Signed 8-bit integer tensor.

U16(Tensor<u16>)

Unsigned 16-bit integer tensor.

I16(Tensor<i16>)

Signed 16-bit integer tensor.

U32(Tensor<u32>)

Unsigned 32-bit integer tensor.

I32(Tensor<i32>)

Signed 32-bit integer tensor.

U64(Tensor<u64>)

Unsigned 64-bit integer tensor.

I64(Tensor<i64>)

Signed 64-bit integer tensor.

F16(Tensor<f16>)

16-bit floating-point tensor.

F32(Tensor<f32>)

32-bit floating-point tensor.

F64(Tensor<f64>)

64-bit floating-point tensor.

Implementations

impl TensorDyn

pub fn dtype(&self) -> DType

Return the runtime element type discriminant.

pub fn shape(&self) -> &[usize]

Return the tensor shape.

pub fn name(&self) -> String

Return the tensor name.

pub fn format(&self) -> Option<PixelFormat>

Return the pixel format (None if not an image tensor).

pub fn width(&self) -> Option<usize>

Return the image width (None if not an image tensor).

pub fn height(&self) -> Option<usize>

Return the image height (None if not an image tensor).

pub fn size(&self) -> usize

Return the total size of this tensor in bytes.

pub fn memory(&self) -> TensorMemory

Return the memory allocation type.

pub fn reshape(&mut self, shape: &[usize]) -> Result<()>

Reshape this tensor. Total element count must remain the same.

pub fn set_format(&mut self, format: PixelFormat) -> Result<()>

Attach pixel format metadata to this tensor.

Validates that the tensor’s shape is compatible with the format’s layout (packed, planar, or semi-planar).

Arguments

• format - The pixel format to attach

Returns

Ok(()) on success, with the format stored as metadata on the tensor.

Errors

Returns Error::InvalidShape if the tensor shape doesn’t match the expected layout for the given format.

pub fn with_format(self, format: PixelFormat) -> Result<Self>

Attach pixel format metadata, consuming and returning self.

Enables builder-style chaining.

Arguments

• format - The pixel format to attach

Returns

The tensor with format metadata attached.

Errors

Returns Error::InvalidShape if the tensor shape doesn’t match the expected layout for the given format.

pub fn colorimetry(&self) -> Option<Colorimetry>

Colorimetry metadata (None = undefined; never auto-filled).

pub fn set_colorimetry(&mut self, c: Option<Colorimetry>)

Attach/clear colorimetry metadata.

pub fn with_colorimetry(self, c: Colorimetry) -> Self

Builder-style colorimetry attach (consumes and returns self).

pub fn row_stride(&self) -> Option<usize>

Row stride in bytes (None = tightly packed).

pub fn effective_row_stride(&self) -> Option<usize>

Effective row stride: stored stride or computed from format and width.

pub fn configure_image( &mut self, width: usize, height: usize, format: PixelFormat, ) -> Result<()>

Set logical dimensions + format to a decoded image, reusing the allocation. See Tensor::configure_image.

pub fn set_row_stride(&mut self, stride: usize) -> Result<()>

Set the row stride in bytes for externally allocated buffers with row padding.

Must be called before the tensor is first used for rendering. The format must be set before calling this method.

pub fn with_row_stride(self, stride: usize) -> Result<Self>

Builder-style: set row stride, consuming and returning self.

pub fn plane_offset(&self) -> Option<usize>

Byte offset within the DMA-BUF where image data starts (None = 0).

pub fn view_origin(&self) -> Option<ViewOrigin>

The parent-image snapshot if this tensor is a view/ batch sub-region; None for a whole tensor. See Tensor::view_origin.

pub fn set_plane_offset(&mut self, offset: usize)

Set the byte offset within the DMA-BUF where image data starts.

pub fn batch(&self, n: usize) -> Result<TensorDyn>

Borrow batch element n of a batched tensor (leading N dimension) as a zero-copy view sharing this tensor’s allocation. See Tensor::batch.

pub fn view(&self, region: Region) -> Result<TensorDyn>

Borrow a rectangular spatial sub-region (the destination/source crop) as a zero-copy view sharing this tensor’s allocation. See Tensor::view.

pub fn cuda(&self) -> Option<&CudaHandle>

The CUDA registration for this tensor, if any.

Returns None when no CUDA handle has been attached (the common non-CUDA case). This check is a pure local field read — no thread routing occurs.

pub fn cuda_map(&self) -> Option<CudaMap<'_>>

Fast-fail CUDA map: None when no handle is attached; else maps the PBO through the GL worker and returns a scoped device-pointer guard.

The same try-cuda_map-then-map fallback pattern that applies to Tensor::cuda_map applies here: call cuda_map() first for a zero-copy device pointer; when it returns None (no CUDA handle attached), fall back to the typed host mapping via the inner tensor.

Example

use edgefirst_tensor::TensorDyn;
if let Some(cuda) = t.cuda_map() {
    feed_tensorrt(cuda.device_ptr(), cuda.len());
} else {
    // No CUDA handle — use the typed inner tensor for host access.
    // See Tensor::cuda_map for the full fallback example.
}

pub fn quantization(&self) -> Option<&Quantization>

Quantization metadata. Returns None for float variants (F16, F32, F64) — quantization does not apply to floating-point tensors. Otherwise delegates to the typed Tensor<T>::quantization() accessor.

pub fn set_quantization(&mut self, q: Quantization) -> Result<()>

Attach quantization metadata. Fails on float variants with [Error::QuantizationInvalid]; delegates to the typed setter for integer variants.

pub fn with_quantization(self, q: Quantization) -> Result<Self>

Builder-style variant of Self::set_quantization. Consumes self and returns it with quantization applied (or the original error).

pub fn clear_quantization(&mut self)

Clear any quantization metadata. No-op on float variants.

pub fn clone_fd(&self) -> Result<OwnedFd>

Clone the file descriptor associated with this tensor.

pub fn dmabuf_clone(&self) -> Result<OwnedFd>

Clone the DMA-BUF file descriptor backing this tensor (Linux only).

Returns

An owned duplicate of the DMA-BUF file descriptor.

Errors

• Error::NotImplemented if the tensor is not DMA-backed (Mem/Shm/Pbo)
• Error::IoError if the fd clone syscall fails (e.g., fd limit reached)

pub fn dmabuf(&self) -> Result<BorrowedFd<'_>>

Borrow the DMA-BUF file descriptor backing this tensor (Linux only).

Returns

A borrowed reference to the DMA-BUF file descriptor, tied to self’s lifetime.

Errors

• Error::NotImplemented if the tensor is not DMA-backed

pub fn is_multiplane(&self) -> bool

Return true if this tensor uses separate plane allocations.

pub fn buffer_identity(&self) -> &BufferIdentity

Return the BufferIdentity of the underlying allocation.

Two TensorDyn values share a [BufferIdentity::id] iff they were produced by cloning the same allocation (e.g. through DmaTensor::try_clone). Separate imports of the same physical buffer (e.g. two from_fd calls on the same dmabuf fd) have distinct identities — use aliases if you need to detect that case.

pub fn aliases(&self, other: &Self) -> bool

Return true if self and other reference the same underlying buffer.

This is the correct check for APIs that require distinct input and output tensors (e.g. ImageProcessor::draw_decoded_masks, where aliasing dst and background would cause the GL backend to read and write the same texture — undefined behaviour on most drivers).

Matching is conservative:

1. Matching [BufferIdentity::id] → same buffer (always).
2. Matching backing type + matching dmabuf fd number (Linux, DMA tensors only) → same buffer, even across separate from_fd imports in the same process.

Two distinct dup’d fds pointing at the same kernel dma-buf are not detected — there is no cheap way to resolve that without a round-trip through the kernel.

pub fn as_u8(&self) -> Option<&Tensor<u8>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_u8_mut(&mut self) -> Option<&mut Tensor<u8>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_u8(self) -> Result<Tensor<u8>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_i8(&self) -> Option<&Tensor<i8>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_i8_mut(&mut self) -> Option<&mut Tensor<i8>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_i8(self) -> Result<Tensor<i8>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_u16(&self) -> Option<&Tensor<u16>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_u16_mut(&mut self) -> Option<&mut Tensor<u16>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_u16(self) -> Result<Tensor<u16>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_i16(&self) -> Option<&Tensor<i16>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_i16_mut(&mut self) -> Option<&mut Tensor<i16>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_i16(self) -> Result<Tensor<i16>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_u32(&self) -> Option<&Tensor<u32>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_u32_mut(&mut self) -> Option<&mut Tensor<u32>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_u32(self) -> Result<Tensor<u32>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_i32(&self) -> Option<&Tensor<i32>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_i32_mut(&mut self) -> Option<&mut Tensor<i32>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_i32(self) -> Result<Tensor<i32>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_u64(&self) -> Option<&Tensor<u64>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_u64_mut(&mut self) -> Option<&mut Tensor<u64>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_u64(self) -> Result<Tensor<u64>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_i64(&self) -> Option<&Tensor<i64>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_i64_mut(&mut self) -> Option<&mut Tensor<i64>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_i64(self) -> Result<Tensor<i64>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_f16(&self) -> Option<&Tensor<f16>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_f16_mut(&mut self) -> Option<&mut Tensor<f16>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_f16(self) -> Result<Tensor<f16>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_f32(&self) -> Option<&Tensor<f32>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_f32_mut(&mut self) -> Option<&mut Tensor<f32>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_f32(self) -> Result<Tensor<f32>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn as_f64(&self) -> Option<&Tensor<f64>>

Returns a shared reference to the inner tensor if the type matches.

pub fn as_f64_mut(&mut self) -> Option<&mut Tensor<f64>>

Returns a mutable reference to the inner tensor if the type matches.

pub fn into_f64(self) -> Result<Tensor<f64>, Self>

Unwraps the inner tensor if the type matches, otherwise returns self as Err. The Err variant is necessarily large (returns the unconsumed TensorDyn).

pub fn new( shape: &[usize], dtype: DType, memory: Option<TensorMemory>, name: Option<&str>, ) -> Result<Self>

Create a type-erased tensor with the given shape and element type.

pub fn from_fd( fd: OwnedFd, shape: &[usize], dtype: DType, name: Option<&str>, ) -> Result<Self>

Create a type-erased tensor from a file descriptor.

pub unsafe fn from_foreign_ptr( ptr: *mut u8, shape: &[usize], dtype: DType, owner: Option<ForeignOwner>, name: Option<&str>, ) -> Result<Self>

Wrap externally-owned memory as a type-erased tensor without copying. The tensor borrows [ptr, ptr + shape.product() * dtype.size()) as TensorMemory::Mem; owner, when Some, co-owns the source so it outlives the tensor (and all derived views/maps). See crate::ForeignOwner and Tensor::from_foreign.

Safety

ptr must be non-null, aligned to the element type, and valid for shape.product() elements of dtype for as long as the returned tensor — and every view/map sharing its backing — is alive. Pass an owner that co-owns the source to uphold that contract.

pub fn image( width: usize, height: usize, format: PixelFormat, dtype: DType, memory: Option<TensorMemory>, ) -> Result<Self>

Create a type-erased image tensor.

Arguments

• width - Image width in pixels
• height - Image height in pixels
• format - Pixel format
• dtype - Element type discriminant
• memory - Optional memory backend (None selects the best available)

Returns

A new TensorDyn wrapping an image tensor of the requested element type.

Errors

Returns an error if the underlying Tensor::image call fails.

pub fn image_with_stride( width: usize, height: usize, format: PixelFormat, dtype: DType, row_stride_bytes: usize, memory: Option<TensorMemory>, ) -> Result<Self>

Create a DMA-backed image tensor with an explicit row stride that may exceed the natural width * channels * sizeof(T) pitch.

See Tensor::image_with_stride for the detailed contract and constraints. The TensorDyn wrapper dispatches to the appropriate monomorphised Tensor<T> based on dtype.

Example

use edgefirst_tensor::{TensorDyn, PixelFormat, DType, TensorMemory};
// Allocate a 3004×1688 RGBA8 canvas with 64-byte pitch alignment
// (12032 bytes per row instead of the natural 12016).
let img = TensorDyn::image_with_stride(
    3004, 1688,
    PixelFormat::Rgba, DType::U8,
    12032,
    Some(TensorMemory::Dma),
)?;
assert_eq!(img.width(), Some(3004));       // logical, unchanged
assert_eq!(img.effective_row_stride(), Some(12032)); // padded

Trait Implementations

impl Debug for TensorDyn

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

Formats the value using the given formatter.

impl From<Tensor<f16>> for TensorDyn

fn from(t: Tensor<f16>) -> Self

Converts to this type from the input type.

impl From<Tensor<f32>> for TensorDyn

fn from(t: Tensor<f32>) -> Self

Converts to this type from the input type.

impl From<Tensor<f64>> for TensorDyn

fn from(t: Tensor<f64>) -> Self

Converts to this type from the input type.

impl From<Tensor<i8>> for TensorDyn

fn from(t: Tensor<i8>) -> Self

Converts to this type from the input type.

impl From<Tensor<i16>> for TensorDyn

fn from(t: Tensor<i16>) -> Self

Converts to this type from the input type.

impl From<Tensor<i32>> for TensorDyn

fn from(t: Tensor<i32>) -> Self

Converts to this type from the input type.

impl From<Tensor<i64>> for TensorDyn

fn from(t: Tensor<i64>) -> Self

Converts to this type from the input type.

impl From<Tensor<u8>> for TensorDyn

fn from(t: Tensor<u8>) -> Self

Converts to this type from the input type.

impl From<Tensor<u16>> for TensorDyn

fn from(t: Tensor<u16>) -> Self

Converts to this type from the input type.

impl From<Tensor<u32>> for TensorDyn

fn from(t: Tensor<u32>) -> Self

Converts to this type from the input type.

impl From<Tensor<u64>> for TensorDyn

fn from(t: Tensor<u64>) -> Self

Converts to this type from the input type.