Struct ImageProcessor 

pub struct ImageProcessor {
    pub cpu: Option<CPUProcessor>,
    pub g2d: Option<G2DProcessor>,
    pub opengl: Option<GLProcessorThreaded>,
    /* private fields */
}

Image converter that uses available hardware acceleration or CPU as a fallback.

Fields

cpu: Option<CPUProcessor>

CPU-based image converter as a fallback. This is only None if the EDGEFIRST_DISABLE_CPU environment variable is set.

g2d: Option<G2DProcessor>

G2D-based image converter for Linux systems. This is only available if the EDGEFIRST_DISABLE_G2D environment variable is not set and libg2d.so is available.

opengl: Option<GLProcessorThreaded>

OpenGL-based image converter for Linux systems. This is only available if the EDGEFIRST_DISABLE_GL environment variable is not set and OpenGL ES is available.

Implementations

impl ImageProcessor

pub fn new() -> Result<Self>

Creates a new ImageProcessor instance, initializing available hardware converters based on the system capabilities and environment variables.

Examples

let image = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../testdata/zidane.jpg"));
let src = load_image(image, Some(PixelFormat::Rgba), None)?;
let mut converter = ImageProcessor::new()?;
let mut dst = converter.create_image(640, 480, PixelFormat::Rgb, DType::U8, None)?;
converter.convert(&src, &mut dst, Rotation::None, Flip::None, Crop::default())?;

pub fn with_config(config: ImageProcessorConfig) -> Result<Self>

Creates a new ImageProcessor with the given configuration.

When ImageProcessorConfig::backend is set to a specific backend, environment variables are ignored and the processor initializes the requested backend plus CPU as a fallback.

When Auto, the existing EDGEFIRST_FORCE_BACKEND and EDGEFIRST_DISABLE_* environment variables apply.

pub fn set_int8_interpolation_mode( &mut self, mode: Int8InterpolationMode, ) -> Result<()>

Sets the interpolation mode for int8 proto textures on the OpenGL backend. No-op if OpenGL is not available.

pub fn create_image( &self, width: usize, height: usize, format: PixelFormat, dtype: DType, memory: Option<TensorMemory>, ) -> Result<TensorDyn>

Create a TensorDyn image with the best available memory backend.

Priority: DMA-buf → PBO (byte-sized types: u8, i8) → system memory.

Use this method instead of TensorDyn::image() when the tensor will be used with ImageProcessor::convert(). It selects the optimal memory backing (including PBO for GPU zero-copy) which direct allocation cannot achieve.

This method is on ImageProcessor rather than ImageProcessorTrait because optimal allocation requires knowledge of the active compute backends (e.g. the GL context handle for PBO allocation). Individual backend implementations (CPUProcessor, etc.) do not have this cross-backend visibility.

Arguments

• width - Image width in pixels
• height - Image height in pixels
• format - Pixel format
• dtype - Element data type (e.g. DType::U8, DType::I8)
• memory - Optional memory type override; when None, the best available backend is selected automatically.

Returns

A TensorDyn backed by the highest-performance memory type available on this system.

Errors

Returns an error if all allocation strategies fail.

pub fn import_image( &self, image: PlaneDescriptor, chroma: Option<PlaneDescriptor>, width: usize, height: usize, format: PixelFormat, dtype: DType, ) -> Result<TensorDyn>

Import an external DMA-BUF image.

Each [PlaneDescriptor] owns an already-duped fd; this method consumes the descriptors and takes ownership of those fds (whether the call succeeds or fails).

The caller must ensure the DMA-BUF allocation is large enough for the specified width, height, format, and any stride/offset on the plane descriptors. No buffer-size validation is performed; an undersized buffer may cause GPU faults or EGL import failure.

Arguments

• image - Plane descriptor for the primary (or only) plane
• chroma - Optional plane descriptor for the UV chroma plane (required for multiplane NV12)
• width - Image width in pixels
• height - Image height in pixels
• format - Pixel format of the buffer
• dtype - Element data type (e.g. DType::U8)

Returns

A TensorDyn configured as an image.

Errors

• Error::NotSupported if chroma is Some for a non-semi-planar format, or multiplane NV16 (not yet supported), or the fd is not DMA-backed
• Error::InvalidShape if NV12 height is odd

Platform

Linux only.

Examples

use edgefirst_tensor::PlaneDescriptor;

// Single-plane RGBA
let pd = PlaneDescriptor::new(fd.as_fd())?;
let src = proc.import_image(pd, None, 1920, 1080, PixelFormat::Rgba, DType::U8)?;

// Multi-plane NV12 with stride
let y_pd = PlaneDescriptor::new(y_fd.as_fd())?.with_stride(2048);
let uv_pd = PlaneDescriptor::new(uv_fd.as_fd())?.with_stride(2048);
let src = proc.import_image(y_pd, Some(uv_pd), 1920, 1080,
                            PixelFormat::Nv12, DType::U8)?;

Trait Implementations

impl Debug for ImageProcessor

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

Formats the value using the given formatter.

impl ImageProcessorTrait for ImageProcessor

fn convert( &mut self, src: &TensorDyn, dst: &mut TensorDyn, rotation: Rotation, flip: Flip, crop: Crop, ) -> Result<()>

Converts the source image to the destination image format and size. The image is cropped first, then flipped, then rotated

Prefer hardware accelerators when available, falling back to CPU if necessary.

fn draw_masks( &mut self, dst: &mut TensorDyn, detect: &[DetectBox], segmentation: &[Segmentation], ) -> Result<()>

Draw pre-decoded detection boxes and segmentation masks onto dst.

fn draw_masks_proto( &mut self, dst: &mut TensorDyn, detect: &[DetectBox], proto_data: &ProtoData, ) -> Result<()>

Draw masks from proto data onto image (fused decode+draw).

fn set_class_colors(&mut self, colors: &[[u8; 4]]) -> Result<()>

Sets the colors used for rendering segmentation masks. Up to 20 colors can be set.

fn decode_masks_atlas( &mut self, detect: &[DetectBox], proto_data: ProtoData, output_width: usize, output_height: usize, ) -> Result<(Vec<u8>, Vec<MaskRegion>)>

Decode masks into a compact atlas buffer.

impl Send for ImageProcessor

impl Sync for ImageProcessor