Struct J2kDecoder 

pub struct J2kDecoder<'a> { /* private fields */ }

CUDA-facing JPEG 2000 decoder wrapper.

Implementations

impl<'a> J2kDecoder<'a>

pub fn new(input: &'a [u8]) -> Result<Self, Error>

Create a CUDA-facing decoder from compressed bytes.

pub fn decode_to_device_with_session( &mut self, fmt: PixelFormat, session: &mut CudaSession, ) -> Result<Surface, Error>

Strictly decode a full HTJ2K image into a CUDA-backed surface using an existing backend session.

pub fn decode_to_device_with_session_and_profile( &mut self, fmt: PixelFormat, session: &mut CudaSession, ) -> Result<(Surface, CudaHtj2kProfileReport), Error>

Strictly decode a full HTJ2K image into a CUDA-backed surface and return a structured profile report for CPU planning and CUDA stages.

pub fn decode_batch_to_device_with_session( inputs: &[&[u8]], fmt: PixelFormat, session: &mut CudaSession, ) -> Result<Vec<Surface>, Error>

Strictly decode a batch of full HTJ2K images into CUDA-backed surfaces using an existing backend session.

pub fn decode_batch_to_device_with_session_and_profile( inputs: &[&[u8]], fmt: PixelFormat, session: &mut CudaSession, ) -> Result<(Vec<Surface>, CudaHtj2kProfileReport), Error>

Strictly decode a batch of full HTJ2K images into CUDA-backed surfaces and return one aggregate profile report for the shared batch.

pub fn decode_to_host_surface( &mut self, fmt: PixelFormat, ) -> Result<Surface, Error>

Decode a full image through the CPU path and wrap it as a host surface.

pub fn build_cuda_htj2k_grayscale_plan_with_profile( &mut self, fmt: PixelFormat, ) -> Result<(CudaHtj2kDecodePlan, CudaHtj2kProfileReport), Error>

Build a flat CUDA HTJ2K grayscale decode plan and return stage timings.

pub fn build_cuda_htj2k_grayscale_region_plan_with_profile( &mut self, fmt: PixelFormat, roi: Rect, ) -> Result<(CudaHtj2kDecodePlan, CudaHtj2kProfileReport), Error>

Build a flat CUDA HTJ2K grayscale region decode plan and return stage timings.

pub fn build_cuda_htj2k_grayscale_scaled_plan_with_profile( &mut self, fmt: PixelFormat, output_dimensions: (u32, u32), ) -> Result<(CudaHtj2kDecodePlan, CudaHtj2kProfileReport), Error>

Build a flat reduced-resolution CUDA HTJ2K grayscale decode plan and return stage timings.

pub fn build_cuda_htj2k_grayscale_region_scaled_plan_with_profile( &mut self, fmt: PixelFormat, scaled_roi: Rect, output_dimensions: (u32, u32), ) -> Result<(CudaHtj2kDecodePlan, CudaHtj2kProfileReport), Error>

Build a flat reduced-resolution CUDA HTJ2K grayscale region decode plan and return stage timings.

pub fn decode_to_cpu_staged_cuda_surface_with_session( &mut self, fmt: PixelFormat, session: &mut CudaSession, ) -> Result<Surface, Error>

Decode a full image on CPU and upload it into a CUDA buffer using an existing backend session.

pub fn decode_region_to_cpu_staged_cuda_surface_with_session( &mut self, fmt: PixelFormat, roi: Rect, session: &mut CudaSession, ) -> Result<Surface, Error>

Decode a region on CPU and upload it into a CUDA buffer using an existing backend session.

pub fn decode_scaled_to_cpu_staged_cuda_surface_with_session( &mut self, fmt: PixelFormat, scale: Downscale, session: &mut CudaSession, ) -> Result<Surface, Error>

Decode a scaled image on CPU and upload it into a CUDA buffer using an existing backend session.

pub fn decode_region_scaled_to_cpu_staged_cuda_surface_with_session( &mut self, fmt: PixelFormat, roi: Rect, scale: Downscale, session: &mut CudaSession, ) -> Result<Surface, Error>

Decode a scaled region on CPU and upload it into a CUDA buffer using an existing backend session.

Trait Implementations

impl ImageCodec for J2kDecoder<'_>

type Error = Error

Codec-specific error type.

type Warning = Infallible

Non-fatal warning type returned in successful decode outcomes.

type Pool = J2kScratchPool

Caller-owned scratch pool type used to reuse allocations.

impl<'a> ImageDecode<'a> for J2kDecoder<'a>

type View = J2kView<'a>

Borrowed parse product that can later construct a decoder.

fn inspect(input: &'a [u8]) -> Result<Info, Self::Error>

Inspect metadata without decoding pixels.

fn parse(input: &'a [u8]) -> Result<Self::View, Self::Error>

Parse compressed bytes into a borrowed view.

fn from_view(view: Self::View) -> Result<Self, Self::Error>

Build a decoder from a parsed view.

fn decode_into( &mut self, out: &mut [u8], stride: usize, fmt: PixelFormat, ) -> Result<DecodeOutcome<Self::Warning>, Self::Error>

Decode the full image into caller-owned output.

fn decode_into_with_scratch( &mut self, pool: &mut Self::Pool, out: &mut [u8], stride: usize, fmt: PixelFormat, ) -> Result<DecodeOutcome<Self::Warning>, Self::Error>

Decode the full image into caller-owned output with reusable scratch.

fn decode_region_into( &mut self, pool: &mut Self::Pool, out: &mut [u8], stride: usize, fmt: PixelFormat, roi: Rect, ) -> Result<DecodeOutcome<Self::Warning>, Self::Error>

Decode a source-coordinate region into caller-owned output.

fn decode_scaled_into( &mut self, pool: &mut Self::Pool, out: &mut [u8], stride: usize, fmt: PixelFormat, scale: Downscale, ) -> Result<DecodeOutcome<Self::Warning>, Self::Error>

Decode the full image at reduced resolution into caller-owned output.

fn decode_region_scaled_into( &mut self, pool: &mut Self::Pool, out: &mut [u8], stride: usize, fmt: PixelFormat, roi: Rect, scale: Downscale, ) -> Result<DecodeOutcome<Self::Warning>, Self::Error>

Decode a source-coordinate region at reduced resolution into caller-owned output.

fn decode_request_into( &mut self, pool: &mut Self::Pool, out: &mut [u8], stride: usize, fmt: PixelFormat, request: DecodeRequest, ) -> Result<DecodeOutcome<Self::Warning>, Self::Error>

Decode a normalized full/ROI/scaled request into caller-owned output.

impl<'a> ImageDecodeDevice<'a> for J2kDecoder<'a>

type DeviceSurface = Surface

Device surface returned by decode calls.

fn decode_to_device( &mut self, fmt: PixelFormat, backend: BackendRequest, ) -> Result<Self::DeviceSurface, Self::Error>

where Self: ImageDecodeSubmit<'a, DeviceSurface = Self::DeviceSurface>,

Decode the full image to the requested backend.

fn decode_region_to_device( &mut self, fmt: PixelFormat, roi: Rect, backend: BackendRequest, ) -> Result<Self::DeviceSurface, Self::Error>

where Self: ImageDecodeSubmit<'a, DeviceSurface = Self::DeviceSurface>,

Decode a source-coordinate region to the requested backend.

fn decode_scaled_to_device( &mut self, fmt: PixelFormat, scale: Downscale, backend: BackendRequest, ) -> Result<Self::DeviceSurface, Self::Error>

where Self: ImageDecodeSubmit<'a, DeviceSurface = Self::DeviceSurface>,

Decode the full image at reduced resolution to the requested backend.

fn decode_region_scaled_to_device( &mut self, fmt: PixelFormat, roi: Rect, scale: Downscale, backend: BackendRequest, ) -> Result<Self::DeviceSurface, Self::Error>

where Self: ImageDecodeSubmit<'a, DeviceSurface = Self::DeviceSurface>,

Decode a source-coordinate region at reduced resolution to the requested backend.

impl<'a> ImageDecodeSubmit<'a> for J2kDecoder<'a>

type Session = CudaSession

Mutable session state shared across submissions.

type DeviceSurface = Surface

Device surface returned by completed submissions.

type SubmittedSurface = ReadySubmission<Surface, Error>

Submission handle type.

fn submit_to_device( &mut self, session: &mut Self::Session, fmt: PixelFormat, backend: BackendRequest, ) -> Result<Self::SubmittedSurface, Self::Error>

Submit full-image decode to the requested backend.

fn submit_region_to_device( &mut self, session: &mut Self::Session, fmt: PixelFormat, roi: Rect, backend: BackendRequest, ) -> Result<Self::SubmittedSurface, Self::Error>

Submit region decode to the requested backend.

fn submit_scaled_to_device( &mut self, session: &mut Self::Session, fmt: PixelFormat, scale: Downscale, backend: BackendRequest, ) -> Result<Self::SubmittedSurface, Self::Error>

Submit reduced-resolution decode to the requested backend.

fn submit_region_scaled_to_device( &mut self, session: &mut Self::Session, fmt: PixelFormat, roi: Rect, scale: Downscale, backend: BackendRequest, ) -> Result<Self::SubmittedSurface, Self::Error>

Submit region decode at reduced resolution to the requested backend.

fn submit_request_to_device( &mut self, session: &mut Self::Session, fmt: PixelFormat, backend: BackendRequest, request: DecodeRequest, ) -> Result<Self::SubmittedSurface, Self::Error>

Submit a normalized full/ROI/scaled decode request to a device backend.