pub mod animation;
#[cfg(all(feature = "dec-heif", any(not(target_os = "windows"), target_abi = "llvm")))]
mod heif;
#[cfg(feature = "jxl")]
pub mod jxl;
use std::fs;
use std::io::BufReader;
use std::path::{Path, PathBuf};
use image::metadata::Orientation;
use image::{
AnimationDecoder, DynamicImage, ImageDecoder, ImageFormat as ImageCrateFormat, ImageReader,
Limits, codecs::gif::GifDecoder, codecs::png::PngDecoder, codecs::webp::WebPDecoder,
};
use crate::Error;
use crate::format::ImageFormat;
use crate::metadata::ImageMetadata;
pub use animation::{AnimationData, FrameData};
pub struct SourceImage {
pub content: ImageContent,
pub metadata: ImageMetadata,
pub source_format: ImageFormat,
pub source_path: PathBuf,
}
pub enum ImageContent {
Still(DynamicImage),
Animated(AnimationData),
}
impl SourceImage {
pub fn into_without_alpha(mut self) -> Self {
match self.content {
ImageContent::Still(image) => {
self.content = ImageContent::Still(image.into_without_alpha());
}
ImageContent::Animated(mut animation) => {
for frame in &mut animation.frames {
let buffer = std::mem::take(&mut frame.buffer);
let rgb = DynamicImage::ImageRgba8(buffer).into_rgb8();
frame.buffer = DynamicImage::ImageRgb8(rgb).to_rgba8();
}
self.content = ImageContent::Animated(animation);
}
}
self
}
pub fn first_frame_still(&self) -> Option<DynamicImage> {
match &self.content {
ImageContent::Still(image) => Some(image.clone()),
ImageContent::Animated(animation) => animation
.first_frame()
.map(|frame| DynamicImage::ImageRgba8(frame.buffer.clone())),
}
}
}
pub fn load_source(path: &Path) -> Result<SourceImage, Error> {
load_source_with_index(path, None)
}
pub fn decode_rgba(path: &Path) -> Result<image::RgbaImage, Error> {
let source = load_source_with_index(path, None)?;
match source.content {
ImageContent::Still(image) => Ok(image.to_rgba8()),
ImageContent::Animated(animation) => match animation.first_frame() {
Some(frame) => Ok(frame.buffer.clone()),
None => Err(Error::from_string(format!(
"Animated image {} does not contain any frames",
path.display()
))),
},
}
}
pub fn load_source_with_index(
path: &Path,
image_index: Option<usize>,
) -> Result<SourceImage, Error> {
if ImageFormat::from(path) == ImageFormat::Jxl {
#[cfg(feature = "jxl")]
return jxl::load_source_jxl(path);
#[cfg(not(feature = "jxl"))]
return Err(Error::from_string(format!(
"JPEG XL support is not compiled in (feature \"jxl\" disabled): {}",
path.display()
)));
}
#[cfg(all(feature = "dec-heif", any(not(target_os = "windows"), target_abi = "llvm")))]
if ImageFormat::from(path) == ImageFormat::Heif {
return load_heif_source(path, image_index);
}
let reader = open_reader(path)?;
let reader = match reader.with_guessed_format() {
Ok(reader) => reader,
Err(_) => {
let ext_format = ImageFormat::from(path);
let crate_format = ext_format.to_image_format().ok_or_else(|| {
Error::from_string(format!("Unsupported image format: {}", path.display()))
})?;
let mut fallback = open_reader(path)?;
fallback.set_format(crate_format);
fallback
}
};
let source_format = reader
.format()
.map(ImageFormat::from_image_format)
.unwrap_or_else(|| ImageFormat::from(path));
if source_format == ImageFormat::Gif {
return load_source_animated(path, source_format);
}
if matches!(source_format, ImageFormat::Webp | ImageFormat::Png)
&& let Some(source) = load_source_animated_if_container_is(path, source_format)?
{
return Ok(source);
}
let mut decoder = reader.into_decoder()?;
let mut metadata = collect_metadata(&mut decoder)?;
if metadata.exif.is_none() {
metadata.exif = crate::metadata::extract_exif_fallback(path, &source_format);
}
let image = match DynamicImage::from_decoder(decoder) {
Ok(image) => image,
Err(err) => fallback_retry_read_image(path, Error::new(err))?,
};
Ok(SourceImage {
content: ImageContent::Still(image),
metadata,
source_format,
source_path: path.to_path_buf(),
})
}
#[cfg(all(feature = "dec-heif", any(not(target_os = "windows"), target_abi = "llvm")))]
fn load_heif_source(path: &Path, image_index: Option<usize>) -> Result<SourceImage, Error> {
heif::load_source(path, image_index)
}
#[cfg(all(feature = "dec-heif", any(not(target_os = "windows"), target_abi = "llvm")))]
pub(crate) fn heif_probe(path: &Path) -> Result<usize, Error> {
heif::probe(path)
}
#[cfg(any(not(feature = "dec-heif"), all(target_os = "windows", not(target_abi = "llvm"))))]
fn load_heif_source(_path: &Path, _image_index: Option<usize>) -> Result<SourceImage, Error> {
Err(Error::new(std::io::Error::other(
"HEIC/HEIF input requires a build with the dec-heif feature",
)))
}
fn load_source_animated(path: &Path, source_format: ImageFormat) -> Result<SourceImage, Error> {
let file = fs::File::open(path)?;
let decoder = GifDecoder::new(BufReader::new(file))?;
let loop_count = decoder.loop_count();
let (width, height) = decoder.dimensions();
let mut frames = Vec::new();
for frame in decoder.into_frames() {
let frame = frame.map_err(Error::new)?;
frames.push(FrameData::from_image_frame(frame));
}
if frames.is_empty() {
return Err(Error::from_string(format!(
"Animated image {} does not contain any frames",
path.display()
)));
}
if frames.len() == 1 {
let frame = frames.into_iter().next().expect("checked length above");
return Ok(SourceImage {
content: ImageContent::Still(DynamicImage::ImageRgba8(frame.buffer)),
metadata: ImageMetadata::default(),
source_format,
source_path: path.to_path_buf(),
});
}
Ok(SourceImage {
content: ImageContent::Animated(AnimationData {
width,
height,
frames,
loop_count,
}),
metadata: ImageMetadata::default(),
source_format,
source_path: path.to_path_buf(),
})
}
fn load_source_animated_if_container_is(
path: &Path,
source_format: ImageFormat,
) -> Result<Option<SourceImage>, Error> {
let file = fs::File::open(path)?;
let reader = BufReader::new(file);
let (loop_count, dimensions, frames, metadata) = match source_format {
ImageFormat::Webp => {
let mut decoder = WebPDecoder::new(reader)?;
if !decoder.has_animation() {
return Ok(None);
}
let loop_count = decoder.loop_count();
let (width, height) = decoder.dimensions();
let metadata = ImageMetadata {
exif: decoder
.exif_metadata()
.map_err(Error::new)?
.and_then(crate::metadata::normalize_exif_payload),
icc: decoder.icc_profile().map_err(Error::new)?,
xmp: None,
exif_applied_orientation: decoder.orientation().map_err(Error::new)?
== Orientation::NoTransforms,
};
let mut frames = Vec::new();
for frame in decoder.into_frames() {
let frame = frame.map_err(Error::new)?;
frames.push(FrameData::from_image_frame(frame));
}
(loop_count, (width, height), frames, metadata)
}
ImageFormat::Png => {
let mut decoder = PngDecoder::new(reader)?;
if !decoder.is_apng().map_err(Error::new)? {
return Ok(None);
}
let (width, height) = decoder.dimensions();
let metadata = ImageMetadata {
exif: decoder
.exif_metadata()
.map_err(Error::new)?
.and_then(crate::metadata::normalize_exif_payload),
icc: decoder.icc_profile().map_err(Error::new)?,
xmp: None,
exif_applied_orientation: decoder.orientation().map_err(Error::new)?
== Orientation::NoTransforms,
};
let apng = decoder.apng().map_err(Error::new)?;
let loop_count = apng.loop_count();
let mut frames = Vec::new();
for frame in apng.into_frames() {
let frame = frame.map_err(Error::new)?;
frames.push(FrameData::from_image_frame(frame));
}
(loop_count, (width, height), frames, metadata)
}
_ => return Ok(None),
};
if frames.is_empty() {
return Err(Error::from_string(format!(
"Animated image {} does not contain any frames",
path.display()
)));
}
if frames.len() == 1 {
let frame = frames.into_iter().next().expect("checked length above");
return Ok(Some(SourceImage {
content: ImageContent::Still(DynamicImage::ImageRgba8(frame.buffer)),
metadata,
source_format,
source_path: path.to_path_buf(),
}));
}
Ok(Some(SourceImage {
content: ImageContent::Animated(AnimationData {
width: dimensions.0,
height: dimensions.1,
frames,
loop_count,
}),
metadata,
source_format,
source_path: path.to_path_buf(),
}))
}
fn open_reader(path: &Path) -> Result<ImageReader<BufReader<fs::File>>, Error> {
let mut reader = ImageReader::new(BufReader::new(fs::File::open(path)?));
reader.no_limits();
Ok(reader)
}
fn collect_metadata(decoder: &mut impl ImageDecoder) -> Result<ImageMetadata, Error> {
let exif = decoder
.exif_metadata()
.map_err(Error::new)?
.and_then(crate::metadata::normalize_exif_payload);
let icc = decoder.icc_profile().map_err(Error::new)?;
let orientation: Orientation = decoder.orientation().map_err(Error::new)?;
let exif_applied_orientation = orientation == Orientation::NoTransforms;
Ok(ImageMetadata {
exif,
icc,
xmp: None,
exif_applied_orientation,
})
}
fn fallback_retry_read_image(input_path: &Path, input_error: Error) -> Result<DynamicImage, Error> {
let err = input_error;
let ext = input_path
.extension()
.and_then(|e| e.to_str())
.unwrap_or("")
.to_ascii_lowercase();
if (ext == "pjpeg" || ext == "jpg" || ext == "jpeg")
&& let Ok(file) = fs::File::open(input_path)
{
let mut decoder = jpeg_decoder::Decoder::new(file);
if let Ok(pixels) = decoder.decode()
&& let Some(info) = decoder.info()
{
let img =
image::RgbImage::from_raw(u32::from(info.width), u32::from(info.height), pixels)
.ok_or_else(|| {
Error::from_string(
"Failed to convert jpeg-decoder output to RgbImage".to_string(),
)
})?;
return Ok(DynamicImage::ImageRgb8(img));
}
}
let mut reader = ImageReader::open(input_path)?;
reader.limits(Limits::no_limits());
match ext.as_str() {
"pjpeg" | "jpg" | "jpeg" => reader.set_format(ImageCrateFormat::Jpeg),
"x-png" | "png" => reader.set_format(ImageCrateFormat::Png),
_ => return Err(err), }
if let Ok(decoded) = reader.decode() {
Ok(decoded)
} else {
Err(err)
}
}
trait IntoWithoutAlpha {
fn into_without_alpha(self) -> DynamicImage;
}
impl IntoWithoutAlpha for DynamicImage {
fn into_without_alpha(self) -> DynamicImage {
match self {
DynamicImage::ImageLumaA8(_) => DynamicImage::ImageLuma8(self.into_luma8()),
DynamicImage::ImageLumaA16(_) => DynamicImage::ImageLuma16(self.into_luma16()),
DynamicImage::ImageRgba8(_) => DynamicImage::ImageRgb8(self.into_rgb8()),
DynamicImage::ImageRgba16(_) => DynamicImage::ImageRgb16(self.into_rgb16()),
DynamicImage::ImageRgba32F(_) => DynamicImage::ImageRgb32F(self.into_rgb32f()),
other => other,
}
}
}
pub fn buffer_size_bytes(img: &DynamicImage) -> u64 {
let (w, h) = (img.width(), img.height());
let bytes_per_pixel = img.color().bytes_per_pixel() as u64;
w as u64 * h as u64 * bytes_per_pixel
}
#[cfg(test)]
mod tests {
use super::*;
use image::codecs::gif::{GifEncoder, Repeat};
use image::metadata::LoopCount;
use image::{ExtendedColorType, Frame, RgbaImage};
fn temp_path(name: &str) -> std::path::PathBuf {
let mut path = std::env::temp_dir();
path.push(format!(
"byteshaver-input-test-{}-{}",
std::process::id(),
name
));
path
}
#[test]
fn animated_gif_flows_through_animation_data() {
let path = temp_path("anim.gif");
let file = fs::File::create(&path).expect("create temp gif");
let mut encoder = GifEncoder::new(file);
encoder.set_repeat(Repeat::Infinite).expect("set repeat");
for i in 0..3u8 {
let mut buffer = RgbaImage::from_pixel(8, 8, image::Rgba([i, 0, 0, 255]));
buffer.get_pixel_mut(0, 0).0[0] = 255;
encoder
.encode_frame(Frame::new(buffer))
.expect("encode frame");
}
drop(encoder);
let source = load_source(&path).expect("load gif");
assert_eq!(source.source_format, ImageFormat::Gif);
let ImageContent::Animated(animation) = &source.content else {
panic!("expected animated content");
};
assert_eq!(animation.width, 8);
assert_eq!(animation.height, 8);
assert_eq!(animation.frames.len(), 3);
assert!(matches!(animation.loop_count, LoopCount::Infinite));
let flattened = source.into_without_alpha();
let ImageContent::Animated(animation) = &flattened.content else {
panic!("expected animated content");
};
assert!(
animation
.frames
.iter()
.all(|f| f.buffer.pixels().all(|p| p.0[3] == 255))
);
let encoder = crate::converter::traits::EncoderRegistry::build(
&crate::config::EncoderConfig::Png(crate::config::PngOptions::default()),
crate::converter::traits::ThreadBudget::global(),
);
let encoded = encoder.encode(&flattened).expect("encode first frame");
assert!(!encoded.is_empty());
let _ = fs::remove_file(&path);
}
#[test]
fn still_input_decodes_with_detected_format() {
let path = temp_path("still.png");
let rgba = RgbaImage::from_pixel(4, 4, image::Rgba([1, 2, 3, 255]));
image::save_buffer(&path, rgba.as_raw(), 4, 4, ExtendedColorType::Rgba8)
.expect("write png");
let source = load_source(&path).expect("load png");
assert_eq!(source.source_format, ImageFormat::Png);
let ImageContent::Still(image) = &source.content else {
panic!("expected still content");
};
assert_eq!((image.width(), image.height()), (4, 4));
let _ = fs::remove_file(&path);
}
#[test]
fn decode_rgba_round_trips_a_png() {
let path = temp_path("decode-rgba.png");
let mut rgba = RgbaImage::from_pixel(5, 3, image::Rgba([9, 8, 7, 255]));
rgba.get_pixel_mut(4, 2).0 = [1, 2, 3, 40];
image::save_buffer(&path, rgba.as_raw(), 5, 3, ExtendedColorType::Rgba8)
.expect("write png");
let decoded = decode_rgba(&path).expect("decode png");
assert_eq!(decoded.dimensions(), (5, 3));
assert_eq!(decoded.as_raw(), rgba.as_raw(), "pixel-exact round trip");
let _ = fs::remove_file(&path);
}
#[test]
fn decode_rgba_takes_the_first_frame_of_an_animation() {
let path = temp_path("decode-rgba.gif");
let file = fs::File::create(&path).expect("create temp gif");
let mut encoder = GifEncoder::new(file);
for i in 0..3u8 {
let buffer = RgbaImage::from_pixel(6, 6, image::Rgba([i, 0, 0, 255]));
encoder.encode_frame(Frame::new(buffer)).expect("encode");
}
drop(encoder);
let decoded = decode_rgba(&path).expect("decode gif");
assert_eq!(decoded.dimensions(), (6, 6));
assert_eq!(decoded.get_pixel(0, 0), &image::Rgba([0, 0, 0, 255]));
let _ = fs::remove_file(&path);
}
#[test]
fn decode_rgba_reports_unreadable_and_unsupported_files() {
assert!(decode_rgba(&temp_path("does-not-exist.png")).is_err());
let junk = temp_path("junk.txt");
fs::write(&junk, b"definitely not an image").expect("write junk");
let error = decode_rgba(&junk).expect_err("unsupported extension");
assert!(
error.to_string().contains("format"),
"honest per-file format error: {error}"
);
let _ = fs::remove_file(&junk);
}
#[cfg(feature = "jxl")]
#[test]
fn decode_rgba_reads_jxl_outputs_via_jxl_oxide() {
use crate::config::{EncoderConfig, JxlOptions};
let path = temp_path("decode-rgba.jxl");
let rgba = RgbaImage::from_pixel(9, 7, image::Rgba([42, 43, 44, 255]));
let encoder = crate::converter::EncoderRegistry::build(
&EncoderConfig::Jxl(JxlOptions {
lossless: true,
effort: 1,
..JxlOptions::default()
}),
crate::converter::ThreadBudget::global(),
);
let source = SourceImage {
content: ImageContent::Still(DynamicImage::ImageRgba8(rgba.clone())),
metadata: ImageMetadata::default(),
source_format: ImageFormat::Png,
source_path: path.clone(),
};
let encoded = encoder.encode(&source).expect("encode jxl fixture");
fs::write(&path, &encoded).expect("write jxl");
let decoded = decode_rgba(&path).expect("decode jxl (plan 15 F15)");
assert_eq!(decoded.dimensions(), (9, 7));
assert_eq!(decoded.as_raw(), rgba.as_raw(), "lossless round trip");
let _ = fs::remove_file(&path);
}
}