Struct ParallelTileEncoder 

pub struct ParallelTileEncoder {
    pub layout: TileLayout,
}

Splits a raw pixel frame into tiles, processes them in parallel, and reassembles the result.

Example

use oximedia_codec::tile_encoder::{TileConfig, ParallelTileEncoder};

let config = TileConfig::new()
    .tile_cols(2)
    .tile_rows(2)
    .frame_width(64)
    .frame_height(64);

let encoder = ParallelTileEncoder::new(config);

let frame: Vec<u8> = (0u8..=255).cycle().take(64 * 64 * 3).collect();
let tiles = encoder.split_frame(&frame, 3);
assert_eq!(tiles.len(), 4);

// Identity encode: return each tile unchanged.
let processed = encoder
    .encode_tiles_parallel(tiles, |tile| Ok(tile))
    ?;

let merged = ParallelTileEncoder::merge_tiles(&processed, 64, 64, 3);
assert_eq!(merged, frame);

Fields

layout: TileLayout

Pre-computed tile layout.

Implementations

impl ParallelTileEncoder

pub fn new(config: TileConfig) -> Self

Create a ParallelTileEncoder from config.

pub fn split_frame(&self, frame: &[u8], channels: u8) -> Vec<TileBuffer>

Split frame into TileBuffers, one per tile in the layout.

channels is the number of bytes per pixel in frame.

pub fn merge_tiles( tiles: &[TileBuffer], frame_width: u32, frame_height: u32, channels: u8, ) -> Vec<u8>

Merge a slice of TileBuffers back into a complete frame.

The returned Vec<u8> has frame_width * frame_height * channels bytes.

pub fn encode_tiles_parallel<F>( &self, tiles: Vec<TileBuffer>, encode_fn: F, ) -> Result<Vec<TileBuffer>, String>

where F: Fn(TileBuffer) -> Result<TileBuffer, String> + Send + Sync,

Process tiles in parallel using encode_fn.

Each tile is passed by value to encode_fn. The closure must return either a (possibly modified) TileBuffer or an error string.

Uses Rayon for parallel execution. The output order matches the input order (raster order when produced by split_frame).

Errors

Returns the first error string produced by any invocation of encode_fn.