use std::any::Any;
use std::panic::{self, AssertUnwindSafe};
use std::path::Path;
use image::{DynamicImage, RgbImage, RgbaImage};
use libheif_rs::{ColorSpace, HeifContext, ImageHandle, ItemId, LibHeif, RgbChroma};
use crate::Error;
use crate::input::{ImageContent, SourceImage};
use crate::metadata::ImageMetadata;
const XMP_CONTENT_TYPE: &str = "application/rdf+xml";
fn open_context(path: &Path) -> Result<HeifContext<'static>, Error> {
let path_str = path.to_str().ok_or_else(|| {
Error::from_string(format!(
"HEIC/HEIF path is not valid unicode: {}",
path.display()
))
})?;
HeifContext::read_from_file(path_str).map_err(|err| {
Error::from_string(format!("libheif could not open {}: {err}", path.display()))
})
}
fn ordered_image_handles(ctx: &HeifContext<'_>) -> Result<Vec<ImageHandle>, Error> {
let mut handles = ctx.top_level_image_handles();
if let Ok(primary) = ctx.primary_image_handle() {
let primary_id = primary.item_id();
handles.retain(|handle| handle.item_id() != primary_id);
handles.insert(0, primary);
}
if handles.is_empty() {
return Err(Error::from_string(
"HEIC/HEIF file does not contain any decodable image".to_string(),
));
}
Ok(handles)
}
pub(crate) fn probe(path: &Path) -> Result<usize, Error> {
let ctx = open_context(path)?;
Ok(ctx.top_level_image_handles().len())
}
pub(crate) fn load_source(path: &Path, image_index: Option<usize>) -> Result<SourceImage, Error> {
let result = panic::catch_unwind(AssertUnwindSafe(|| load_source_inner(path, image_index)));
match result {
Ok(inner) => inner,
Err(payload) => Err(Error::from_string(format!(
"libheif decoding panicked: {}",
panic_message(&payload)
))),
}
}
fn load_source_inner(path: &Path, image_index: Option<usize>) -> Result<SourceImage, Error> {
let ctx = open_context(path)?;
let handles = ordered_image_handles(&ctx)?;
let total_images = handles.len();
let handle = match image_index {
Some(index) => handles.get(index).ok_or_else(|| {
Error::from_string(format!(
"HEIC/HEIF file {} contains {total_images} image(s), but image {index} was requested",
path.display()
))
})?,
None => handles.first().ok_or_else(|| {
Error::from_string(format!(
"HEIC/HEIF file {} does not contain any decodable image",
path.display()
))
})?,
};
let mut metadata = ImageMetadata {
exif: extract_exif(handle),
xmp: extract_xmp(handle),
icc: extract_icc(handle),
exif_applied_orientation: true,
};
#[cfg(feature = "exif")]
if let Some(payload) = metadata.exif.take() {
let (payload, orientation_removed) = strip_orientation_tag(payload);
metadata.exif_applied_orientation = orientation_removed;
metadata.exif = payload;
}
let image = decode_image(handle)?;
Ok(SourceImage {
content: ImageContent::Still(image),
metadata,
source_format: crate::format::ImageFormat::Heif,
source_path: path.to_path_buf(),
})
}
fn decode_image(handle: &ImageHandle) -> Result<DynamicImage, Error> {
let bits = handle.luma_bits_per_pixel();
if bits > 8 {
println!("Warning: HEIC/HEIF image is {bits}-bit; down-converting to 8-bit");
}
let chroma = if handle.has_alpha_channel() {
RgbChroma::Rgba
} else {
RgbChroma::Rgb
};
let lib_heif = LibHeif::new();
let heif_image = lib_heif
.decode(handle, ColorSpace::Rgb(chroma), None)
.map_err(|err| Error::from_string(format!("libheif decoding failed: {err}")))?;
let planes = heif_image.planes();
let plane = planes.interleaved.ok_or_else(|| {
Error::from_string(
"libheif did not return an interleaved RGB(A) plane for the decoded image".to_string(),
)
})?;
let (width, height) = (plane.width, plane.height);
if width == 0 || height == 0 {
return Err(Error::from_string(format!(
"libheif decoded an image with invalid dimensions {width}x{height}"
)));
}
let bytes_per_pixel = match chroma {
RgbChroma::Rgba => 4usize,
_ => 3usize,
};
let row_len = width as usize * bytes_per_pixel;
let mut pixels = Vec::with_capacity(row_len * height as usize);
for row in 0..height as usize {
let start = row * plane.stride;
let end = start + row_len;
if end > plane.data.len() {
return Err(Error::from_string(format!(
"libheif plane data is truncated (row {row}: need {end} bytes, got {})",
plane.data.len()
)));
}
pixels.extend_from_slice(&plane.data[start..end]);
}
match chroma {
RgbChroma::Rgba => RgbaImage::from_raw(width, height, pixels)
.map(DynamicImage::ImageRgba8)
.ok_or_else(|| {
Error::from_string("libheif plane buffer has an unexpected size".to_string())
}),
_ => RgbImage::from_raw(width, height, pixels)
.map(DynamicImage::ImageRgb8)
.ok_or_else(|| {
Error::from_string("libheif plane buffer has an unexpected size".to_string())
}),
}
}
fn extract_exif(handle: &ImageHandle) -> Option<Vec<u8>> {
let capacity = handle.number_of_metadata_blocks(b"Exif").max(0) as usize;
let mut ids: Vec<ItemId> = vec![0; capacity];
let count = handle.metadata_block_ids(&mut ids, b"Exif");
for id in ids.into_iter().take(count) {
if let Ok(raw) = handle.metadata(id)
&& let Some(payload) = tiff_payload_from_heif_item(raw)
{
return Some(payload);
}
}
None
}
fn extract_xmp(handle: &ImageHandle) -> Option<Vec<u8>> {
let capacity = handle.number_of_metadata_blocks(b"mime").max(0) as usize;
let mut ids: Vec<ItemId> = vec![0; capacity];
let count = handle.metadata_block_ids(&mut ids, b"mime");
for id in ids.into_iter().take(count) {
if handle.metadata_content_type(id) == Some(XMP_CONTENT_TYPE)
&& let Ok(data) = handle.metadata(id)
&& !data.is_empty()
{
return Some(data);
}
}
None
}
fn extract_icc(handle: &ImageHandle) -> Option<Vec<u8>> {
let profile = handle.color_profile_raw()?;
let data = profile.data;
if data.is_empty() { None } else { Some(data) }
}
fn tiff_payload_from_heif_item(raw: Vec<u8>) -> Option<Vec<u8>> {
let start = if raw.len() >= 8 {
let offset = u32::from_be_bytes([raw[0], raw[1], raw[2], raw[3]]) as usize;
match offset {
0 => 4,
offset if (4..raw.len()).contains(&offset) => offset,
_ => 0,
}
} else {
0
};
crate::metadata::normalize_exif_payload(raw[start..].to_vec())
}
#[cfg(feature = "exif")]
fn strip_orientation_tag(payload: Vec<u8>) -> (Option<Vec<u8>>, bool) {
use exif::experimental::Writer;
let parsed = match crate::metadata::exif::parse(&payload) {
Ok(parsed) => parsed,
Err(err) => {
println!(
"Warning: could not parse the EXIF payload of the HEIC/HEIF image to remove its \
Orientation tag ({err}); keeping the tag, the rotation was already applied \
during decoding and applying it again would distort the output"
);
return (Some(payload), false);
}
};
if crate::metadata::exif::orientation_value(&parsed).is_none() {
return (Some(payload), true);
}
let mut writer = Writer::new();
let mut seen: Vec<(exif::In, exif::Tag)> = Vec::new();
for field in parsed.fields() {
if field.tag == exif::Tag::Orientation && field.ifd_num == exif::In::PRIMARY {
continue;
}
let key = (field.ifd_num, field.tag);
if seen.contains(&key) {
continue;
}
seen.push(key);
writer.push_field(field);
}
let mut serialized = std::io::Cursor::new(Vec::new());
match writer.write(&mut serialized, parsed.little_endian()) {
Ok(()) if !serialized.get_ref().is_empty() => (Some(serialized.into_inner()), true),
Ok(()) => (Some(payload), false),
Err(err) => {
println!(
"Warning: could not re-serialize the EXIF payload without its Orientation tag \
({err}); keeping the tag, the rotation was already applied during decoding and \
applying it again would distort the output"
);
(Some(payload), false)
}
}
}
fn panic_message(payload: &Box<dyn Any + Send>) -> String {
if let Some(message) = payload.downcast_ref::<&'static str>() {
(*message).to_string()
} else if let Some(message) = payload.downcast_ref::<String>() {
message.clone()
} else {
"unknown panic".to_string()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn exif_item_offset_prefix_is_normalized() {
let mut item = vec![0, 0, 0, 0];
item.extend_from_slice(b"II*\0\x08\0\0\0\0\0");
assert_eq!(
tiff_payload_from_heif_item(item).as_deref(),
Some(&b"II*\0\x08\0\0\0\0\0"[..])
);
let mut item = vec![0, 0, 0, 8, 0, 0, 0xEE, 0xEE];
item.extend_from_slice(b"II*\0\x08\0\0\0\0\0");
assert_eq!(
tiff_payload_from_heif_item(item).as_deref(),
Some(&b"II*\0\x08\0\0\0\0\0"[..])
);
assert_eq!(
tiff_payload_from_heif_item(b"MM\0*\0\0\0\0".to_vec()).as_deref(),
Some(&b"MM\0*\0\0\0\0"[..])
);
let mut item = vec![0, 0, 0, 0];
item.extend_from_slice(b"Exif\0\0II*\0");
assert_eq!(
tiff_payload_from_heif_item(item).as_deref(),
Some(&b"II*\0"[..])
);
assert_eq!(tiff_payload_from_heif_item(Vec::new()), None);
assert_eq!(
tiff_payload_from_heif_item(vec![0, 0, 0, 0]),
Some(vec![0, 0, 0, 0])
);
}
}