image/lib.rs
1//! # Overview
2//!
3//! This crate provides native rust implementations of image encoding and decoding as well as some
4//! basic image manipulation functions. Additional documentation can currently also be found in the
5//! [README.md file which is most easily viewed on
6//! github](https://github.com/image-rs/image/blob/main/README.md).
7//!
8//! There are two core problems for which this library provides solutions: a unified interface for image
9//! encodings and simple generic buffers for their content. It's possible to use either feature
10//! without the other. The focus is on a small and stable set of common operations that can be
11//! supplemented by other specialized crates. The library also prefers safe solutions with few
12//! dependencies.
13//!
14//! # High level API
15//!
16//! Load images using [`ImageReader`](crate::image_reader::ImageReader):
17//!
18//! ```rust,no_run
19//! use std::io::Cursor;
20//! use image::ImageReader;
21//! # fn main() -> Result<(), image::ImageError> {
22//! # let bytes = vec![0u8];
23//!
24//! let img = ImageReader::open("myimage.png")?.decode()?;
25//! let img2 = ImageReader::new(Cursor::new(bytes)).with_guessed_format()?.decode()?;
26//! # Ok(())
27//! # }
28//! ```
29//!
30//! And save them using [`save`] or [`write_to`] methods:
31//!
32//! ```rust,no_run
33//! # use std::io::{Write, Cursor};
34//! # use image::{DynamicImage, ImageFormat};
35//! # #[cfg(feature = "png")]
36//! # fn main() -> Result<(), image::ImageError> {
37//! # let img: DynamicImage = unimplemented!();
38//! # let img2: DynamicImage = unimplemented!();
39//! img.save("empty.jpg")?;
40//!
41//! let mut bytes: Vec<u8> = Vec::new();
42//! img2.write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Png)?;
43//! # Ok(())
44//! # }
45//! # #[cfg(not(feature = "png"))] fn main() {}
46//! ```
47//!
48//! With default features, the crate includes support for [many common image formats](codecs/index.html#supported-formats).
49//!
50//! [`save`]: enum.DynamicImage.html#method.save
51//! [`write_to`]: enum.DynamicImage.html#method.write_to
52//! [`ImageReader`]: struct.Reader.html
53//!
54//! # Image buffers
55//!
56//! The two main types for storing images:
57//! * [`ImageBuffer`] which holds statically typed image contents.
58//! * [`DynamicImage`] which is an enum over the supported `ImageBuffer` formats
59//! and supports conversions between them.
60//!
61//! As well as a few more specialized options:
62//! * [`GenericImage`] trait for a mutable image buffer.
63//! * [`GenericImageView`] trait for read only references to a `GenericImage`.
64//! * [`flat`] module containing types for interoperability with generic channel
65//! matrices and foreign interfaces.
66//!
67//! [`GenericImageView`]: trait.GenericImageView.html
68//! [`GenericImage`]: trait.GenericImage.html
69//! [`ImageBuffer`]: struct.ImageBuffer.html
70//! [`DynamicImage`]: enum.DynamicImage.html
71//! [`flat`]: flat/index.html
72//!
73//! # Low level encoding/decoding API
74//!
75//! Implementations of [`ImageEncoder`] provides low level control over encoding:
76//! ```rust,no_run
77//! # use std::io::Write;
78//! # use image::DynamicImage;
79//! # use image::ImageEncoder;
80//! # #[cfg(feature = "jpeg")]
81//! # fn main() -> Result<(), image::ImageError> {
82//! # use image::codecs::jpeg::JpegEncoder;
83//! # let img: DynamicImage = unimplemented!();
84//! # let writer: Box<dyn Write> = unimplemented!();
85//! let encoder = JpegEncoder::new_with_quality(&mut writer, 95);
86//! img.write_with_encoder(encoder)?;
87//! # Ok(())
88//! # }
89//! # #[cfg(not(feature = "jpeg"))] fn main() {}
90//! ```
91//! While [`ImageDecoder`] and [`ImageDecoderRect`] give access to more advanced decoding options:
92//!
93//! ```rust,no_run
94//! # use std::io::{BufReader, Cursor};
95//! # use image::DynamicImage;
96//! # use image::ImageDecoder;
97//! # #[cfg(feature = "png")]
98//! # fn main() -> Result<(), image::ImageError> {
99//! # use image::codecs::png::PngDecoder;
100//! # let img: DynamicImage = unimplemented!();
101//! # let reader: BufReader<Cursor<&[u8]>> = unimplemented!();
102//! let decoder = PngDecoder::new(&mut reader)?;
103//! let icc = decoder.icc_profile();
104//! let img = DynamicImage::from_decoder(decoder)?;
105//! # Ok(())
106//! # }
107//! # #[cfg(not(feature = "png"))] fn main() {}
108//! ```
109//!
110//! [`DynamicImage::from_decoder`]: enum.DynamicImage.html#method.from_decoder
111//! [`ImageDecoderRect`]: trait.ImageDecoderRect.html
112//! [`ImageDecoder`]: trait.ImageDecoder.html
113//! [`ImageEncoder`]: trait.ImageEncoder.html
114#![warn(missing_docs)]
115#![warn(unused_qualifications)]
116#![deny(unreachable_pub)]
117#![deny(deprecated)]
118#![deny(missing_copy_implementations)]
119#![cfg_attr(all(test, feature = "benchmarks"), feature(test))]
120#![cfg_attr(docsrs, feature(doc_auto_cfg))]
121
122#[cfg(all(test, feature = "benchmarks"))]
123extern crate test;
124
125#[cfg(test)]
126#[macro_use]
127extern crate quickcheck;
128
129pub use crate::color::{ColorType, ExtendedColorType};
130
131pub use crate::color::{Luma, LumaA, Rgb, Rgba};
132
133pub use crate::error::{ImageError, ImageResult};
134
135pub use crate::image::{
136 AnimationDecoder,
137 GenericImage,
138 GenericImageView,
139 ImageDecoder,
140 ImageDecoderRect,
141 ImageEncoder,
142 ImageFormat,
143 // Iterators
144 Pixels,
145 SubImage,
146};
147
148pub use crate::buffer_::{
149 GrayAlphaImage,
150 GrayImage,
151 // Image types
152 ImageBuffer,
153 Rgb32FImage,
154 RgbImage,
155 Rgba32FImage,
156 RgbaImage,
157};
158
159pub use crate::flat::FlatSamples;
160
161// Traits
162pub use crate::traits::{EncodableLayout, Pixel, PixelWithColorType, Primitive};
163
164// Opening and loading images
165pub use crate::dynimage::{
166 image_dimensions, load_from_memory, load_from_memory_with_format, open, save_buffer,
167 save_buffer_with_format, write_buffer_with_format,
168};
169pub use crate::image_reader::free_functions::{guess_format, load};
170pub use crate::image_reader::{ImageReader, LimitSupport, Limits};
171
172pub use crate::dynimage::DynamicImage;
173
174pub use crate::animation::{Delay, Frame, Frames};
175
176// More detailed error type
177pub mod error;
178
179/// Iterators and other auxiliary structure for the `ImageBuffer` type.
180pub mod buffer {
181 // Only those not exported at the top-level
182 pub use crate::buffer_::{
183 ConvertBuffer, EnumeratePixels, EnumeratePixelsMut, EnumerateRows, EnumerateRowsMut,
184 Pixels, PixelsMut, Rows, RowsMut,
185 };
186
187 #[cfg(feature = "rayon")]
188 pub use crate::buffer_par::*;
189}
190
191// Math utils
192pub mod math;
193
194// Image processing functions
195pub mod imageops;
196
197// Buffer representations for ffi.
198pub mod flat;
199
200/// Encoding and decoding for various image file formats.
201///
202/// # Supported formats
203///
204/// <!--- NOTE: Make sure to keep this table in sync with the README -->
205///
206/// | Format | Decoding | Encoding |
207/// | -------- | ----------------------------------------- | --------------------------------------- |
208/// | AVIF | Yes (8-bit only) \* | Yes (lossy only) |
209/// | BMP | Yes | Yes |
210/// | DDS | Yes | --- |
211/// | Farbfeld | Yes | Yes |
212/// | GIF | Yes | Yes |
213/// | HDR | Yes | Yes |
214/// | ICO | Yes | Yes |
215/// | JPEG | Yes | Yes |
216/// | EXR | Yes | Yes |
217/// | PNG | Yes | Yes |
218/// | PNM | Yes | Yes |
219/// | QOI | Yes | Yes |
220/// | TGA | Yes | Yes |
221/// | TIFF | Yes | Yes |
222/// | WebP | Yes | Yes (lossless only) |
223///
224/// - \* Requires the `avif-native` feature, uses the libdav1d C library.
225///
226/// ## A note on format specific features
227///
228/// One of the main goals of `image` is stability, in runtime but also for programmers. This
229/// ensures that performance as well as safety fixes reach a majority of its user base with little
230/// effort. Re-exporting all details of its dependencies would run counter to this goal as it
231/// linked _all_ major version bumps between them and `image`. As such, we are wary of exposing too
232/// many details, or configuration options, that are not shared between different image formats.
233///
234/// Nevertheless, the advantage of precise control is hard to ignore. We will thus consider
235/// _wrappers_, not direct re-exports, in either of the following cases:
236///
237/// 1. A standard specifies that configuration _x_ is required for decoders/encoders and there
238/// exists an essentially canonical way to control it.
239/// 2. At least two different implementations agree on some (sub-)set of features in practice.
240/// 3. A technical argument including measurements of the performance, space benefits, or otherwise
241/// objectively quantified benefits can be made, and the added interface is unlikely to require
242/// breaking changes.
243///
244/// Features that fulfill two or more criteria are preferred.
245///
246/// Re-exports of dependencies that reach version `1` will be discussed when it happens.
247pub mod codecs {
248 #[cfg(any(feature = "avif", feature = "avif-native"))]
249 pub mod avif;
250 #[cfg(feature = "bmp")]
251 pub mod bmp;
252 #[cfg(feature = "dds")]
253 pub mod dds;
254 #[cfg(feature = "ff")]
255 pub mod farbfeld;
256 #[cfg(feature = "gif")]
257 pub mod gif;
258 #[cfg(feature = "hdr")]
259 pub mod hdr;
260 #[cfg(feature = "ico")]
261 pub mod ico;
262 #[cfg(feature = "jpeg")]
263 pub mod jpeg;
264 #[cfg(feature = "exr")]
265 pub mod openexr;
266 #[cfg(feature = "png")]
267 pub mod png;
268 #[cfg(feature = "pnm")]
269 pub mod pnm;
270 #[cfg(feature = "qoi")]
271 pub mod qoi;
272 #[cfg(feature = "tga")]
273 pub mod tga;
274 #[cfg(feature = "tiff")]
275 pub mod tiff;
276 #[cfg(feature = "webp")]
277 pub mod webp;
278
279 #[cfg(feature = "dds")]
280 mod dxt;
281}
282
283mod animation;
284#[path = "buffer.rs"]
285mod buffer_;
286#[cfg(feature = "rayon")]
287mod buffer_par;
288mod color;
289mod dynimage;
290mod image;
291mod image_reader;
292pub mod metadata;
293//TODO delete this module after a few releases
294/// deprecated io module the original io module has been renamed to `image_reader`
295pub mod io {
296 #[deprecated(note = "this type has been moved and renamed to image::ImageReader")]
297 /// Deprecated re-export of `ImageReader` as `Reader`
298 pub type Reader<R> = super::ImageReader<R>;
299 #[deprecated(note = "this type has been moved to image::Limits")]
300 /// Deprecated re-export of `Limits`
301 pub type Limits = super::Limits;
302 #[deprecated(note = "this type has been moved to image::LimitSupport")]
303 /// Deprecated re-export of `LimitSupport`
304 pub type LimitSupport = super::LimitSupport;
305}
306mod traits;
307mod utils;
308
309// Can't use the macro-call itself within the `doc` attribute. So force it to eval it as part of
310// the macro invocation.
311//
312// The inspiration for the macro and implementation is from
313// <https://github.com/GuillaumeGomez/doc-comment>
314//
315// MIT License
316//
317// Copyright (c) 2018 Guillaume Gomez
318macro_rules! insert_as_doc {
319 { $content:expr } => {
320 #[allow(unused_doc_comments)]
321 #[doc = $content] extern { }
322 }
323}
324
325// Provides the README.md as doc, to ensure the example works!
326insert_as_doc!(include_str!("../README.md"));