Struct Image 

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

A JPEG2000 image or codestream.

Implementations

impl<'a> Image<'a>

pub fn new(data: &'a [u8], settings: &DecodeSettings) -> Result<Self>

Try to create a new JPEG2000 image from the given data.

pub fn has_alpha(&self) -> bool

Whether the image has an alpha channel.

pub fn color_space(&self) -> &ColorSpace

The color space of the image.

pub fn width(&self) -> u32

The width of the image.

pub fn height(&self) -> u32

The height of the image.

pub fn original_bit_depth(&self) -> u8

The original bit depth of the image. You usually don’t need to do anything with this parameter, it just exists for informational purposes.

pub fn supports_direct_device_plane_reuse(&self) -> bool

Whether decode finishes with additional host-side component mutation or reordering.

pub fn decode(&self) -> Result<Vec<u8>>

Decode the image and return its decoded result as a Vec<u8>, with each channel interleaved.

pub fn decode_with_context( &self, decoder_context: &mut DecoderContext<'a>, ) -> Result<Bitmap>

Decode the image and return its decoded result using a caller-provided decoder context so allocations can be reused across repeated decodes.

pub fn decode_components_with_context<'ctx>( &self, decoder_context: &'ctx mut DecoderContext<'a>, ) -> Result<DecodedComponents<'ctx>>

Decode the image into borrowed component planes using a caller-provided decoder context so allocations can be reused across repeated decodes.

pub fn build_direct_grayscale_plan_with_context( &self, decoder_context: &mut DecoderContext<'a>, ) -> Result<J2kDirectGrayscalePlan>

Build a adapter grayscale direct device plan without materializing host component planes.

pub fn build_direct_grayscale_plan_region_with_context( &self, decoder_context: &mut DecoderContext<'a>, output_region: (u32, u32, u32, u32), ) -> Result<J2kDirectGrayscalePlan>

Build a adapter grayscale direct device plan for an output-space region.

pub fn build_direct_color_plan_with_context( &self, decoder_context: &mut DecoderContext<'a>, ) -> Result<J2kDirectColorPlan>

Build a adapter RGB direct device plan without materializing host component planes.

pub fn build_direct_color_plan_region_with_context( &self, decoder_context: &mut DecoderContext<'a>, output_region: (u32, u32, u32, u32), ) -> Result<J2kDirectColorPlan>

Build a adapter RGB direct device plan for an output-space region.

pub fn decode_components_with_ht_decoder<'ctx>( &self, decoder_context: &'ctx mut DecoderContext<'a>, ht_decoder: &mut dyn HtCodeBlockDecoder, ) -> Result<DecodedComponents<'ctx>>

Decode borrowed component planes while delegating HTJ2K code-block decode.

pub fn decode_region_components_with_context<'ctx>( &self, roi: (u32, u32, u32, u32), decoder_context: &'ctx mut DecoderContext<'a>, ) -> Result<DecodedComponents<'ctx>>

Decode borrowed component planes for a requested region using a caller-provided decoder context.

pub fn decode_region_components_with_ht_decoder<'ctx>( &self, decoder_context: &'ctx mut DecoderContext<'a>, roi: (u32, u32, u32, u32), ht_decoder: &mut dyn HtCodeBlockDecoder, ) -> Result<DecodedComponents<'ctx>>

Decode borrowed component planes for a requested region while delegating code-block/transform stages through the adapter backend hook.

pub fn decode_region(&self, roi: (u32, u32, u32, u32)) -> Result<Bitmap>

Decode a region of the image and return it as an 8-bit interleaved bitmap.

pub fn decode_region_with_context( &self, roi: (u32, u32, u32, u32), decoder_context: &mut DecoderContext<'a>, ) -> Result<Bitmap>

Decode a region of the image and return it as an 8-bit interleaved bitmap using a caller-provided decoder context.

pub fn decode_native(&self) -> Result<RawBitmap>

Decode the image at native bit depth without scaling to 8-bit.

For images with bit depth ≤ 8, returns pixel data as Vec<u8>. For images with bit depth > 8 (e.g., 12-bit or 16-bit), returns pixel data as little-endian u16 values packed into Vec<u8>.

This is essential for medical imaging (DICOM) where 12-bit and 16-bit images must preserve their full dynamic range.

pub fn decode_reversible_53_coefficients( &self, ) -> Result<Reversible53CoefficientImage>

Extract reversible 5/3 wavelet coefficients for coefficient-domain classic JPEG 2000 to HTJ2K recoding.

This decodes classic Tier-1 code-blocks into dequantized reversible wavelet coefficients, but does not run inverse DWT or color conversion.

pub fn decode_reversible_53_coefficients_with_context( &self, decoder_context: &mut DecoderContext<'a>, ) -> Result<Reversible53CoefficientImage>

Extract reversible 5/3 wavelet coefficients using a caller-provided decoder context.

pub fn decode_native_region( &self, roi: (u32, u32, u32, u32), ) -> Result<RawBitmap>

Decode a region of the image at native bit depth.

pub fn decode_native_with_context( &self, decoder_context: &mut DecoderContext<'a>, ) -> Result<RawBitmap>

Decode the image at native bit depth using a caller-provided decoder context so allocations can be reused across repeated decodes.

pub fn decode_native_region_with_context( &self, roi: (u32, u32, u32, u32), decoder_context: &mut DecoderContext<'a>, ) -> Result<RawBitmap>

Decode a region of the image at native bit depth using a caller-provided decoder context.

pub fn decode_into( &self, buf: &mut [u8], decoder_context: &mut DecoderContext<'a>, ) -> Result<()>

Decode the image into the given buffer.

This method does the same as Image::decode, but you can provide a custom buffer for the output, as well as a decoder context. Doing so allows the internal decode engine to reuse memory allocations, so this is especially recommended if you plan on converting multiple images in the same session.

The buffer must have the correct size.