Struct image::io::Reader

pub struct Reader<R: Read> {
    inner: R,
    format: Option<ImageFormat>,
    limits: Limits,
}

A multi-format image reader.

Wraps an input reader to facilitate automatic detection of an image’s format, appropriate decoding method, and dispatches into the set of supported ImageDecoder implementations.

Usage

Opening a file, deducing the format based on the file path automatically, and trying to decode the image contained can be performed by constructing the reader and immediately consuming it.

let image = Reader::open("path/to/image.png")?
    .decode()?;

It is also possible to make a guess based on the content. This is especially handy if the source is some blob in memory and you have constructed the reader in another way. Here is an example with a pnm black-and-white subformat that encodes its pixel matrix with ascii values.

use std::io::Cursor;
use image::ImageFormat;

let raw_data = b"P1 2 2\n\
    0 1\n\
    1 0\n";

let mut reader = Reader::new(Cursor::new(raw_data))
    .with_guessed_format()
    .expect("Cursor io never fails");
assert_eq!(reader.format(), Some(ImageFormat::Pnm));

let image = reader.decode()?;

As a final fallback or if only a specific format must be used, the reader always allows manual specification of the supposed image format with set_format.

Fields

inner: R

The reader. Should be buffered.

format: Option<ImageFormat>

The format, if one has been set or deduced.

limits: Limits

Decoding limits

Implementations

impl<R: Read> Reader<R>

pub fn new(buffered_reader: R) -> Self

Create a new image reader without a preset format.

Assumes the reader is already buffered. For optimal performance, consider wrapping the reader with a BufReader::new().

It is possible to guess the format based on the content of the read object with with_guessed_format, or to set the format directly with set_format.

pub fn with_format(buffered_reader: R, format: ImageFormat) -> Self

Construct a reader with specified format.

Assumes the reader is already buffered. For optimal performance, consider wrapping the reader with a BufReader::new().

pub fn format(&self) -> Option<ImageFormat>

Get the currently determined format.

pub fn set_format(&mut self, format: ImageFormat)

Supply the format as which to interpret the read image.

pub fn clear_format(&mut self)

Remove the current information on the image format.

Note that many operations require format information to be present and will return e.g. an ImageError::Unsupported when the image format has not been set.

pub fn no_limits(&mut self)

Disable all decoding limits.

pub fn limits(&mut self, limits: Limits)

Set a custom set of decoding limits.

pub fn into_inner(self) -> R

Unwrap the reader.

impl Reader<BufReader<File>>

pub fn open<P>(path: P) -> Result<Self>

where P: AsRef<Path>,

Open a file to read, format will be guessed from path.

This will not attempt any io operation on the opened file.

If you want to inspect the content for a better guess on the format, which does not depend on file extensions, follow this call with a call to with_guessed_format.

fn open_impl(path: &Path) -> Result<Self>

impl<R: BufRead + Seek> Reader<R>

pub fn with_guessed_format(self) -> Result<Self>

Make a format guess based on the content, replacing it on success.

Returns Ok with the guess if no io error occurs. Additionally, replaces the current format if the guess was successful. If the guess was unable to determine a format then the current format of the reader is unchanged.

Returns an error if the underlying reader fails. The format is unchanged. The error is a std::io::Error and not ImageError since the only error case is an error when the underlying reader seeks.

When an error occurs, the reader may not have been properly reset and it is potentially hazardous to continue with more io.

Usage

This supplements the path based type deduction from open with content based deduction. This is more common in Linux and UNIX operating systems and also helpful if the path can not be directly controlled.

let image = Reader::open("image.unknown")?
    .with_guessed_format()?
    .decode()?;

fn guess_format(&mut self) -> Result<Option<ImageFormat>>

pub fn into_dimensions(self) -> ImageResult<(u32, u32)>

Read the image dimensions.

Uses the current format to construct the correct reader for the format.

If no format was determined, returns an ImageError::Unsupported.

pub fn decode(self) -> ImageResult<DynamicImage>

Read the image (replaces load).

Uses the current format to construct the correct reader for the format.

If no format was determined, returns an ImageError::Unsupported.

fn require_format(&mut self) -> ImageResult<ImageFormat>