exif-rs

The library can parse raw Exif data blocks or read Exif data directly from the following image formats:

• TIFF and some RAW image formats based on it
• JPEG
• HEIF and coding-specific variations (including HEIC and AVIF)
• PNG
• WebP

The Writer manages the complex relationships between different IFDs (Primary, Exif, GPS, Interop). When you push a field, the Writer uses the Field.ifd_num and the Tag's context to place it in the correct directory.

When write is called, the Writer automatically handles:

1. Pointer Synthesis: It calculates and writes the necessary pointer tags (like ExifIFDPointer) to link the Primary IFD to the Exif, GPS, or Interop IFDs.
2. Data Alignment: It ensures all values and offsets are written on proper word boundaries.
3. Image Data Offsets: It calculates and writes the actual offsets for StripOffsets, TileOffsets, and JPEGInterchangeFormat based on the raw data provided via set_strips, set_tiles, or set_jpeg.

The Context enum indicates how a tag number should be interpreted. It categorizes tags into different IFDs (Image File Directories):

• Context::Tiff: TIFF attributes defined in the TIFF Rev. 6.0 specification (0th/1st IFD).
• Context::Exif: Exif attributes (Exif IFD).
• Context::Gps: GPS attributes (GPS IFD).
• Context::Interop: Interoperability attributes (Interoperability IFD).

Because Endian is a trait, you can write functions that work with any endianness using generic type parameters. This is useful for building parsers that can switch between big-endian and little-endian modes based on the EXIF header metadata.

use exif::Endian;

fn parse_value<E: Endian>(data: &[u8]) -> u16 {
    E::loadu16(data, 0)
}

let val_be = parse_value::<BigEndian>(&[0x01, 0x02]);    // 0x0102
let val_le = parse_value::<LittleEndian>(&[0x01, 0x02]); // 0x0201

In TIFF/Exif, data is organized into Image File Directories (IFDs). The In struct represents these indices:

• In::PRIMARY (index 0): The main image data.
• In::THUMBNAIL (index 1): The thumbnail data.
• Other indices represent additional IFDs.

use exif::In;
assert_eq!(In::PRIMARY.index(), 0);
assert_eq!(In::THUMBNAIL.index(), 1);

To extract Exif attributes from an image file (supporting formats like TIFF, JPEG, HEIF, PNG, and WebP), use Reader::read_from_container. This method accepts any type that implements std::io::Read.

for path in &["tests/exif.jpg", "tests/exif.tif"] {
    let file = std::fs::File::open(path)?;
    let mut bufreader = std::io::BufReader::new(&file);
    let exifreader = exif::Reader::new();
    let exif = exifreader.read_from_container(&mut bufreader)?;
    for f in exif.fields() {
        println!("{} {} {}",
                 f.tag, f.ifd_num, f.display_value().with_unit(&exif));
    }
}

To use this library in your Rust project, add kamadak-exif to your Cargo.toml dependencies. Note that while the canonical crate name is exif, it is published to crates.io as kamadak-exif to avoid naming conflicts.

[dependencies]
kamadak-exif = "x.y.z"

Use is_jpeg to quickly determine if a byte slice starts with the standard JPEG Start of Image (SOI) marker (0xFF 0xD8).

let buf = &[0xff, 0xd8, 0x01, 0x02];
if is_jpeg(buf) {
    // The buffer is a JPEG
}

Use push_field to append a Field to the Writer. Fields can be appended in any order, but duplicate fields must not be appended.

Certain tags are automatically synthesized by the Writer and should not be manually pushed:

• ExifIFDPointer, GPSInfoIFDPointer, InteropIFDPointer (synthesized via IFD relationships)
• StripOffsets, StripByteCounts, TileOffsets, TileByteCounts (synthesized from strip/tile data)
• JPEGInterchangeFormat, JPEGInterchangeFormatLength (synthesized from JPEG data)

writer.push_field(&field);