This crate provides a library for decoding valid ITU-T Rec. T.851 (09/2005) ITU-T T.81 (JPEG-1) or JPEG images.

Features

• SSE and AVX accelerated functions to speed up certain decoding operations
• FAST and accurate 32 bit IDCT algorithm
• Fast color convert functions
• RGBA and RGBX (4-Channel) color conversion functions
• YCbCr to Luma(Grayscale) conversion.

Usage

Add zune-jpeg to the dependencies in the project Cargo.toml

[dependencies]
zune_jpeg = "0.5"

Examples

Decode a JPEG file with default arguments.

 use std::fs::read;
 use std::io::BufReader;
 use zune_jpeg::JpegDecoder;
 let file_contents = BufReader::new(std::fs::File::open("a_jpeg.file").unwrap());
 let mut decoder = JpegDecoder::new(file_contents);
 let mut pixels = decoder.decode().unwrap();

Migrating from version 0.4--

Motivation

zune v 0.5 reworks mainly the internal architecture of how we perform I/O ,before the decoder accepted byte slices that represent the whole data as contiguous but that was not ideal for all use cases, increasing memory e.g on massive files that had to be read to memory.

With v 0.5 a new I/O system is introduced, which generally introduces mechanisms to process std::io::Read + std::io::Seek type of data feeds, (but which works in no-std), which means...

What changes

I/O code that looked like this

 use zune_core::colorspace::ColorSpace;
 use zune_jpeg::JpegDecoder;
 // Read file into memory
 let image = std::fs::read("image.jpg").unwrap();
 // Make a decoder from the slice
 let mut decoder = JpegDecoder::new(&image);
 // decode
 decoder.decode().unwrap();

Now can be rewritten in two ways.

1. File I/O (Using bufreader)

 use std::io::BufReader;
 use zune_core::colorspace::ColorSpace;
 use zune_jpeg::JpegDecoder;

 let image = BufReader::new(std::fs::File::open("image.jpg").unwrap());
 let mut decoder = JpegDecoder::new(image);
 // decode
 decoder.decode().unwrap();

2. Reading to memory (but wrapping it in a Cursor like object)

 use zune_core::bytestream::ZCursor;
 use zune_jpeg::JpegDecoder;

 let image_data =std::fs::read("image.jpg").unwrap();
 // Alternatively, you can use std::io::Cursor,
 // but it is better speed wise to use ZCursor, and it also works in
 // no-std environments
 let mut cursor = ZCursor::new(image_data);
 // use the wrapped item
 let mut decoder = JpegDecoder::new(cursor);
 // decode
 decoder.decode().unwrap();

3. Anything that implements ZByteReaderTrait

Decode a JPEG file to RGBA format

• Other (limited) supported formats are and BGR, BGRA

 use zune_core::bytestream::ZCursor;
 use zune_core::colorspace::ColorSpace;
 use zune_core::options::DecoderOptions;
 use zune_jpeg::JpegDecoder;

 let mut options = DecoderOptions::default().jpeg_set_out_colorspace(ColorSpace::RGBA);

 let mut decoder = JpegDecoder::new_with_options(ZCursor::new(&[]),options);
 let pixels = decoder.decode().unwrap();

Decode an image and get its width and height.

 use zune_core::bytestream::ZCursor;
 use zune_jpeg::JpegDecoder;

 let mut decoder = JpegDecoder::new(ZCursor::new(&[]));
 decoder.decode_headers().unwrap();
 let image_info = decoder.info().unwrap();
 println!("{},{}",image_info.width,image_info.height)

Crate features.

This crate tries to be as minimal as possible while being extensible enough to handle the complexities arising from parsing different types of jpeg images.

Safety is a top concern that is why we provide both static ways to disable unsafe code, disabling x86 feature, and dynamic ,by using DecoderOptions::set_use_unsafe(false), both of these disable platform specific optimizations, which reduce the speed of decompression.

Please do note that careful consideration has been taken to ensure that the unsafe paths are only unsafe because they depend on platform specific intrinsics, hence no need to disable them

The crate tries to decode as many images as possible, as a best effort, even those violating the standard , this means a lot of images may get silent warnings and wrong output, but if you are sure you will be handling images that follow the spec, set ZuneJpegOptions::set_strict to true.