Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

Read Canon maker-note lens when LensModel is missing

eliets29db9811759a4
diff --git a/crates/meta/src/exif.rs b/crates/meta/src/exif.rs
index adcba0f80..fa589594e 100644
--- a/crates/meta/src/exif.rs
+++ b/crates/meta/src/exif.rs
@@ -27,9 +27,9 @@ pub fn try_read_exif_with(bytes: &[u8], opts: &ParseOptions) -> Result<Metadata,
let data = strip_exif_header(bytes);
let tiff = Tiff::parse_with(data, opts)?;
let mut m = from_tiff(&tiff);
- // Panasonic writes no LensModel, only the name in its maker note (and in a RW2 that note is not in the raw's own Exif)
+ // Panasonic (and some Canons) write no LensModel, only the name in their maker note
if m.lens_model.is_none() {
- m.lens_model = panasonic_maker_note_lens(data, &tiff);
+ m.lens_model = panasonic_maker_note_lens(data, &tiff).or_else(|| canon_maker_note_lens(data, &tiff));
}
// the maker note's values are offsets into the stream, which `from_tiff` doesn't have
m.focus = crate::focus::read(data, &tiff, m.make.as_deref(), m.model.as_deref(), m.orientation);
@@ -201,6 +201,23 @@ fn panasonic_jpg_from_raw_lens(tiff: &Tiff) -> Option<String> {
panasonic_lens(data, &Tiff::parse(data).ok()?)
}
+/// Canon maker note tag `0x0001` (LensType in the ExifTool Canon tag names): the lens name as ASCII. Canon
+/// plain maker notes put the IFD at the note start with offsets relative to the enclosing TIFF header.
+const CANON_LENS_TYPE: u16 = 0x0001;
+
+/// The lens name in a Canon maker note of this Exif stream (`data` starts at its TIFF header): the note of
+/// its own Exif IFD. Only consulted when Make is Canon, so other vendors' plain notes are never read as lenses.
+fn canon_maker_note_lens(data: &[u8], tiff: &Tiff) -> Option<String> {
+ let make = tiff.ifds.first().and_then(|i| i.string(t::MAKE)).unwrap_or_default();
+ if !make.trim().to_ascii_uppercase().starts_with("CANON") {
+ return None;
+ }
+ let exif = tiff.exif()?;
+ let e = exif.get(t::MAKER_NOTE)?;
+ let mn = lightcraft_tiff::makernote::parse_makernote(data, e.offset, e.count() as u64, tiff.order, &make)?;
+ text(Some(&mn.ifd), CANON_LENS_TYPE)
+}
+
/// Nikon maker note tag `0x0084` (Lens in the ExifTool Nikon tag names): shortest and longest focal length, then the
/// widest aperture at each, as rationals, like Exif LensSpecification. Zero for a lens that doesn't report itself.
const NIKON_LENS: u16 = 0x0084;
@@ -297,6 +314,52 @@ pub(crate) mod tests {
assert_eq!(crate::extract(&rw2).lens_model.as_deref(), Some("LUMIX S 85/F1.8"));
}
+ /// Canon maker note tag holding the lens name as ASCII in a plain maker-note IFD (offsets relative to
+ /// the TIFF header, as Canon writes it).
+ const CANON_LENS_TAG: u16 = 0x0001;
+
+ /// An Exif block from a Canon EOS 5D: `Canon` / `Canon EOS 5D` in IFD0, no LensModel tag, and a maker
+ /// note whose plain IFD records the lens name at an offset relative to the TIFF header.
+ fn canon_exif(order: ByteOrder, lens: Option<&str>) -> Vec<u8> {
+ let name = lens.unwrap_or("Canon EF 50mm f/1.8 II");
+ let note = |at: u32| {
+ let mut v = Vec::new();
+ order.put_u16(&mut v, 1);
+ order.put_u16(&mut v, CANON_LENS_TAG);
+ order.put_u16(&mut v, 2); // ASCII
+ order.put_u32(&mut v, name.len() as u32);
+ // Value offset = at + size of IFD header (num_entries[2] + entry[12] + next_ifd[4] = 18)
+ // At this point v.len() == 10 (num_entries + tag + type + count); value field (4) + next_ifd (4) = 8 more.
+ let value_offset = at + v.len() as u32 + 8;
+ order.put_u32(&mut v, value_offset);
+ order.put_u32(&mut v, 0);
+ v.extend_from_slice(name.as_bytes());
+ v
+ };
+ let build = |at: u32| {
+ let mut exif = IfdBuilder::new();
+ exif.set(t::MAKER_NOTE, Value::Undefined(note(at)));
+ exif.set(t::FOCAL_LENGTH, Value::Rational(vec![(50, 1)]));
+ let mut ifd0 = IfdBuilder::new();
+ ifd0.set(t::MAKE, Value::Ascii("Canon".into()));
+ ifd0.set(t::MODEL, Value::Ascii("Canon EOS 5D".into()));
+ ifd0.set_child(t::EXIF_IFD, exif);
+ TiffWriter::new(order, false).write(&[ifd0]).unwrap()
+ };
+ // the note's own offset is only known once it is laid out; its length doesn't change
+ let first = build(0);
+ let at = Tiff::parse(&first).unwrap().exif().unwrap().get(t::MAKER_NOTE).unwrap().offset as u32;
+ build(at)
+ }
+
+ #[test]
+ fn canon_maker_note_lens_fills_lens_model() {
+ for order in [ByteOrder::Little, ByteOrder::Big] {
+ let m = read_exif(&canon_exif(order, Some("Canon EF 50mm f/1.8 II")));
+ assert_eq!(m.lens_model.as_deref(), Some("Canon EF 50mm f/1.8 II"));
+ }
+ }
+
/// An Exif block from a Nikon body whose maker note records the lens (tag 0x0084) and no LensModel or
/// LensSpecification, as the D700, D750, D80 and D5300 write it.
fn nikon_exif(make: &str, lens: Option<[(u32, u32); 4]>, spec: Option<[(u32, u32); 4]>) -> Vec<u8> {