diff --git a/Cargo.lock b/Cargo.lock index b21b46d3d3..80932ceff4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1222,6 +1222,15 @@ dependencies = [ "writeable", ] +[[package]] +name = "craft-tiff" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=3b3104981bb3093904a12e44d6a3b41c6c4c39c8#3b3104981bb3093904a12e44d6a3b41c6c4c39c8" +dependencies = [ + "serde", + "thiserror 2.0.21", +] + [[package]] name = "craft-ui" version = "0.1.0" @@ -3745,6 +3754,7 @@ dependencies = [ "ab_glyph", "chrono", "craft-docpath", + "craft-tiff", "crc32fast", "fs4", "harfrust 0.13.3", @@ -3773,7 +3783,6 @@ dependencies = [ "lightcraft-segment", "lightcraft-slideshow", "lightcraft-testkit", - "lightcraft-tiff", "log", "miniz_oxide 0.9.1", "rayon", @@ -3910,9 +3919,9 @@ name = "lightcraft-meta" version = "0.21.0" dependencies = [ "chrono", + "craft-tiff", "lightcraft-geom", "lightcraft-heif", - "lightcraft-tiff", "proptest", "quick-xml 0.41.0", "serde", @@ -3968,6 +3977,7 @@ version = "0.21.0" dependencies = [ "chrono", "craft-crw", + "craft-tiff", "dhat", "jpeg-encoder", "jxl-oxide", @@ -3976,7 +3986,6 @@ dependencies = [ "lightcraft-meta", "lightcraft-raster", "lightcraft-testkit", - "lightcraft-tiff", "miniz_oxide 0.9.1", "proptest", "rayon", @@ -4030,15 +4039,6 @@ version = "0.21.0" name = "lightcraft-testkit" version = "0.21.0" -[[package]] -name = "lightcraft-tiff" -version = "0.21.0" -dependencies = [ - "proptest", - "serde", - "thiserror 2.0.21", -] - [[package]] name = "lightcraft-ui-egui" version = "0.21.0" diff --git a/Cargo.toml b/Cargo.toml index 59ed59535c..ceb80a2ea4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -26,7 +26,8 @@ lightcraft-sysmem = { path = "crates/sysmem" } lightcraft-wincolor = { path = "crates/wincolor" } lightcraft-color = { path = "crates/color" } lightcraft-raster = { path = "crates/raster" } -lightcraft-tiff = { path = "crates/tiff" } +# TIFF/IFD: the shared reader and writer (moved from crates/tiff; craft-libs#783). +craft-tiff = { git = "https://github.com/storytold/craft-libs", rev = "3b3104981bb3093904a12e44d6a3b41c6c4c39c8" } lightcraft-raw = { path = "crates/raw" } lightcraft-codecs = { path = "crates/codecs" } lightcraft-meta = { path = "crates/meta" } diff --git a/crates/codecs/README.md b/crates/codecs/README.md index b993c52efe..7df71c9a11 100644 --- a/crates/codecs/README.md +++ b/crates/codecs/README.md @@ -48,7 +48,7 @@ CRW, MRW, X3F) are detected so the engine can route them to `lightcraft-raw`; `d |---|---|---|---| | JPEG | yes (zune-jpeg; jpeg-decoder for DCT scaling, CMYK/YCCK, 12-bit, non-interleaved scans) | yes (jpeg-encoder, baseline, 4:4:4/4:2:2/4:2:0) | EXIF (APP1), XMP (APP1, ≤ 64 KiB), ICC (APP2; only complete, consistently counted, uniquely numbered chunk sequences are assembled; malformed profiles use the existing unsupported-profile fallback), Adobe APP14, MPF previews | | PNG | yes, 1–16-bit, palette, tRNS, interlaced | 8/16-bit, gray/GA/RGB/RGBA | iCCP, eXIf, iTXt XMP; sRGB/cICP/cHRM/gAMA honoured when no ICC | -| TIFF | 8/16-bit int (32/64-bit int kept to 16 bits), 16/32/64-bit float, gray/RGB/CMYK/palette, alpha (assoc./unassoc.), planar, LZW/Deflate/PackBits/JPEG | 8/16-bit, 32-bit float; none/LZW/Deflate/PackBits | ICC (34675), XMP (700), Orientation; first IFD only; EXIF not written (use `lightcraft-tiff`) | +| TIFF | 8/16-bit int (32/64-bit int kept to 16 bits), 16/32/64-bit float, gray/RGB/CMYK/palette, alpha (assoc./unassoc.), planar, LZW/Deflate/PackBits/JPEG | 8/16-bit, 32-bit float; none/LZW/Deflate/PackBits | ICC (34675), XMP (700), Orientation; first IFD only; EXIF not written (use `craft-tiff`) | | WebP | lossy + lossless, alpha, first frame of animations | lossless only | ICCP/EXIF/XMP chunks | | GIF / BMP | yes (first GIF frame) | — | via `image` | | PSD / PSB | merged composite: 8/16/32-bit gray, RGB, CMYK, indexed, duotone (as gray); raw/RLE | — | ICC (1039), EXIF (1058), XMP (1060); ZIP-compressed composite, Lab and 1-bit unsupported | diff --git a/crates/codecs/src/encode.rs b/crates/codecs/src/encode.rs index 82f654adf2..18e8be64aa 100644 --- a/crates/codecs/src/encode.rs +++ b/crates/codecs/src/encode.rs @@ -229,7 +229,7 @@ pub enum TiffCompression { } /// Encode TIFF: 8/16-bit integer or 32-bit float, gray/RGB with optional (unassociated) alpha. -/// ICC and XMP are embedded; EXIF is not (write it through the TIFF writer in `lightcraft-tiff`). +/// ICC and XMP are embedded; EXIF is not (write it through the TIFF writer in `craft-tiff`). pub fn encode_tiff(img: &EncodeImage, compression: TiffCompression, meta: &EncodeMeta) -> Result> { use tiff::encoder::{Compression, DeflateLevel, TiffEncoder}; use tiff::tags::Predictor; diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml index 895ef52126..ab73adb42e 100644 --- a/crates/engine/Cargo.toml +++ b/crates/engine/Cargo.toml @@ -68,4 +68,4 @@ jxl-oxide = { workspace = true } # Lossless synthetic HEIC files (the import test; decoded when the codecs' `heif` feature is on). lightcraft-heif = { workspace = true, features = ["testdata"] } libc = { workspace = true } -lightcraft-tiff = { workspace = true } +craft-tiff = { workspace = true } diff --git a/crates/engine/src/files/tests.rs b/crates/engine/src/files/tests.rs index 9700adce65..ff50d94ab6 100644 --- a/crates/engine/src/files/tests.rs +++ b/crates/engine/src/files/tests.rs @@ -281,7 +281,7 @@ fn tiff_with_preview_strip(strip: &[u8], tail: usize, what: Fixture) -> Vec /// [`tiff_with_preview_strip`] that also keeps the `smaller` JPEGs in sub-IFDs of IFD0, as an ARW keeps its /// 1616 px preview beside the full-size one. fn tiff_with_preview_strips(strip: &[u8], smaller: &[&[u8]], tail: usize, what: Fixture) -> Vec { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; let mut preview = IfdBuilder::new(); if what.dng { preview.set(t::DNG_VERSION, Value::Byte(vec![1, 4, 0, 0])); @@ -662,7 +662,7 @@ fn corpus_a7cr_warp_keeps_coordinates_after_orientation_and_resizing() { let Ok(mut bytes) = std::fs::read(root.join("raw").join(name)) else { continue }; let off = lightcraft_raw::probe_info(&bytes).unwrap(); assert!(embedded_lens(&off).is_none()); - let tiff = lightcraft_tiff::Tiff::parse(&bytes).unwrap(); + let tiff = craft_tiff::Tiff::parse(&bytes).unwrap(); let at = tiff.find(0x7036).unwrap().offset as usize; let mut enabled = Vec::new(); tiff.order.put_u16(&mut enabled, 17); @@ -1220,8 +1220,8 @@ fn corpus_clipped_sky_beside_a_tree_has_no_coloured_halo() { /// copy's samples are much brighter than the image's here, so a picture says which one it came from. #[test] fn exports_never_develop_a_dngs_reduced_copy() { - use lightcraft_tiff::tags::{self as t, photometric}; - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::tags::{self as t, photometric}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; use serde_json::json; let linear = |subfile: u32, w: u32, h: u32, sample: u16| { let mut ifd = IfdBuilder::new(); @@ -1298,10 +1298,10 @@ fn exports_never_develop_a_dngs_reduced_copy() { /// heuristic would never look) is used; a matte with an unknown name is ignored. #[test] fn dng_sky_matte_drives_the_sky_mask() { + use craft_tiff::tags::{self as t, photometric}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; use lightcraft_develop::{DevelopSettings, LocalAdjustments, Mask, MaskComponent, MaskOp, MaskShape}; use lightcraft_pipeline::{RenderRequest, render}; - use lightcraft_tiff::tags::{self as t, photometric}; - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; let (w, h) = (16u32, 8u32); let image = |ifd: &mut IfdBuilder, w: u32, h: u32, cpp: u16, bits: u16, data: Vec| { ifd.set(t::IMAGE_WIDTH, Value::Long(vec![w])); @@ -1536,7 +1536,7 @@ fn unsupported_raw_imports_as_preview_only_and_survives_reopen() { /// A raw whose TIFF shell holds only a small RGB image (IFD0) next to a private block, as Exif /// declares a picture 25x its size. fn tiff_shell(w: u32, h: u32, shell: bool) -> Vec { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; let mut ifd0 = IfdBuilder::new(); ifd0.set(t::IMAGE_WIDTH, Value::Long(vec![w])); ifd0.set(t::IMAGE_LENGTH, Value::Long(vec![h])); @@ -1577,7 +1577,7 @@ fn thumbnail_only_tiff_raw_is_preview_only_not_a_plain_image() { // TIFFs preserving camera Make tags (SONY, NIKON, etc.) are ordinary images, not raws (#281) for make in ["SONY", "NIKON CORPORATION", "PENTAX", "RICOH", "SAMSUNG"] { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; let mut ifd0 = IfdBuilder::new(); ifd0.set(t::IMAGE_WIDTH, Value::Long(vec![24])); ifd0.set(t::IMAGE_LENGTH, Value::Long(vec![16])); @@ -1621,7 +1621,7 @@ fn undecodable_container_with_a_preview_imports_as_preview_only() { /// holds the preview) imports as a raw shown from its preview, not as a greyscale image of the mosaic. #[test] fn uncompressed_leaf_mos_imports_as_a_preview_only_raw() { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; let px: Vec = (0..40 * 30).flat_map(|i| [(i % 251) as u8, 128, 200]).collect(); let jpeg = encode_jpeg(&EncodeImage::new(40, 30, 3, Samples::U8(&px)), 90, ChromaSubsampling::S444, &EncodeMeta::default()).unwrap(); let mos = |leaf_data: bool| { @@ -1652,7 +1652,7 @@ fn uncompressed_leaf_mos_imports_as_a_preview_only_raw() { /// headers; loading it says what is wrong instead of naming a bare TIFF compression number. #[test] fn gopro_vc5_dng_imports_and_fails_to_load_with_a_clear_reason() { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; let mut ifd = IfdBuilder::new(); ifd.set(t::NEW_SUBFILE_TYPE, Value::Long(vec![0])); ifd.set(t::IMAGE_WIDTH, Value::Long(vec![32])); @@ -1681,7 +1681,7 @@ fn decode_failures_of_recognised_raws_may_fall_back_to_the_preview() { assert_eq!(preview_reason(b"x", RawError::Unsupported("x".into())), Ok("x".to_string())); assert!(preview_reason(b"x", RawError::Corrupt("bad strip".into())).is_ok_and(|w| w.contains("bad strip"))); assert!(preview_reason(b"x", RawError::Limit("too big")).is_ok()); - assert!(preview_reason(b"x", RawError::Tiff(lightcraft_tiff::TiffError::MissingTag(256))).is_ok()); + assert!(preview_reason(b"x", RawError::Tiff(craft_tiff::TiffError::MissingTag(256))).is_ok()); assert!(preview_reason(b"x", RawError::NotRaw).is_err()); assert!(preview_reason(cr3, RawError::Corrupt("bad".into())).is_ok_and(|w| w.starts_with("CR3 "))); } @@ -1746,8 +1746,8 @@ fn a_quick_thumbnail_without_an_embedded_preview_renders_the_raw() { /// A Sony ARW of `model`: a 64 × 48 uncompressed 14-bit CFA strip in a SubIFD (as `crates/raw/tests/it/vendor_robust.rs` /// lays it out) whose IFD carries the full-frame 16–35 mm distortion table (tag 0x7037). fn sony_arw(model: &str) -> Vec { - use lightcraft_tiff::tags::{self as t, photometric}; - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::tags::{self as t, photometric}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; // 3:2, the aspect Sony's lens opcodes are limited to let (w, h) = (72u32, 48u32); let mut raw = IfdBuilder::new(); diff --git a/crates/engine/src/tests/face_tiles.rs b/crates/engine/src/tests/face_tiles.rs index d3b50aefc4..37d20b58b0 100644 --- a/crates/engine/src/tests/face_tiles.rs +++ b/crates/engine/src/tests/face_tiles.rs @@ -46,7 +46,7 @@ fn jpeg(w: u32, h: u32, px: impl Fn(u32, u32) -> [u8; 3]) -> Vec { /// photo by its largest preview (600 × 400) and the develop path renders from it, after reading /// the whole file. fn raw_with_two_previews(tail: usize) -> Vec { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; let preview = |w: u32, h: u32, bytes: Vec, first: bool| { let mut ifd = IfdBuilder::new(); if first { diff --git a/crates/engine/src/tests/import.rs b/crates/engine/src/tests/import.rs index 4885b5d30b..95be627fc5 100644 --- a/crates/engine/src/tests/import.rs +++ b/crates/engine/src/tests/import.rs @@ -34,7 +34,7 @@ fn write_png(path: &Path, seed: u8) { } fn exif_clock_block(original: Option<&str>, digitized: Option<&str>) -> Vec { - use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; + use craft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; let mut exif = IfdBuilder::new(); if let Some(value) = original { @@ -2857,8 +2857,8 @@ fn heic_imports_as_a_normal_photo_or_says_why_not() { /// writes as UTC: an iPhone photo landed five hours late and after 19:00 on the wrong day. #[test] fn a_heic_is_dated_by_its_exif_and_not_by_the_file() { + use craft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value, tags as t}; use lightcraft_heif::testdata::{Spec, build}; - use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value, tags as t}; let src = temp_dir("heic-capture-time"); let photo = |x: u32, y: u32| [((x * 7 + y * 13) % 200 + 30) as u16, 110, 150]; let mut exif = IfdBuilder::new(); diff --git a/crates/engine/src/tests/xmp.rs b/crates/engine/src/tests/xmp.rs index 0d27be67c9..006a0a488a 100644 --- a/crates/engine/src/tests/xmp.rs +++ b/crates/engine/src/tests/xmp.rs @@ -638,7 +638,7 @@ fn an_orientation_only_the_xmp_states_leaves_stored_frame_regions_as_written() { let img = lightcraft_raster::Rgba8::from_fn(32, 24, |x, y| [(x * 7) as u8, (y * 9) as u8, 90, 255]); // an Exif that states the size as stored (32 × 24, as cameras do) and no orientation let exif = { - use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value, tags as t}; + use craft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value, tags as t}; let mut sub = IfdBuilder::new(); sub.set(t::PIXEL_X_DIMENSION, Value::Long(vec![32])); sub.set(t::PIXEL_Y_DIMENSION, Value::Long(vec![24])); @@ -681,7 +681,7 @@ fn a_raws_decoder_orientation_turns_stored_frame_regions_on_import_and_reread() let px: Vec = (0..16 * 6).map(|i| (i * 41 % 4096) as u16).collect(); let strip: Vec = px.chunks(2).flat_map(|p| [(p[0] >> 4) as u8, ((p[0] & 15) << 4) as u8 | (p[1] >> 8) as u8, p[1] as u8]).collect(); { - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value, tags as t}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value, tags as t}; let mut raw = IfdBuilder::new(); raw.set(t::NEW_SUBFILE_TYPE, Value::Long(vec![0])); raw.set(t::IMAGE_WIDTH, Value::Long(vec![16])); diff --git a/crates/meta/Cargo.toml b/crates/meta/Cargo.toml index 4f2fad315e..e570fe21de 100644 --- a/crates/meta/Cargo.toml +++ b/crates/meta/Cargo.toml @@ -9,7 +9,7 @@ description = "LightCraft metadata: EXIF, XMP, IPTC (L1)" workspace = true [dependencies] -lightcraft-tiff = { workspace = true } +craft-tiff = { workspace = true } lightcraft-geom = { workspace = true } serde = { workspace = true } quick-xml = { workspace = true } diff --git a/crates/meta/src/container.rs b/crates/meta/src/container.rs index 0136bf6846..5b4242bfff 100644 --- a/crates/meta/src/container.rs +++ b/crates/meta/src/container.rs @@ -14,7 +14,7 @@ //! - HEIF/HEIC/AVIF (ISO base media file, see [`crate::heif`]): the `Exif` item's TIFF stream and the XMP //! `mime` item. -use lightcraft_tiff::{Tiff, tags}; +use craft_tiff::{Tiff, tags}; /// Metadata blocks found in a file. #[derive(Clone, Debug, Default, PartialEq, Eq)] @@ -71,8 +71,8 @@ pub fn embedded(bytes: &[u8]) -> Embedded { xmp_extended: None, icc: ifd0.bytes(tags::ICC_PROFILE).map(|b| b.to_vec()), iptc: ifd0.value(tags::IPTC_NAA).map(|v| match v { - lightcraft_tiff::Value::Byte(b) | lightcraft_tiff::Value::Undefined(b) => b.clone(), - other => lightcraft_tiff::writer::encode(t.order, other), + craft_tiff::Value::Byte(b) | craft_tiff::Value::Undefined(b) => b.clone(), + other => craft_tiff::writer::encode(t.order, other), }), } } else { @@ -275,7 +275,7 @@ pub fn webp_chunks(b: &[u8]) -> Embedded { mod tests { use super::*; use crate::exif::tests::sample_exif; - use lightcraft_tiff::ByteOrder; + use craft_tiff::ByteOrder; fn seg(marker: u8, payload: &[u8]) -> Vec { let mut v = vec![0xff, marker]; diff --git a/crates/meta/src/cr3.rs b/crates/meta/src/cr3.rs index a95b8baada..0a90f733e9 100644 --- a/crates/meta/src/cr3.rs +++ b/crates/meta/src/cr3.rs @@ -436,13 +436,13 @@ fn le32(b: &[u8], at: usize) -> Option { /// Merge `CMT1` (IFD0), `CMT2` (Exif) and `CMT4` (GPS) into one TIFF stream, so the Exif readers see a CR3 /// like any TIFF-based raw. The maker note (`CMT3`) is left out: its offsets are relative to its own block. pub fn merged_exif(c: &Cr3<'_>) -> Option> { - use lightcraft_tiff::{IfdBuilder, Tiff, TiffWriter, tags as t}; + use craft_tiff::{IfdBuilder, Tiff, TiffWriter, tags as t}; let ifd0 = Tiff::parse(c.cmt[0]?).ok()?; let order = ifd0.order; let first = |i: usize| c.cmt[i].and_then(|b| Tiff::parse(b).ok()).and_then(|t| t.ifds.into_iter().next()); // pointers and offsets that would dangle once the IFDs move const SKIP: [u16; 9] = [t::EXIF_IFD, t::GPS_IFD, t::INTEROP_IFD, t::SUB_IFDS, t::MAKER_NOTE, 273, 279, 513, 514]; - let build = |ifd: &lightcraft_tiff::Ifd| { + let build = |ifd: &craft_tiff::Ifd| { let mut b = IfdBuilder::new(); for e in ifd.entries.iter().filter(|e| !SKIP.contains(&e.tag)) { b.set(e.tag, e.value.clone()); @@ -497,14 +497,14 @@ mod tests { let stbl = [full(b"stsd", &stsd), full(b"stsz", &stsz), full(b"co64", &co64)].concat(); bx(b"trak", &bx(b"mdia", &bx(b"minf", &bx(b"stbl", &stbl)))) } - fn tiff_with(tag: u16, v: lightcraft_tiff::Value) -> Vec { - let b = lightcraft_tiff::IfdBuilder::new().with(tag, v); - lightcraft_tiff::TiffWriter::new(lightcraft_tiff::ByteOrder::Little, false).write(&[b]).unwrap() + fn tiff_with(tag: u16, v: craft_tiff::Value) -> Vec { + let b = craft_tiff::IfdBuilder::new().with(tag, v); + craft_tiff::TiffWriter::new(craft_tiff::ByteOrder::Little, false).write(&[b]).unwrap() } /// A small synthetic CR3: Canon uuid with CMT1/CMT2/CMT4, a JPEG track, a raw track, XMP. pub(crate) fn sample() -> Vec { - use lightcraft_tiff::{Value, tags as t}; + use craft_tiff::{Value, tags as t}; let cmt1 = tiff_with(t::MODEL, Value::Ascii("Canon EOS Test".into())); let cmt2 = tiff_with(t::ISO_SPEED, Value::Short(vec![400])); let cmt4 = tiff_with(1, Value::Ascii("N".into())); @@ -689,7 +689,7 @@ mod tests { #[test] fn timed_metadata_exposes_the_dynamic_maker_note() { - use lightcraft_tiff::{Value, tags as t}; + use craft_tiff::{Value, tags as t}; let exif = tiff_with(t::ISO_SPEED, Value::Short(vec![800])); let maker = tiff_with(0x4001, Value::Short(vec![48, 100, 200])); let item = |tag: u32, data: &[u8]| { diff --git a/crates/meta/src/exif.rs b/crates/meta/src/exif.rs index 9894f016ba..7602e115de 100644 --- a/crates/meta/src/exif.rs +++ b/crates/meta/src/exif.rs @@ -1,7 +1,7 @@ //! Exif / TIFF tags → [`Metadata`] (CIPA DC-008 Exif 2.32, TIFF 6.0, DNG 1.7 tag semantics). use crate::{DateTime, Flash, Gps, Metadata, Orientation}; -use lightcraft_tiff::{Ifd, ParseOptions, Tiff, TiffError, tags as t}; +use craft_tiff::{Ifd, ParseOptions, Tiff, TiffError, tags as t}; /// Strip an `Exif\0\0` (or `Exif\0\xff`) prefix as found in JPEG APP1 and some WebP `EXIF` chunks. pub fn strip_exif_header(b: &[u8]) -> &[u8] { @@ -129,8 +129,8 @@ pub fn from_tiff(tiff: &Tiff) -> Metadata { if let Some(iptc) = ifd0.and_then(|i| i.value(t::IPTC_NAA)) { // IPTC-NAA is often typed LONG; re-serialise to bytes in file order. let bytes = match iptc { - lightcraft_tiff::Value::Byte(b) | lightcraft_tiff::Value::Undefined(b) => b.clone(), - other => lightcraft_tiff::writer::encode(tiff.order, other), + craft_tiff::Value::Byte(b) | craft_tiff::Value::Undefined(b) => b.clone(), + other => craft_tiff::writer::encode(tiff.order, other), }; m.fill_missing(&crate::parse_iptc(&bytes)); } @@ -200,7 +200,7 @@ fn panasonic_lens(data: &[u8], tiff: &Tiff) -> Option { } let e = exif.get(t::MAKER_NOTE)?; let make = tiff.ifds.first().and_then(|i| i.string(t::MAKE)).unwrap_or_default(); - let mn = lightcraft_tiff::makernote::parse_makernote(data, e.offset, e.count() as u64, tiff.order, &make)?; + let mn = craft_tiff::makernote::parse_makernote(data, e.offset, e.count() as u64, tiff.order, &make)?; text(Some(&mn.ifd), PANASONIC_LENS_TYPE) } @@ -225,7 +225,7 @@ fn canon_maker_note_lens(data: &[u8], tiff: &Tiff) -> Option { } 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)?; + let mn = craft_tiff::makernote::parse_makernote(data, e.offset, e.count() as u64, tiff.order, &make)?; text(Some(&mn.ifd), CANON_LENS_MODEL) } @@ -234,13 +234,13 @@ fn canon_maker_note_lens(data: &[u8], tiff: &Tiff) -> Option { const NIKON_LENS: u16 = 0x0084; /// The lens a Nikon camera records in its maker note, when it's plausible. -fn nikon_lens_spec(exif: Option<&Ifd>, make: Option<&str>, order: lightcraft_tiff::ByteOrder) -> Option<[f64; 4]> { +fn nikon_lens_spec(exif: Option<&Ifd>, make: Option<&str>, order: craft_tiff::ByteOrder) -> Option<[f64; 4]> { let make = make?; if !make.trim().to_ascii_uppercase().starts_with("NIKON") { return None; } let note = exif?.bytes(t::MAKER_NOTE)?; - let mn = lightcraft_tiff::makernote::parse_makernote(note, 0, note.len() as u64, order, make)?; + let mn = craft_tiff::makernote::parse_makernote(note, 0, note.len() as u64, order, make)?; let s = mn.ifd.f64s(NIKON_LENS)?; let [short, long, wide, narrow] = s.as_slice() else { return None }; let focal = |f: f64| f.is_finite() && f > 0.0 && f < 10_000.0; @@ -251,7 +251,7 @@ fn nikon_lens_spec(exif: Option<&Ifd>, make: Option<&str>, order: lightcraft_tif #[cfg(test)] pub(crate) mod tests { use super::*; - use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; + use craft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; fn capture_time_tiff(original: Option<&str>, digitized: Option<&str>, ifd0_time: Option<&str>, xmp: Option<&str>) -> Vec { let mut exif = IfdBuilder::new(); @@ -602,19 +602,19 @@ pub(crate) mod tests { } /// An exact `1/N` rational for a sub-second value whose reciprocal is a whole number (shutter speeds such as -/// 1/12800 s, which [`lightcraft_tiff::writer::rational`]'s decimal denominators cannot represent). -fn reciprocal(v: Option) -> Option { +/// 1/12800 s, which [`craft_tiff::writer::rational`]'s decimal denominators cannot represent). +fn reciprocal(v: Option) -> Option { let v = v.filter(|v| v.is_finite() && *v > 0.0 && *v < 1.0)?; let inv = 1.0 / v; - ((inv - inv.round()).abs() < 1e-6 && inv.round() <= u32::MAX as f64).then(|| lightcraft_tiff::Value::Rational(vec![(1, inv.round() as u32)])) + ((inv - inv.round()).abs() < 1e-6 && inv.round() <= u32::MAX as f64).then(|| craft_tiff::Value::Rational(vec![(1, inv.round() as u32)])) } /// Serialise the interchange subset of `meta` as a TIFF-structured Exif block (little-endian, no /// `Exif\0\0` prefix): IFD0 (make, model, software, artist, copyright, description, orientation, /// date), the Exif IFD (capture settings, lens) and, when present, the GPS IFD. pub fn write_exif(meta: &Metadata) -> Vec { - use lightcraft_tiff::writer::{rational, srational}; - use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; + use craft_tiff::writer::{rational, srational}; + use craft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; let ascii = |s: &Option| s.as_ref().filter(|v| !v.is_empty()).map(|v| Value::Ascii(v.clone())); let mut ifd0 = IfdBuilder::new(); for (tag, v) in [ diff --git a/crates/meta/src/focus.rs b/crates/meta/src/focus.rs index 5107829989..b956e667ed 100644 --- a/crates/meta/src/focus.rs +++ b/crates/meta/src/focus.rs @@ -31,7 +31,7 @@ pub use crate::focus_read::{HEADER_PREFIX, HeaderRead, MAX_HEADER_BYTES, read_header}; use crate::{Orientation, Rect}; -use lightcraft_tiff::{ByteOrder, Ifd, Tiff, makernote, tags as t}; +use craft_tiff::{ByteOrder, Ifd, Tiff, makernote, tags as t}; use serde::{Deserialize, Serialize}; /// Where the camera focused, on the upright photo. diff --git a/crates/meta/src/focus/tests.rs b/crates/meta/src/focus/tests.rs index e5f79fbfe5..148f5ed999 100644 --- a/crates/meta/src/focus/tests.rs +++ b/crates/meta/src/focus/tests.rs @@ -1,5 +1,5 @@ use super::*; -use lightcraft_tiff::{Entry, IfdBuilder, TiffWriter, Value}; +use craft_tiff::{Entry, IfdBuilder, TiffWriter, Value}; fn encipher(p: u8) -> u8 { if p >= 249 { p } else { ((u32::from(p).pow(3)) % 249) as u8 } @@ -206,7 +206,7 @@ fn sony_file_with(make: &str, model: &str, orientation: u16, note_entries: &[(u1 let mut outside: Vec = Vec::new(); order.put_u16(&mut note, note_entries.len() as u16); for (tag, v) in note_entries { - let raw = lightcraft_tiff::writer::encode(order, v); + let raw = craft_tiff::writer::encode(order, v); order.put_u16(&mut note, *tag); order.put_u16(&mut note, v.field_type() as u16); order.put_u32(&mut note, v.count() as u32); diff --git a/crates/meta/src/focus_read.rs b/crates/meta/src/focus_read.rs index 65adbee754..14547b051e 100644 --- a/crates/meta/src/focus_read.rs +++ b/crates/meta/src/focus_read.rs @@ -14,7 +14,7 @@ use std::io; use crate::focus::FocusPoint; -use lightcraft_tiff::{ByteOrder, FieldType, Tiff, tags as t}; +use craft_tiff::{ByteOrder, FieldType, Tiff, tags as t}; /// Bytes read first: the α1's and A7S III's focus data ends before 16 KB, so one read covers it. pub const HEADER_PREFIX: u64 = 32 * 1024; @@ -176,8 +176,7 @@ fn tiff(r: &mut Reader, head: Vec) -> io::Result> { // file length: only the loaded ranges are data, and an unrelated entry that claims a // huge value must be cut by what leaving it cost, not by what the buffer claims to hold. // The same 8 × / + 1 MiB shape the general TIFF reader uses, over `reader.bytes` instead. - let opts = - lightcraft_tiff::ParseOptions { value_budget: Some(r.bytes.saturating_mul(8).saturating_add(1 << 20)), ..Default::default() }; + let opts = craft_tiff::ParseOptions { value_budget: Some(r.bytes.saturating_mul(8).saturating_add(1 << 20)), ..Default::default() }; return Ok(crate::try_read_exif_with(&buf, &opts).ok().and_then(|m| m.focus)); } Step::Nothing => return Ok(None), @@ -354,7 +353,7 @@ impl Want<'_> { /// What of a classic TIFF the focus decoder still needs, given what is `loaded`: IFD0 (Make, Model, /// the Exif pointer), the Exif IFD (the maker-note entry), the maker note's header and IFD as -/// `lightcraft_tiff::makernote` locates it, and the focus tags' values. +/// `craft_tiff::makernote` locates it, and the focus tags' values. fn plan(buf: &[u8], loaded: &Loaded) -> Step { let Some((order, false)) = Tiff::sniff(buf) else { return Step::Nothing }; let mut w = Want { buf, order, loaded, need: Vec::new() }; diff --git a/crates/meta/src/heif.rs b/crates/meta/src/heif.rs index 1d768f7a69..ce3a133831 100644 --- a/crates/meta/src/heif.rs +++ b/crates/meta/src/heif.rs @@ -198,7 +198,7 @@ mod tests { use super::*; // the whole routing, not just this module: a HEIC must reach the HEIF branch of `embedded` use crate::embedded; - use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value, tags as t}; + use craft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value, tags as t}; /// One box: its own size, its four-letter kind, then its payload. fn bx(kind: &[u8; 4], payload: &[u8]) -> Vec { diff --git a/crates/meta/src/lib.rs b/crates/meta/src/lib.rs index 91186e3d8c..4844168119 100644 --- a/crates/meta/src/lib.rs +++ b/crates/meta/src/lib.rs @@ -555,7 +555,7 @@ mod tests { j.extend(payload); }; // orientation 6, 6000 × 4000 as stored - seg([b"Exif\0\0".as_slice(), &crate::exif::tests::sample_exif(lightcraft_tiff::ByteOrder::Little)].concat()); + seg([b"Exif\0\0".as_slice(), &crate::exif::tests::sample_exif(craft_tiff::ByteOrder::Little)].concat()); seg([b"http://ns.adobe.com/xap/1.0/\0".as_slice(), packet.as_bytes()].concat()); j.extend([0xff, 0xd9]); j @@ -600,10 +600,10 @@ mod tests { assert!(near(m.regions[0].rect, DRAWN), "{:?}", m.regions[0].rect); assert_eq!(try_extract(&j).unwrap().regions, m.regions); // a TIFF-based file: the whole file is the Exif block, with the XMP in its first IFD - let mut ifd0 = lightcraft_tiff::IfdBuilder::new(); - ifd0.set(lightcraft_tiff::tags::ORIENTATION, lightcraft_tiff::Value::Short(vec![6])); - ifd0.set(lightcraft_tiff::tags::XMP, lightcraft_tiff::Value::Byte(packet.into_bytes())); - let m = extract(&lightcraft_tiff::TiffWriter::default().write(&[ifd0]).unwrap()); + let mut ifd0 = craft_tiff::IfdBuilder::new(); + ifd0.set(craft_tiff::tags::ORIENTATION, craft_tiff::Value::Short(vec![6])); + ifd0.set(craft_tiff::tags::XMP, craft_tiff::Value::Byte(packet.into_bytes())); + let m = extract(&craft_tiff::TiffWriter::default().write(&[ifd0]).unwrap()); assert_eq!((m.orientation, m.width, m.height), (Some(Orientation::Rotate90), Some(4000), Some(6000))); assert!(near(m.regions[0].rect, DRAWN), "TIFF: {:?}", m.regions[0].rect); } @@ -615,14 +615,14 @@ mod tests { fn an_orientation_only_the_xmp_states_turns_no_regions() { // 6000 × 4000 in the Exif, and no orientation let size_ifd = || { - let mut sub = lightcraft_tiff::IfdBuilder::new(); - sub.set(lightcraft_tiff::tags::PIXEL_X_DIMENSION, lightcraft_tiff::Value::Long(vec![6000])); - sub.set(lightcraft_tiff::tags::PIXEL_Y_DIMENSION, lightcraft_tiff::Value::Long(vec![4000])); + let mut sub = craft_tiff::IfdBuilder::new(); + sub.set(craft_tiff::tags::PIXEL_X_DIMENSION, craft_tiff::Value::Long(vec![6000])); + sub.set(craft_tiff::tags::PIXEL_Y_DIMENSION, craft_tiff::Value::Long(vec![4000])); sub }; - let mut exif_ifd0 = lightcraft_tiff::IfdBuilder::new(); - exif_ifd0.set_child(lightcraft_tiff::tags::EXIF_IFD, size_ifd()); - let exif = lightcraft_tiff::TiffWriter::new(lightcraft_tiff::ByteOrder::Little, false).write(&[exif_ifd0]).unwrap(); + let mut exif_ifd0 = craft_tiff::IfdBuilder::new(); + exif_ifd0.set_child(craft_tiff::tags::EXIF_IFD, size_ifd()); + let exif = craft_tiff::TiffWriter::new(craft_tiff::ByteOrder::Little, false).write(&[exif_ifd0]).unwrap(); let packet = regions_packet(6000, 4000, "") .replace(r#"rdf:about="""#, r#"rdf:about="" xmlns:tiff="http://ns.adobe.com/tiff/1.0/" tiff:Orientation="6""#); let mut j = vec![0xff, 0xd8]; @@ -641,10 +641,10 @@ mod tests { assert!(near(m.regions[0].rect, DRAWN), "turned by an orientation the Exif doesn't state: {:?}", m.regions[0].rect); assert_eq!(try_extract(&j).unwrap().regions, m.regions); // a TIFF-based file: the first IFD has no orientation, its XMP (tag 700) has - let mut ifd0 = lightcraft_tiff::IfdBuilder::new(); - ifd0.set(lightcraft_tiff::tags::XMP, lightcraft_tiff::Value::Byte(packet.into_bytes())); - ifd0.set_child(lightcraft_tiff::tags::EXIF_IFD, size_ifd()); - let m = extract(&lightcraft_tiff::TiffWriter::default().write(&[ifd0]).unwrap()); + let mut ifd0 = craft_tiff::IfdBuilder::new(); + ifd0.set(craft_tiff::tags::XMP, craft_tiff::Value::Byte(packet.into_bytes())); + ifd0.set_child(craft_tiff::tags::EXIF_IFD, size_ifd()); + let m = extract(&craft_tiff::TiffWriter::default().write(&[ifd0]).unwrap()); assert_eq!(m.orientation, Some(Orientation::Rotate90)); assert!(near(m.regions[0].rect, DRAWN), "TIFF: {:?}", m.regions[0].rect); } diff --git a/crates/meta/src/psd.rs b/crates/meta/src/psd.rs index bda16d9602..ebdbdaf723 100644 --- a/crates/meta/src/psd.rs +++ b/crates/meta/src/psd.rs @@ -177,9 +177,9 @@ mod tests { #[test] fn try_extract_accepts_unknown_exif_tags_in_psd() { - let mut ifd0 = lightcraft_tiff::IfdBuilder::new(); - ifd0.set(0xc001, lightcraft_tiff::Value::Ascii("vendor metadata".into())); - let exif = lightcraft_tiff::TiffWriter::default().write(&[ifd0]).unwrap(); + let mut ifd0 = craft_tiff::IfdBuilder::new(); + ifd0.set(0xc001, craft_tiff::Value::Ascii("vendor metadata".into())); + let exif = craft_tiff::TiffWriter::default().write(&[ifd0]).unwrap(); let file = image(1, &[], &resource(1058, b"", &exif)); assert!(crate::try_extract(&file).is_ok()); } diff --git a/crates/meta/src/tags.rs b/crates/meta/src/tags.rs index 643d0fb28d..e16e5663a4 100644 --- a/crates/meta/src/tags.rs +++ b/crates/meta/src/tags.rs @@ -4,7 +4,7 @@ //! binary blobs are summarised by size; of a maker note only the lens name is listed (the //! Panasonic one, as Panasonic writes no Exif LensModel). -use lightcraft_tiff::{Ifd, Tiff, Value}; +use craft_tiff::{Ifd, Tiff, Value}; /// One metadata row. #[derive(Clone, Debug, PartialEq)] @@ -318,7 +318,7 @@ fn nikon_nef_compression(tiff: &Tiff, bytes: &[u8]) -> Option<&'static str> { return None; } let e = ifd0.exif.as_ref()?.get(0x927c)?; - let mn = lightcraft_tiff::makernote::parse_makernote(bytes, e.offset, e.count() as u64, tiff.order, &make)?; + let mn = craft_tiff::makernote::parse_makernote(bytes, e.offset, e.count() as u64, tiff.order, &make)?; nef_compression(mn.ifd.u32(0x0093)?) } @@ -516,7 +516,7 @@ mod tests { let rw2 = crate::exif::tests::panasonic_rw2("LUMIX S 85/F1.8"); assert_eq!(lens(&file_tag_rows(&rw2)), ["LUMIX S 85/F1.8"]); // a JPEG: the note is in its own Exif - let exif = crate::exif::tests::panasonic_exif(lightcraft_tiff::ByteOrder::Big, Some("LUMIX G 25/F1.7"), None); + let exif = crate::exif::tests::panasonic_exif(craft_tiff::ByteOrder::Big, Some("LUMIX G 25/F1.7"), None); let mut jpg = vec![0xff, 0xd8, 0xff, 0xe1]; jpg.extend_from_slice(&((exif.len() + 8) as u16).to_be_bytes()); jpg.extend(b"Exif\0\0"); diff --git a/crates/meta/src/xmp.rs b/crates/meta/src/xmp.rs index b7ee773763..600ca0fbb5 100644 --- a/crates/meta/src/xmp.rs +++ b/crates/meta/src/xmp.rs @@ -656,12 +656,12 @@ fn frac(v: f64) -> String { return format!("1/{}", inv.round() as u64); } } - let (n, d) = lightcraft_tiff::writer::rational(v); + let (n, d) = craft_tiff::writer::rational(v); format!("{n}/{d}") } fn sfrac(v: f64) -> String { - let (n, d) = lightcraft_tiff::writer::srational(v); + let (n, d) = craft_tiff::writer::srational(v); format!("{n}/{d}") } diff --git a/crates/raw/Cargo.toml b/crates/raw/Cargo.toml index 50ecfc3719..18bf6d76c2 100644 --- a/crates/raw/Cargo.toml +++ b/crates/raw/Cargo.toml @@ -9,7 +9,7 @@ description = "LightCraft RAW decoding, demosaicing and DNG colour model (L1)" workspace = true [dependencies] -lightcraft-tiff = { workspace = true } +craft-tiff = { workspace = true } lightcraft-meta = { workspace = true } lightcraft-raster = { workspace = true } lightcraft-color = { workspace = true } diff --git a/crates/raw/examples/rawinfo.rs b/crates/raw/examples/rawinfo.rs index 23e540b965..2271aa0bd2 100644 --- a/crates/raw/examples/rawinfo.rs +++ b/crates/raw/examples/rawinfo.rs @@ -3,8 +3,8 @@ //! Prints the TIFF structure (with `--tree`), decode result, timings (MP/s) and basic statistics. //! Exits unsuccessfully if any input cannot be read, decoded or developed, while inspecting the remaining files. +use craft_tiff::{Ifd, Tiff, Value}; use lightcraft_raw::{Method, RawData, decode, embedded_preview, probe}; -use lightcraft_tiff::{Ifd, Tiff, Value}; use std::process::ExitCode; use std::time::Instant; diff --git a/crates/raw/examples/rawrender.rs b/crates/raw/examples/rawrender.rs index abb1fe7c94..c1715a9ced 100644 --- a/crates/raw/examples/rawrender.rs +++ b/crates/raw/examples/rawrender.rs @@ -2,9 +2,9 @@ //! //! Quick visual check: develop → as-shot WB + camera matrix → sRGB, oriented, box-downscaled, 8-bit TIFF. +use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags}; use lightcraft_color::{REC2020, SRGB, transfer::encode_srgb8}; use lightcraft_raw::{Method, color, decode}; -use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags}; fn main() { let a: Vec = std::env::args().skip(1).collect(); diff --git a/crates/raw/src/dcp.rs b/crates/raw/src/dcp.rs index 774b1ceab1..a577fbe4e5 100644 --- a/crates/raw/src/dcp.rs +++ b/crates/raw/src/dcp.rs @@ -4,7 +4,7 @@ //! `UniqueCameraModel`, `ProfileName`, the colour/forward matrices and calibration illuminants, the //! hue/saturation map, look table and tone curve. Nothing here ships a profile. -use lightcraft_tiff::{Ifd, ParseOptions, Tiff, tags as t}; +use craft_tiff::{Ifd, ParseOptions, Tiff, tags as t}; use crate::ColorData; use crate::dng::color_data; @@ -118,8 +118,8 @@ pub fn parse_dcp(bytes: &[u8]) -> Result { /// Write `p` as a `.dcp` file (little-endian): its name, camera, illuminants, matrices, hue/saturation /// map, look table, tone curve and baseline exposure offset. pub fn write_dcp(p: &DcpProfile) -> Result, DcpError> { - use lightcraft_tiff::writer::srational; - use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; + use craft_tiff::writer::srational; + use craft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; let c = &p.color; let mut ifd = IfdBuilder::new(); ifd.set(t::UNIQUE_CAMERA_MODEL, Value::Ascii(p.camera_model.clone())); diff --git a/crates/raw/src/dng.rs b/crates/raw/src/dng.rs index bbea2c8c1a..c156e8f4cb 100644 --- a/crates/raw/src/dng.rs +++ b/crates/raw/src/dng.rs @@ -5,10 +5,10 @@ use crate::gaintable::GainTableMap; use crate::profile::{HsvTable, ProfileLook, ToneCurve}; use crate::tiffraw::{Packing, read_image_in}; use crate::{BlackLevel, Cfa, ColorData, Mat3, Mode, RawData, RawError, RawFormat, RawImage, Rect, Result, opcodes}; +use craft_tiff::tags::{self as t, photometric}; +use craft_tiff::{ByteOrder, Ifd, Tiff}; use lightcraft_color::Xy; use lightcraft_geom::Orientation; -use lightcraft_tiff::tags::{self as t, photometric}; -use lightcraft_tiff::{ByteOrder, Ifd, Tiff}; /// The main raw IFD: full-resolution (NewSubfileType 0) CFA or LinearRaw image with the most pixels. pub(crate) fn raw_ifd(tiff: &Tiff) -> Option<&Ifd> { @@ -183,7 +183,7 @@ pub(crate) fn is_plain_cfa_tiff(tiff: &Tiff, bytes: &[u8]) -> bool { t::compression::JPEG => info .chunks(bytes.len() as u64) .first() - .and_then(|c| lightcraft_tiff::image::chunk_bytes(bytes, c)) + .and_then(|c| craft_tiff::image::chunk_bytes(bytes, c)) .is_some_and(|src| crate::ljpeg::frame_info(src).is_ok()), _ => false, } diff --git a/crates/raw/src/dngwrite.rs b/crates/raw/src/dngwrite.rs index 39db148901..303165f385 100644 --- a/crates/raw/src/dngwrite.rs +++ b/crates/raw/src/dngwrite.rs @@ -2,10 +2,10 @@ //! bit-exact decoder round-trip tests. The raw image is stored in IFD0 (allowed by DNG 1.7 §"File Structure"). use crate::{RawData, RawError, RawImage, Result, ljpeg, opcodes}; +use craft_tiff::tags::{self as t, compression, photometric}; +use craft_tiff::writer::{rational, srational}; +use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; use lightcraft_color::Mat3; -use lightcraft_tiff::tags::{self as t, compression, photometric}; -use lightcraft_tiff::writer::{rational, srational}; -use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; use rayon::prelude::*; #[derive(Clone, Copy, Debug, PartialEq, Eq)] diff --git a/crates/raw/src/gaintable.rs b/crates/raw/src/gaintable.rs index cec1d6828d..c6a1b4c91e 100644 --- a/crates/raw/src/gaintable.rs +++ b/crates/raw/src/gaintable.rs @@ -40,7 +40,7 @@ //! `MapPointsV` / `MapPointsH` is below 256 (their product is at most [`MAX_TABLES`]), so swapped //! it is at least 2^24 and the size checks reject it. We write in the file's byte order. -use lightcraft_tiff::ByteOrder; +use craft_tiff::ByteOrder; use serde::{Deserialize, Serialize}; /// Upper bound on `MapPointsV × MapPointsH` (Apple uses 6 × 8). diff --git a/crates/raw/src/lib.rs b/crates/raw/src/lib.rs index ff9ee048b7..f246612cae 100644 --- a/crates/raw/src/lib.rs +++ b/crates/raw/src/lib.rs @@ -70,8 +70,8 @@ pub use preview::{ }; pub use semantic::{SemanticMask, semantic_masks}; +use craft_tiff::{Tiff, TiffError}; use lightcraft_color::Xy; -use lightcraft_tiff::{Tiff, TiffError}; use serde::{Deserialize, Serialize}; /// Upper bound on decoded samples (guards allocations driven by header values). @@ -189,28 +189,28 @@ pub fn probe(bytes: &[u8]) -> Option { return Some(RawFormat::Cr2); } let (_, _) = Tiff::sniff(bytes)?; - let opts = lightcraft_tiff::ParseOptions { max_ifds: 256, ..Default::default() }; + let opts = craft_tiff::ParseOptions { max_ifds: 256, ..Default::default() }; let t = Tiff::parse_with(bytes, &opts).ok()?; let ifd0 = t.ifds.first()?; - if ifd0.contains(lightcraft_tiff::tags::DNG_VERSION) { + if ifd0.contains(craft_tiff::tags::DNG_VERSION) { return Some(RawFormat::Dng); } - let make = t.find(lightcraft_tiff::tags::MAKE).and_then(|e| e.value.as_str()).unwrap_or_default().to_ascii_uppercase(); + let make = t.find(craft_tiff::tags::MAKE).and_then(|e| e.value.as_str()).unwrap_or_default().to_ascii_uppercase(); let has_cfa = has_raw_ifd(&t); // Pentax's reader takes the layout from the Exif `CFAPattern` when no IFD has a CFA photometric (uncompressed // and PackBits PEFs), so for the Pentax family that tag counts as raw evidence too let pentax_raw = has_cfa || t.exif().is_some_and(|e| e.contains(vendor::EXIF_CFA_PATTERN)); // Samsung's raw IFD uses private compressions 32769..=32773 (`vendor::srw`), 32773 being PackBits elsewhere - let samsung_raw = has_cfa || t.all_ifds().iter().any(|i| i.u16(lightcraft_tiff::tags::COMPRESSION).is_some_and(|c| (32769..=32773).contains(&c))); + let samsung_raw = has_cfa || t.all_ifds().iter().any(|i| i.u16(craft_tiff::tags::COMPRESSION).is_some_and(|c| (32769..=32773).contains(&c))); // Sony raws without a CFA IFD (#702): SRF (DSC-F828), whose IFD0 looks like RGB but holds 14-bit samples (12 or // 14 count: raw sensor depths; the raw is in Sony's SRF blocks), and the DSLR-A100, whose IFD0 is an old-style // JPEG thumbnail (compression 6, which today's TIFF writers don't produce) and whose `SubIFDs` tag addresses its // raw data. A camera-authored or exported TIFF has 8- or 16-bit samples, and its SubIFDs hold ordinary images - let model = t.find(lightcraft_tiff::tags::MODEL).and_then(|e| e.value.as_str()).unwrap_or_default().trim().to_ascii_uppercase(); + let model = t.find(craft_tiff::tags::MODEL).and_then(|e| e.value.as_str()).unwrap_or_default().trim().to_ascii_uppercase(); let sony_raw = has_cfa - || ifd0.u64s(lightcraft_tiff::tags::BITS_PER_SAMPLE).is_some_and(|b| b.iter().any(|v| matches!(v, 12 | 14))) - || (model == "DSLR-A100" && ifd0.u16(lightcraft_tiff::tags::COMPRESSION) == Some(6) && ifd0.contains(lightcraft_tiff::tags::SUB_IFDS)); - if make.starts_with("CANON") && t.ifds.len() >= 4 && t.ifds[3].u16(lightcraft_tiff::tags::COMPRESSION) == Some(6) { + || ifd0.u64s(craft_tiff::tags::BITS_PER_SAMPLE).is_some_and(|b| b.iter().any(|v| matches!(v, 12 | 14))) + || (model == "DSLR-A100" && ifd0.u16(craft_tiff::tags::COMPRESSION) == Some(6) && ifd0.contains(craft_tiff::tags::SUB_IFDS)); + if make.starts_with("CANON") && t.ifds.len() >= 4 && t.ifds[3].u16(craft_tiff::tags::COMPRESSION) == Some(6) { return Some(RawFormat::Cr2); } if make.starts_with("NIKON") && has_cfa { @@ -218,7 +218,7 @@ pub fn probe(bytes: &[u8]) -> Option { } // Hasselblad's Sony-built bodies (the Lunar is a NEX-7 inside) write a Sony ARW under their own Make. Sony's // raw coding gives them away: compression 32767 or the raw IFD's tone-curve tag 0x7010, which no 3FR / FFF has - let sony_coded = || t.all_ifds().iter().any(|i| i.u16(lightcraft_tiff::tags::COMPRESSION) == Some(32767) || i.contains(0x7010)); + let sony_coded = || t.all_ifds().iter().any(|i| i.u16(craft_tiff::tags::COMPRESSION) == Some(32767) || i.contains(0x7010)); if (make.starts_with("SONY") && sony_raw) || (make.starts_with("HASSELBLAD") && sony_coded()) { return Some(RawFormat::Arw); } @@ -257,13 +257,13 @@ const LEAF_DATA: u16 = 0x8606; /// An uncompressed Leaf MOS: IFD0 is the 16-bit mosaic itself (compression 1, BlackIsZero, one sample per pixel), /// with no Make tag and no CFA photometric, so only Leaf's data block marks it as a raw (issue #1275). A rendered /// RGB image that kept the block stays an ordinary image. -fn is_leaf_mosaic(ifd0: &lightcraft_tiff::Ifd) -> bool { - ifd0.contains(LEAF_DATA) && ifd0.u16(lightcraft_tiff::tags::SAMPLES_PER_PIXEL).unwrap_or(1) == 1 +fn is_leaf_mosaic(ifd0: &craft_tiff::Ifd) -> bool { + ifd0.contains(LEAF_DATA) && ifd0.u16(craft_tiff::tags::SAMPLES_PER_PIXEL).unwrap_or(1) == 1 } /// Whether the Exif maker note starts with the signature of the Pentax layouts (`AOC\0` or `PENTAX \0`). fn has_pentax_maker_note(t: &Tiff, bytes: &[u8]) -> bool { - let Some(e) = t.exif().and_then(|e| e.get(lightcraft_tiff::tags::MAKER_NOTE)) else { return false }; + let Some(e) = t.exif().and_then(|e| e.get(craft_tiff::tags::MAKER_NOTE)) else { return false }; bytes.get(e.offset as usize..).is_some_and(|n| n.starts_with(b"AOC\0") || n.starts_with(b"PENTAX \0")) } @@ -272,19 +272,19 @@ fn has_pentax_maker_note(t: &Tiff, bytes: &[u8]) -> bool { /// or vendor-specific raw tags (Sony tone curve, CFA pattern, or Pentax compression 65535). fn has_raw_ifd(t: &Tiff) -> bool { t.all_ifds().iter().any(|i| { - i.u16(lightcraft_tiff::tags::PHOTOMETRIC) == Some(lightcraft_tiff::tags::photometric::CFA) - || i.u16(lightcraft_tiff::tags::COMPRESSION).is_some_and(|c| matches!(c, 34713 | 32767 | 32769 | 32770 | 99 | 65535)) + i.u16(craft_tiff::tags::PHOTOMETRIC) == Some(craft_tiff::tags::photometric::CFA) + || i.u16(craft_tiff::tags::COMPRESSION).is_some_and(|c| matches!(c, 34713 | 32767 | 32769 | 32770 | 99 | 65535)) || i.contains(0x7010) - || i.contains(lightcraft_tiff::tags::CFA_PATTERN_EP) - || i.contains(lightcraft_tiff::tags::CFA_REPEAT_PATTERN_DIM) + || i.contains(craft_tiff::tags::CFA_PATTERN_EP) + || i.contains(craft_tiff::tags::CFA_REPEAT_PATTERN_DIM) }) } /// IFD0 that is not an image at all: no `ImageWidth` / `ImageLength`, but a JPEG preview pointer or /// `SubIFDs` (the layout of Kodak KDC files, whose pictures sit in private tags). A plain TIFF reader /// rejects such a file as malformed even though it carries a preview. -fn is_preview_container(ifd0: &lightcraft_tiff::Ifd) -> bool { - use lightcraft_tiff::tags::{IMAGE_LENGTH, IMAGE_WIDTH, JPEG_INTERCHANGE_FORMAT, SUB_IFDS}; +fn is_preview_container(ifd0: &craft_tiff::Ifd) -> bool { + use craft_tiff::tags::{IMAGE_LENGTH, IMAGE_WIDTH, JPEG_INTERCHANGE_FORMAT, SUB_IFDS}; !ifd0.contains(IMAGE_WIDTH) && !ifd0.contains(IMAGE_LENGTH) && (ifd0.contains(JPEG_INTERCHANGE_FORMAT) || ifd0.contains(SUB_IFDS)) } @@ -309,7 +309,7 @@ pub(crate) struct ThumbnailShell { /// A multi-page TIFF is not caught (its pages are the IFD chain, not `SubIFDs`), nor a pyramid whose /// IFD0 is the full image. fn thumbnail_shell(t: &Tiff, len: usize) -> Option { - use lightcraft_tiff::tags::{IMAGE_LENGTH, IMAGE_WIDTH, PIXEL_X_DIMENSION, PIXEL_Y_DIMENSION}; + use craft_tiff::tags::{IMAGE_LENGTH, IMAGE_WIDTH, PIXEL_X_DIMENSION, PIXEL_Y_DIMENSION}; let ifd0 = t.ifds.first()?; let (w0, h0) = (ifd0.u32(IMAGE_WIDTH)?, ifd0.u32(IMAGE_LENGTH)?); if w0 == 0 || h0 == 0 { @@ -352,12 +352,12 @@ fn thumbnail_shell(t: &Tiff, len: usize) -> Option { /// Why [`decode`] gives up on a file [`probe`] called [`RawFormat::OtherTiff`]. fn other_tiff_reason(bytes: &[u8]) -> String { - let t = Tiff::parse_with(bytes, &lightcraft_tiff::ParseOptions { max_ifds: 256, ..Default::default() }).ok(); + let t = Tiff::parse_with(bytes, &craft_tiff::ParseOptions { max_ifds: 256, ..Default::default() }).ok(); // a DNG-style CFA IFD whose lossless JPEG the lossless decoder rejects: say why if let Some(t) = &t && let Some(info) = dng::raw_ifd(t).and_then(|i| i.image().ok()) - && info.compression == lightcraft_tiff::tags::compression::JPEG - && let Some(src) = info.chunks(bytes.len() as u64).first().and_then(|c| lightcraft_tiff::image::chunk_bytes(bytes, c)) + && info.compression == craft_tiff::tags::compression::JPEG + && let Some(src) = info.chunks(bytes.len() as u64).first().and_then(|c| craft_tiff::image::chunk_bytes(bytes, c)) && let Err(e) = ljpeg::frame_info(src) { return format!("raw image coded as lossless JPEG that is not decoded yet ({e})"); diff --git a/crates/raw/src/preview.rs b/crates/raw/src/preview.rs index d6121c4466..cc4535af2b 100644 --- a/crates/raw/src/preview.rs +++ b/crates/raw/src/preview.rs @@ -3,9 +3,9 @@ //! or a DNG 1.7 JPEG XL preview IFD stored as a single tile/strip (a standalone `.jxl` file, as the spec //! recommends for previews). -use lightcraft_tiff::image::chunk_bytes; -use lightcraft_tiff::tags as t; -use lightcraft_tiff::{Ifd, Tiff, makernote}; +use craft_tiff::image::chunk_bytes; +use craft_tiff::tags as t; +use craft_tiff::{Ifd, Tiff, makernote}; /// Colour space of an embedded JPEG when the enclosing raw supplies it instead of the JPEG. #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -203,7 +203,7 @@ fn jpeg_end(s: &[u8], budget: &mut usize) -> Option { fn candidates<'a>(data: &'a [u8], ifd: &Ifd, base: u64, out: &mut Vec<&'a [u8]>, budget: &mut usize) { // whole JPEG files stored as an undefined-type tag value (e.g. Panasonic `JpgFromRaw` 0x002e) for e in &ifd.entries { - if matches!(e.value, lightcraft_tiff::Value::Undefined(_)) + if matches!(e.value, craft_tiff::Value::Undefined(_)) && e.count() > 1024 && let Some(s) = file_span(data, e.offset, e.count() as u64, budget) && s.starts_with(&[0xff, 0xd8]) @@ -310,7 +310,7 @@ fn preview_covering(bytes: &[u8], min_edge: Option) -> Option> { if let Some(mn) = makernote::parse_makernote(bytes, e.offset, e.count() as u64, tiff.order, &make) { candidates(bytes, &mn.ifd, mn.base, &mut found, &mut budget); if let Some(off) = mn.ifd.u64(0x0011) - && let Ok((pifd, _)) = lightcraft_tiff::parse_ifd_at(bytes, mn.base + off, mn.order, mn.base, false, &Default::default()) + && let Ok((pifd, _)) = craft_tiff::parse_ifd_at(bytes, mn.base + off, mn.order, mn.base, false, &Default::default()) { candidates(bytes, &pifd, mn.base, &mut found, &mut budget); } diff --git a/crates/raw/src/preview/tests.rs b/crates/raw/src/preview/tests.rs index 561d39645d..924c4b4213 100644 --- a/crates/raw/src/preview/tests.rs +++ b/crates/raw/src/preview/tests.rs @@ -1,5 +1,5 @@ use super::*; -use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; +use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; fn fake_jpeg(n: usize) -> Vec { let mut j = vec![0xff, 0xd8, 0xff, 0xc0, 0x00, 0x0b, 8, 0, 1, 0, 1, 1, 1, 0x11, 0]; @@ -394,10 +394,9 @@ fn cr3_with_color_space(exif: Option, note: Option) -> Vec { let block = |tag: u16, v: Option| { let ifd = v.map_or_else(|| IfdBuilder::new().with(t::ISO_SPEED, Value::Short(vec![100])), |v| IfdBuilder::new().with(tag, Value::Short(vec![v]))); - TiffWriter::new(lightcraft_tiff::ByteOrder::Little, false).write(&[ifd]).unwrap() + TiffWriter::new(craft_tiff::ByteOrder::Little, false).write(&[ifd]).unwrap() }; - let cmt1 = - TiffWriter::new(lightcraft_tiff::ByteOrder::Little, false).write(&[IfdBuilder::new().with(t::MAKE, Value::Ascii("Canon".into()))]).unwrap(); + let cmt1 = TiffWriter::new(craft_tiff::ByteOrder::Little, false).write(&[IfdBuilder::new().with(t::MAKE, Value::Ascii("Canon".into()))]).unwrap(); let canon_uuid = [0x85, 0xc0, 0xb6, 0x87, 0x82, 0x0f, 0x11, 0xe0, 0x81, 0x11, 0xf4, 0xce, 0x46, 0x2b, 0x6a, 0x48]; let boxes = [bx(b"CMT1", &cmt1), bx(b"CMT2", &block(0xA001, exif)), bx(b"CMT3", &block(0x00b4, note))].concat(); let mut file = bx(b"ftyp", b"crx \0\0\0\x01crx isom"); @@ -444,7 +443,7 @@ fn cr2_preview_colour_space_comes_from_the_canon_maker_note() { } let mut ifd0 = IfdBuilder::new().with(t::MAKE, Value::Ascii(make.into())); ifd0.set_child(t::EXIF_IFD, exif); - TiffWriter::new(lightcraft_tiff::ByteOrder::Little, false).write(&[ifd0]).unwrap() + TiffWriter::new(craft_tiff::ByteOrder::Little, false).write(&[ifd0]).unwrap() }; assert_eq!(embedded_preview_color_space(&cr2("Canon", 0xFFFF, Some(2))), Some(AdobeRgb)); assert_eq!(embedded_preview_color_space(&cr2("Canon", 1, Some(1))), Some(Srgb)); diff --git a/crates/raw/src/semantic.rs b/crates/raw/src/semantic.rs index e9af87c08a..fba28596e1 100644 --- a/crates/raw/src/semantic.rs +++ b/crates/raw/src/semantic.rs @@ -9,9 +9,9 @@ use crate::Rect; use crate::tiffraw::{Packing, read_image}; use crate::{RawData, Result}; +use craft_tiff::Tiff; +use craft_tiff::tags::{self as t, photometric}; use lightcraft_raster::Image; -use lightcraft_tiff::Tiff; -use lightcraft_tiff::tags::{self as t, photometric}; /// At most this many mask IFDs are read from one file. pub const MAX_MASKS: usize = 16; @@ -55,7 +55,7 @@ pub fn semantic_masks(bytes: &[u8]) -> Vec { .collect() } -fn read_mask(bytes: &[u8], tiff: &Tiff, ifd: &lightcraft_tiff::Ifd) -> Result> { +fn read_mask(bytes: &[u8], tiff: &Tiff, ifd: &craft_tiff::Ifd) -> Result> { let Some(name) = ifd.string(t::SEMANTIC_NAME).filter(|n| !n.is_empty()) else { return Ok(None) }; let info = ifd.image()?; let (w, h) = (info.width as usize, info.height as usize); diff --git a/crates/raw/src/sparse.rs b/crates/raw/src/sparse.rs index 893ba79b20..dd81263e58 100644 --- a/crates/raw/src/sparse.rs +++ b/crates/raw/src/sparse.rs @@ -19,8 +19,8 @@ use std::collections::HashSet; +use craft_tiff::{ByteOrder, FieldType, Tiff, tags as t}; use lightcraft_meta::cr3::{Cr3TrackKind, XMP_UUID, is_cr3, parse_cr3}; -use lightcraft_tiff::{ByteOrder, FieldType, Tiff, tags as t}; use crate::RawFormat; @@ -29,7 +29,7 @@ use crate::RawFormat; const HEAD: u64 = 64 * 1024; /// An image whose chunks hold fewer bytes than this is read (thumbnails, small previews). const BULK: u64 = 256 * 1024; -/// The same bounds as `lightcraft_tiff`'s reader. +/// The same bounds as `craft_tiff`'s reader. const MAX_IFDS: usize = 1024; const MAX_ENTRIES: u64 = 8192; const MAX_BOXES: usize = 4096; @@ -301,7 +301,7 @@ fn tiff_plan(bytes: &[u8], loaded: &Ranges, preview: bool) -> HeaderPlan { }) } -/// Walk the IFDs of the TIFF in `data` (which starts at `origin` in the file) as `lightcraft_tiff`'s +/// Walk the IFDs of the TIFF in `data` (which starts at `origin` in the file) as `craft_tiff`'s /// reader does — the chain, `SubIFDs`, Exif, GPS and Interop, plus the `extra` pointer tags — /// asking for every IFD table and for the values that locate IFDs and image chunks. Returns the IFD /// tables and out-of-line values found (absolute ranges); incomplete while `w` needs more. diff --git a/crates/raw/src/tests.rs b/crates/raw/src/tests.rs index e58991ccc8..0cff6f2006 100644 --- a/crates/raw/src/tests.rs +++ b/crates/raw/src/tests.rs @@ -120,7 +120,7 @@ fn black_levels() { // --- TIFF shells around a private raw block (thumbnail-only IFD0) --- -use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; +use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; /// An uncompressed 8-bit RGB image IFD. fn rgb_ifd(w: u32, h: u32) -> IfdBuilder { @@ -408,7 +408,7 @@ fn uncompressed_leaf_mos_is_a_raw() { } ifd }; - let bytes = TiffWriter::new(lightcraft_tiff::ByteOrder::Big, false).write(&[mosaic(true)]).unwrap(); + let bytes = TiffWriter::new(craft_tiff::ByteOrder::Big, false).write(&[mosaic(true)]).unwrap(); assert_eq!(probe(&bytes), Some(RawFormat::OtherTiff)); assert!(matches!(decode(&bytes), Err(RawError::Unsupported(_)))); assert!(matches!(probe_info(&bytes), Err(RawError::Unsupported(_)))); diff --git a/crates/raw/src/tiffraw.rs b/crates/raw/src/tiffraw.rs index c1fd0974eb..c396651ae5 100644 --- a/crates/raw/src/tiffraw.rs +++ b/crates/raw/src/tiffraw.rs @@ -2,8 +2,8 @@ use crate::unpack::{f16_to_f32, f24_to_f32, inflate, read_u16s, undo_diff_u16, undo_float_predictor, unpack_lsb, unpack_msb, unpack_words32_msb}; use crate::{MAX_SAMPLES, RawData, RawError, Result, ljpeg}; -use lightcraft_tiff::image::{Chunk, ImageInfo, chunk_bytes}; -use lightcraft_tiff::{ByteOrder, tags::compression as comp}; +use craft_tiff::image::{Chunk, ImageInfo, chunk_bytes}; +use craft_tiff::{ByteOrder, tags::compression as comp}; use rayon::prelude::*; /// Bit packing for uncompressed integer data with bit depths other than 8/16. @@ -461,7 +461,7 @@ fn unpack_chunk( #[cfg(test)] mod lossy_tests { use super::*; - use lightcraft_tiff::image::Layout; + use craft_tiff::image::Layout; /// 65 536 tiles all pointing at the same 256 bytes: the image's samples can't come from them, /// and nothing of its size is allocated to find that out. diff --git a/crates/raw/src/unpack.rs b/crates/raw/src/unpack.rs index 77c69c00d5..bf7040a8a7 100644 --- a/crates/raw/src/unpack.rs +++ b/crates/raw/src/unpack.rs @@ -4,7 +4,7 @@ //! predictor), DNG 1.7 (predictors 34892–34895, bit packing, 16/24-bit floats), RFC 1950/1951 (zlib/deflate). use crate::{RawError, Result}; -use lightcraft_tiff::ByteOrder; +use craft_tiff::ByteOrder; /// Unpack `out.len()` MSB-first packed samples of `bits` (1..=16) from `src` (TIFF bit order). pub fn unpack_msb(src: &[u8], bits: u32, out: &mut [u16]) { diff --git a/crates/raw/src/vendor.rs b/crates/raw/src/vendor.rs index a44262a2c4..dea94043e5 100644 --- a/crates/raw/src/vendor.rs +++ b/crates/raw/src/vendor.rs @@ -30,7 +30,7 @@ mod sr2; pub mod srw; use crate::{BlackLevel, Cfa, Rect}; -use lightcraft_tiff::Tiff; +use craft_tiff::Tiff; use std::ops::Range; /// Exif `CFAPattern`. @@ -247,7 +247,7 @@ pub(crate) fn declare_strip_len(file: &mut [u8], len: u32, declared: u32) { #[cfg(test)] mod tests { use super::*; - use lightcraft_tiff::tags as t; + use craft_tiff::tags as t; /// `file`, whose image IFD holds one strip, as two strips at the same offset whose StripByteCounts are LONG8 (which /// classic TIFF readers accept) `[u64::MAX, 1]`: their sum is past `u64::MAX`. diff --git a/crates/raw/src/vendor/arw.rs b/crates/raw/src/vendor/arw.rs index e260415648..950e3bec47 100644 --- a/crates/raw/src/vendor/arw.rs +++ b/crates/raw/src/vendor/arw.rs @@ -48,10 +48,10 @@ use super::arw6; use crate::lens_metadata::SonyLensGeometry; use crate::tiffraw::{Packing, check_image, read_image_in}; use crate::{BlackLevel, Cfa, ColorData, LensMetadata, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result, ljpeg}; +use craft_tiff::image::{Chunk, ImageInfo, Layout, chunk_bytes}; +use craft_tiff::tags::{self as t, photometric}; +use craft_tiff::{Ifd, Tiff, makernote}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::{Chunk, ImageInfo, Layout, chunk_bytes}; -use lightcraft_tiff::tags::{self as t, photometric}; -use lightcraft_tiff::{Ifd, Tiff, makernote}; use rayon::prelude::*; const TONE_CURVE: u16 = 0x7010; @@ -226,7 +226,7 @@ fn sony_body<'a>(make: &str, model: &'a str, mn: Option<&makernote::MakerNote>) /// White balance from the maker note's enciphered `Tag2010` block, the fallback described at [`TAG2010_WB`]. /// `model` is the Sony body ([`sony_body`]); Sony appends a regional "V" to some names (SLT-A77V), which the /// documented lists omit. -fn tag2010_wb(model: &str, block: &[u8], order: lightcraft_tiff::ByteOrder) -> Option<[f32; 3]> { +fn tag2010_wb(model: &str, block: &[u8], order: craft_tiff::ByteOrder) -> Option<[f32; 3]> { let model = model.trim(); let &(_, offset) = TAG2010_WB.iter().find(|(models, _)| models.iter().any(|m| model == *m || model.strip_suffix('V') == Some(*m)))?; let bytes: Vec = block.get(offset..offset + 6)?.iter().map(|&b| DECIPHER[b as usize]).collect(); @@ -523,7 +523,7 @@ fn sr2_old_crop(sr2: &super::sr2::SubIfd, w: usize, h: usize) -> Option { } /// One black level from the four deciphered per-channel levels (their mean), when they are near-equal and plausible. -fn sr2_black_levels(plain: &[u8], order: lightcraft_tiff::ByteOrder) -> Option { +fn sr2_black_levels(plain: &[u8], order: craft_tiff::ByteOrder) -> Option { let levels: Vec = (0..4).filter_map(|i| order.read_u16(plain, 2 * i)).collect(); let (&lo, &hi) = (levels.iter().min()?, levels.iter().max()?); (levels.len() == 4 && (64..=4096).contains(&lo) && hi - lo <= 64).then(|| levels.iter().map(|&v| f32::from(v)).sum::() / 4.0) @@ -532,8 +532,8 @@ fn sr2_black_levels(plain: &[u8], order: lightcraft_tiff::ByteOrder) -> Option lightcraft_tiff::ByteOrder { - use lightcraft_tiff::ByteOrder::{Big, Little}; +fn word16_order(strip: &[u8], bits: u32, file: craft_tiff::ByteOrder) -> craft_tiff::ByteOrder { + use craft_tiff::ByteOrder::{Big, Little}; let other = if file == Little { Big } else { Little }; let limit = 1u32 << bits.clamp(14, 16); let (mut n, mut over_file, mut over_other) = (0usize, 0usize, 0usize); @@ -836,7 +836,7 @@ mod tests { #[test] fn downsized_lossless_is_linear_rgb_not_cfa() { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let mut raw = IfdBuilder::new(); raw.set(t::MAKE, Value::Ascii("SONY".into())); raw.set(t::MODEL, Value::Ascii("ILCE-7M4".into())); @@ -894,7 +894,7 @@ mod tests { /// A 32767-compressed ARW whose single strip is `strip` bytes for a 32 x 4 image. fn arw_with_strip(strip: usize) -> Vec { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let mut raw = IfdBuilder::new(); raw.set(t::MAKE, Value::Ascii("SONY".into())); raw.set(t::MODEL, Value::Ascii("DSLR-A200".into())); @@ -923,7 +923,7 @@ mod tests { /// [`super::super::arw_lens_rm6`]). #[test] fn lens_tables_reach_opcode_list3() { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let file = |model: &str, ca: bool| { let mut raw = IfdBuilder::new(); raw.set(t::MAKE, Value::Ascii("SONY".into())); @@ -974,7 +974,7 @@ mod tests { /// A 32767-compressed, 12-bit ARW of `w` x `h` whose single strip is `strip`. fn packed_arw(w: u32, h: u32, strip: Vec) -> Vec { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let mut raw = IfdBuilder::new(); raw.set(t::MAKE, Value::Ascii("SONY".into())); raw.set(t::MODEL, Value::Ascii("DSLR-A900".into())); @@ -1111,7 +1111,7 @@ mod tests { #[test] fn tag2010_white_balance_by_model() { - use lightcraft_tiff::ByteOrder::Little; + use craft_tiff::ByteOrder::Little; let mut plain = vec![0u8; 700]; for (i, v) in [669u16, 256, 441].iter().enumerate() { plain[612 + 2 * i..614 + 2 * i].copy_from_slice(&v.to_le_bytes()); @@ -1134,8 +1134,8 @@ mod tests { /// A Sony-style file: IFD0 (`make`) → Exif → maker note `SONY DSC \0\0\0` + an IFD of `entries` (tag, type, /// count, inline value bytes), the layout of the camera's own notes; `count` overrides the entry count. - fn sony_file(order: lightcraft_tiff::ByteOrder, make: &str, entries: &[(u16, u16, u32, [u8; 4])], count: Option) -> Vec { - use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; + fn sony_file(order: craft_tiff::ByteOrder, make: &str, entries: &[(u16, u16, u32, [u8; 4])], count: Option) -> Vec { + use craft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value}; let (u16b, u32b) = match order { ByteOrder::Little => (u16::to_le_bytes as fn(u16) -> [u8; 2], u32::to_le_bytes as fn(u32) -> [u8; 4]), ByteOrder::Big => (u16::to_be_bytes as fn(u16) -> [u8; 2], u32::to_be_bytes as fn(u32) -> [u8; 4]), @@ -1160,7 +1160,7 @@ mod tests { #[test] fn dynamic_range_optimizer_is_read_from_the_sony_note() { - use lightcraft_tiff::ByteOrder::{Big, Little}; + use craft_tiff::ByteOrder::{Big, Little}; let long = |order, v: u32| match order { Little => v.to_le_bytes(), Big => v.to_be_bytes(), @@ -1195,7 +1195,7 @@ mod tests { #[test] fn hostile_sony_notes_are_read_safely() { - use lightcraft_tiff::ByteOrder::Little; + use craft_tiff::ByteOrder::Little; let entry = [(MN_DYNAMIC_RANGE_OPTIMIZER, 4, 1, 3u32.to_le_bytes())]; let good = sony_file(Little, "SONY", &entry, None); assert_eq!(crate::embedded_preview_dynamic_range_optimized(&good), Some(true)); @@ -1211,9 +1211,9 @@ mod tests { assert_eq!(crate::embedded_preview_dynamic_range_optimized(b"not a TIFF"), None); assert_eq!(crate::embedded_preview_dynamic_range_optimized(&[]), None); // a Sony file without a maker note - let mut ifd0 = lightcraft_tiff::IfdBuilder::new(); - ifd0.set(t::MAKE, lightcraft_tiff::Value::Ascii("SONY".into())); - assert_eq!(crate::embedded_preview_dynamic_range_optimized(&lightcraft_tiff::TiffWriter::new(Little, false).write(&[ifd0]).unwrap()), None); + let mut ifd0 = craft_tiff::IfdBuilder::new(); + ifd0.set(t::MAKE, craft_tiff::Value::Ascii("SONY".into())); + assert_eq!(crate::embedded_preview_dynamic_range_optimized(&craft_tiff::TiffWriter::new(Little, false).write(&[ifd0]).unwrap()), None); } #[test] @@ -1238,7 +1238,7 @@ mod tests { /// (reached through `DNGPrivateData` and the `SR2Private` IFD, as Sony stores it, with `key`; black level 800) /// and a maker note whose `Tag2010` block (RX100 III layout) holds `WB_RGBLevels`. fn arw_with_wb(plain: Option<[u16; 4]>, sr2: Option<[u16; 4]>, tag2010: Option<[u16; 3]>, key: [u8; 4]) -> Vec { - use lightcraft_tiff::{ByteOrder::Little, IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{ByteOrder::Little, IfdBuilder, ImageData, TiffWriter, Value}; let mut tag2010_block = vec![0u8; 700]; for (i, v) in tag2010.unwrap_or([0; 3]).iter().enumerate() { tag2010_block[612 + 2 * i..614 + 2 * i].copy_from_slice(&v.to_le_bytes()); @@ -1307,7 +1307,7 @@ mod tests { /// balance; without the ID, or with one that isn't listed, there is no layout to read. #[test] fn rebadged_body_takes_its_tag2010_layout_from_the_sony_model_id() { - use lightcraft_tiff::{ByteOrder::Little, IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{ByteOrder::Little, IfdBuilder, ImageData, TiffWriter, Value}; let file = |make: &str, model: &str, id: Option| { let mut block = vec![0u8; 4600]; for (i, v) in [639u16, 256, 368].iter().enumerate() { @@ -1371,7 +1371,7 @@ mod tests { #[test] fn dsc_r1_sr2_subifd_gives_black_wb_and_crop() { - use lightcraft_tiff::ByteOrder::Little; + use craft_tiff::ByteOrder::Little; let key = [0x63, 0xbe, 0x01, 0x3e]; let enc = |crop: [u16; 4], wb: [u16; 4]| { let b = super::super::sr2::tests::block_keyed( @@ -1453,7 +1453,7 @@ mod tests { #[test] fn sr2_black_level_decodes_and_rejects_garbage() { - use lightcraft_tiff::ByteOrder::Little; + use craft_tiff::ByteOrder::Little; let plain = |levels: [u16; 4]| -> Vec { levels.iter().flat_map(|v| v.to_le_bytes()).collect() }; assert_eq!(sr2_black_levels(&plain([800; 4]), Little), Some(800.0)); assert_eq!(sr2_black_levels(&plain([512, 512, 514, 512]), Little), Some(512.5)); @@ -1486,13 +1486,13 @@ mod tests { } /// [`sr2_black`] on the encrypted `SR2SubIFD` bytes `block`, which start at file offset `start`. - fn sr2_black_in(block: &[u8], start: usize, order: lightcraft_tiff::ByteOrder) -> Option { + fn sr2_black_in(block: &[u8], start: usize, order: craft_tiff::ByteOrder) -> Option { sr2_black(&super::super::sr2::SubIfd::decrypt(block, start, order)) } #[test] fn sr2_black_level_follows_the_first_entry_to_its_layout() { - use lightcraft_tiff::ByteOrder::Little; + use craft_tiff::ByteOrder::Little; let start = 37584; // the value position of every layout seen, e.g. the DSLR-A700's (62112 bytes, value at 1638) and the // DSLR-A450/A500/A550's (27152 bytes, value at 2166); the first four are those of bodies without a plain 0x7310 @@ -1521,7 +1521,7 @@ mod tests { #[test] fn word16_byte_order_follows_the_sample_range() { - use lightcraft_tiff::ByteOrder::{Big, Little}; + use craft_tiff::ByteOrder::{Big, Little}; let be: Vec = (0..4096u16).flat_map(|i| (512 + i * 3).to_be_bytes()).collect(); // 512..12800 big-endian words assert_eq!(word16_order(&be, 14, Little), Big); let le: Vec = (0..4096u16).flat_map(|i| (512 + i * 3).to_le_bytes()).collect(); @@ -1584,7 +1584,7 @@ mod tests { /// decode allocates the frame. #[test] fn a_strip_cut_short_is_refused_before_allocating() { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let (w, h) = (3000u32, 2000u32); for declared in [w * h, w * h / 2 * 3] { let mut raw = IfdBuilder::new(); diff --git a/crates/raw/src/vendor/arw6.rs b/crates/raw/src/vendor/arw6.rs index 9837f3e7be..b8ee711732 100644 --- a/crates/raw/src/vendor/arw6.rs +++ b/crates/raw/src/vendor/arw6.rs @@ -543,9 +543,9 @@ mod tests { use super::*; use crate::vendor::arw6_testenc::*; use crate::vendor::pef::Bits; - use lightcraft_tiff::Tiff; - use lightcraft_tiff::image::chunk_bytes; - use lightcraft_tiff::tags as t; + use craft_tiff::Tiff; + use craft_tiff::image::chunk_bytes; + use craft_tiff::tags as t; fn planes(w2: usize, h2: usize, seed: u64) -> (Plane, Plane, Plane, Plane) { let mut x = seed.max(1); diff --git a/crates/raw/src/vendor/arw6_testenc.rs b/crates/raw/src/vendor/arw6_testenc.rs index 5493311237..47d93a5639 100644 --- a/crates/raw/src/vendor/arw6_testenc.rs +++ b/crates/raw/src/vendor/arw6_testenc.rs @@ -2,8 +2,8 @@ //! Section names in italics refer to `docs/arw6-compression.md`. use crate::llvc::{Bands3, Plane, band_rows}; -use lightcraft_tiff::tags as t; -use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; +use craft_tiff::tags as t; +use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; /// Exact inverse of `dequant` on representable values: `sign(v) * (|v| >> qi)`. pub(crate) fn quantize(v: i32, qi: u32) -> i32 { diff --git a/crates/raw/src/vendor/arw_lens.rs b/crates/raw/src/vendor/arw_lens.rs index 4cebf221ec..94f1b67883 100644 --- a/crates/raw/src/vendor/arw_lens.rs +++ b/crates/raw/src/vendor/arw_lens.rs @@ -25,7 +25,7 @@ use crate::lens_metadata::{ SonySource, }; use crate::{Opcode, Rect}; -use lightcraft_tiff::{ByteOrder, FieldType, Ifd, Value}; +use craft_tiff::{ByteOrder, FieldType, Ifd, Value}; /// Each component's setting and table tags, `(raw IFD, SR2SubIFD)`. const SHADING: Tags = Tags { setting: (0x7031, 0x797c), table: (0x7032, 0x797d) }; @@ -545,8 +545,8 @@ mod tests { use crate::lens_metadata::SonyCopy::{Absent, Rejected, Valid}; use crate::lens_metadata::SonyFieldError::*; use crate::{LensMetadata, Mode, RawImage}; - use lightcraft_tiff::ByteOrder::{Big, Little}; - use lightcraft_tiff::{IfdBuilder, ImageData, Tiff, TiffWriter, Value, tags as t}; + use craft_tiff::ByteOrder::{Big, Little}; + use craft_tiff::{IfdBuilder, ImageData, Tiff, TiffWriter, Value, tags as t}; const TELE: [i16; 16] = [-2, 1, 7, 17, 31, 48, 68, 93, 120, 152, 187, 225, 265, 309, 356, 403]; const WIDE: [i16; 16] = [14, 0, -27, -59, -106, -158, -223, -291, -367, -440, -519, -593, -667, -731, -792, -839]; diff --git a/crates/raw/src/vendor/arw_lens_rm6.rs b/crates/raw/src/vendor/arw_lens_rm6.rs index 5a215ef7a2..e537e009ea 100644 --- a/crates/raw/src/vendor/arw_lens_rm6.rs +++ b/crates/raw/src/vendor/arw_lens_rm6.rs @@ -47,7 +47,7 @@ use super::fit_radial_warp; use crate::opcodes::max_radius; use crate::{Opcode, Rect}; -use lightcraft_tiff::Ifd; +use craft_tiff::Ifd; use std::ops::RangeInclusive; pub(crate) const DISTORTION_PARAMS: u16 = 0x7037; @@ -272,7 +272,7 @@ pub(crate) fn lens_opcodes(raw: &Ifd, model: &str, lens: Option<&str>, focal_mm: #[cfg(test)] mod tests { use super::*; - use lightcraft_tiff::{Entry, Value}; + use craft_tiff::{Entry, Value}; /// The FF 16–35 mm example (corpus `arw-sony-ilce7rm6-ff-land-lossless.arw`, docs/sony-ilce7rm6-lens-corrections.md). const FF_DISTORTION: [i16; 17] = [16, 0, 2, 7, 16, 28, 43, 61, 83, 109, 139, 175, 217, 267, 325, 395, 479]; diff --git a/crates/raw/src/vendor/cr2.rs b/crates/raw/src/vendor/cr2.rs index 6cab70d2fa..83367e2324 100644 --- a/crates/raw/src/vendor/cr2.rs +++ b/crates/raw/src/vendor/cr2.rs @@ -27,9 +27,9 @@ mod sraw; use super::{active_rows, black_from_columns, white_from_data}; use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result, ljpeg}; +use craft_tiff::image::chunk_bytes; +use craft_tiff::{ByteOrder, Ifd, Tiff, Value, makernote, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::chunk_bytes; -use lightcraft_tiff::{ByteOrder, Ifd, Tiff, Value, makernote, tags as t}; use std::ops::Range; const CR2_SLICE: u16 = 0xc640; @@ -192,9 +192,9 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result { Some(v) if v != 1 => return Err(RawError::Unsupported(format!("Canon raw type {v}"))), _ => {} } - let off = raw.u64(t::STRIP_OFFSETS).ok_or(RawError::Tiff(lightcraft_tiff::TiffError::MissingTag(t::STRIP_OFFSETS)))?; + let off = raw.u64(t::STRIP_OFFSETS).ok_or(RawError::Tiff(craft_tiff::TiffError::MissingTag(t::STRIP_OFFSETS)))?; let len = raw.u64(t::STRIP_BYTE_COUNTS).unwrap_or(bytes.len() as u64 - off.min(bytes.len() as u64)); - let chunk = lightcraft_tiff::image::Chunk { index: 0, x: 0, y: 0, width: 0, height: 0, plane: 0, offset: off, len }; + let chunk = craft_tiff::image::Chunk { index: 0, x: 0, y: 0, width: 0, height: 0, plane: 0, offset: off, len }; let src = chunk_bytes(bytes, &chunk).ok_or_else(|| RawError::Corrupt("raw strip outside file".into()))?; let (fw, fh, nc, prec) = ljpeg::frame_info(src)?; let frame = match mode { @@ -306,7 +306,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result { #[cfg(test)] pub(crate) mod tests { use super::*; - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; /// Build a synthetic CR2: IFD0..IFD2 placeholders + IFD3 holding a sliced 2-component LJ92 frame. pub(crate) fn synthetic_cr2(w: usize, h: usize, slices: Option<[u16; 3]>) -> (Vec, Vec) { diff --git a/crates/raw/src/vendor/cr2/sraw.rs b/crates/raw/src/vendor/cr2/sraw.rs index 6a37d627e5..742ce3a58a 100644 --- a/crates/raw/src/vendor/cr2/sraw.rs +++ b/crates/raw/src/vendor/cr2/sraw.rs @@ -28,9 +28,9 @@ use super::{COLOR_BALANCE, CR2_SLICE, SENSOR_INFO, words}; use crate::{BlackLevel, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result, ljpeg}; +use craft_tiff::image::{Chunk, chunk_bytes}; +use craft_tiff::{ByteOrder, Ifd, Tiff, makernote, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::{Chunk, chunk_bytes}; -use lightcraft_tiff::{ByteOrder, Ifd, Tiff, makernote, tags as t}; use rayon::prelude::*; /// Chroma samples are centred on this value. @@ -335,7 +335,7 @@ fn colour_data_black(words: &[u64]) -> Option { /// Decode a Canon sRAW / mRAW CR2 into linear white-balanced camera RGB (`cpp` 3). pub(super) fn decode(bytes: &[u8], tiff: &Tiff, raw: &Ifd, mode: Mode) -> Result { let ifd0 = &tiff.ifds[0]; - let off = raw.u64(t::STRIP_OFFSETS).ok_or(RawError::Tiff(lightcraft_tiff::TiffError::MissingTag(t::STRIP_OFFSETS)))?; + let off = raw.u64(t::STRIP_OFFSETS).ok_or(RawError::Tiff(craft_tiff::TiffError::MissingTag(t::STRIP_OFFSETS)))?; let len = raw.u64(t::STRIP_BYTE_COUNTS).unwrap_or(bytes.len() as u64 - off.min(bytes.len() as u64)); let chunk = Chunk { index: 0, x: 0, y: 0, width: 0, height: 0, plane: 0, offset: off, len }; let src = chunk_bytes(bytes, &chunk).ok_or_else(|| RawError::Corrupt("raw strip outside file".into()))?; @@ -403,7 +403,7 @@ pub(super) fn decode(bytes: &[u8], tiff: &Tiff, raw: &Ifd, mode: Mode) -> Result #[cfg(test)] mod tests { use super::*; - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; const SRAW_TYPE_TAG: u16 = 0xc6c5; diff --git a/crates/raw/src/vendor/cr3.rs b/crates/raw/src/vendor/cr3.rs index ba526b6e56..8a0a54c8c6 100644 --- a/crates/raw/src/vendor/cr3.rs +++ b/crates/raw/src/vendor/cr3.rs @@ -20,8 +20,8 @@ use super::{black_from_columns, crx, white_from_data}; use crate::{BlackLevel, Cfa, ColorData, MAX_SAMPLES, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result}; +use craft_tiff::{Ifd, Tiff}; use lightcraft_meta::cr3::{Cr3ImageArea, Cr3Track, Cr3TrackKind, parse_cr3}; -use lightcraft_tiff::{Ifd, Tiff}; const SENSOR_INFO: u16 = 0x00e0; const COLOR_DATA: u16 = 0x4001; @@ -282,7 +282,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result { #[cfg(test)] mod tests { use super::*; - use lightcraft_tiff::{IfdBuilder, Value}; + use craft_tiff::{IfdBuilder, Value}; fn maker(version: u16, wb_at: usize, black_at: usize, white_at: usize) -> Ifd { let mut words = vec![0u16; white_at + 1]; @@ -291,7 +291,7 @@ mod tests { words[black_at..black_at + 4].copy_from_slice(&[100, 101, 102, 103]); words[white_at] = 15000; let b = IfdBuilder::new().with(COLOR_DATA, Value::Short(words)); - let bytes = lightcraft_tiff::TiffWriter::new(lightcraft_tiff::ByteOrder::Little, false).write(&[b]).unwrap(); + let bytes = craft_tiff::TiffWriter::new(craft_tiff::ByteOrder::Little, false).write(&[b]).unwrap(); Tiff::parse(&bytes).unwrap().ifds.remove(0) } @@ -321,7 +321,7 @@ mod tests { } fn synthetic_header_with(aspect: Option<[u32; 5]>) -> Vec { - use lightcraft_tiff::{ByteOrder, TiffWriter, tags as t}; + use craft_tiff::{ByteOrder, TiffWriter, tags as t}; let tiff = |b: IfdBuilder| TiffWriter::new(ByteOrder::Little, false).write(&[b]).unwrap(); let cmt1 = tiff( IfdBuilder::new() @@ -460,8 +460,8 @@ mod tests { /// and `AspectInfo` applies from its origin. #[test] fn aspect_info_needs_a_consistent_recommended_crop() { - let aspect = lightcraft_tiff::IfdBuilder::new().with(ASPECT_INFO, Value::Long(vec![13, 5088, 3392, 0, 0])); - let bytes = lightcraft_tiff::TiffWriter::new(lightcraft_tiff::ByteOrder::Little, false).write(&[aspect]).unwrap(); + let aspect = craft_tiff::IfdBuilder::new().with(ASPECT_INFO, Value::Long(vec![13, 5088, 3392, 0, 0])); + let bytes = craft_tiff::TiffWriter::new(craft_tiff::ByteOrder::Little, false).write(&[aspect]).unwrap(); let maker = Tiff::parse(&bytes).unwrap().ifds.remove(0); let area = |crop| Cr3ImageArea { width: 5376, height: 3574, crop, active: Some([132, 160, 5243, 3567]), masked_left: [0; 4], masked_top: None }; diff --git a/crates/raw/src/vendor/erf.rs b/crates/raw/src/vendor/erf.rs index 7f88dae2af..0a1316448b 100644 --- a/crates/raw/src/vendor/erf.rs +++ b/crates/raw/src/vendor/erf.rs @@ -20,9 +20,9 @@ //! - The preview is the maker note's tag `0x0280`, a JPEG whose first byte is stored as `ee` (found by the //! structural scan in `preview::scan_for_jpeg`). use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result}; +use craft_tiff::image::chunk_bytes; +use craft_tiff::{Ifd, Tiff, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::chunk_bytes; -use lightcraft_tiff::{Ifd, Tiff, tags as t}; /// Epson's private compression code for the 16-byte block layout. const BLOCKS16: u16 = 32769; @@ -58,8 +58,8 @@ fn maker_note(bytes: &[u8], tiff: &Tiff) -> Option { if !bytes.get(start..)?.starts_with(b"EPSON\0") { return None; } - let opts = lightcraft_tiff::ParseOptions { max_ifds: 1, max_depth: 0, follow_children: false, ..Default::default() }; - lightcraft_tiff::parse_ifd_at(bytes, e.offset.checked_add(8)?, tiff.order, 0, false, &opts).ok().map(|(i, _)| i) + let opts = craft_tiff::ParseOptions { max_ifds: 1, max_depth: 0, follow_children: false, ..Default::default() }; + craft_tiff::parse_ifd_at(bytes, e.offset.checked_add(8)?, tiff.order, 0, false, &opts).ok().map(|(i, _)| i) } /// Unpack a strip of 16-byte blocks (15 bytes of ten MSB-first 12-bit samples, one pad byte). @@ -137,7 +137,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result { #[cfg(test)] mod tests { use super::*; - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; /// Pack ten-sample groups into 16-byte blocks, MSB first, zero pad. fn pack(px: &[u16]) -> Vec { @@ -168,7 +168,7 @@ mod tests { ifd0.set(t::MODEL, Value::Ascii("R-D1".into())); ifd0.set(t::ORIENTATION, Value::Short(vec![1])); ifd0.add_sub_ifd(raw); - TiffWriter::new(lightcraft_tiff::ByteOrder::Big, false).write(&[ifd0]).unwrap() + TiffWriter::new(craft_tiff::ByteOrder::Big, false).write(&[ifd0]).unwrap() } #[test] diff --git a/crates/raw/src/vendor/hasselblad.rs b/crates/raw/src/vendor/hasselblad.rs index 5f3342f9ff..9ec21d85c9 100644 --- a/crates/raw/src/vendor/hasselblad.rs +++ b/crates/raw/src/vendor/hasselblad.rs @@ -25,8 +25,8 @@ //! [`rgb_preview`] hands the largest 8-bit one on as a small baseline TIFF. use crate::dng; use crate::{ColorData, Mode, RawFormat, RawImage, Result}; -use lightcraft_tiff::image::{Layout, chunk_bytes}; -use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, ParseOptions, Tiff, TiffWriter, Value, tags as t}; +use craft_tiff::image::{Layout, chunk_bytes}; +use craft_tiff::{ByteOrder, IfdBuilder, ImageData, ParseOptions, Tiff, TiffWriter, Value, tags as t}; /// Private IFD0 tag holding the original 3FR header (a complete TIFF) inside an FFF. pub(crate) const ORIGINAL_HEADER: u16 = 0xc51b; @@ -124,7 +124,7 @@ fn adopt_matrices(color: &mut ColorData, from: &ColorData) { mod tests { use super::*; use crate::{RawData, RawError, decode as decode_file, probe, probe_info}; - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value, tags as t}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value, tags as t}; const MATRIX: [(i32, i32); 9] = [(686, 1000), (-196, 1000), (-32, 1000), (-437, 1000), (1228, 1000), (235, 1000), (-165, 1000), (317, 1000), (675, 1000)]; diff --git a/crates/raw/src/vendor/kodak.rs b/crates/raw/src/vendor/kodak.rs index 1e972873e5..5d77108ffc 100644 --- a/crates/raw/src/vendor/kodak.rs +++ b/crates/raw/src/vendor/kodak.rs @@ -24,9 +24,9 @@ //! each other) the raw G/R is 0.94 and G/B 1.96; `0x848` (1913, 1834, 921) gives 0.96 and 1.99, the others //! 0.77..1.25 and 2.08..2.96, so its green over red and over blue are the gains. use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result, ljpeg}; +use craft_tiff::image::chunk_bytes; +use craft_tiff::{Ifd, Tiff, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::chunk_bytes; -use lightcraft_tiff::{Ifd, Tiff, tags as t}; /// The vendor IFD pointer (`KodakIFD`). const KODAK_IFD: u16 = 0x8290; @@ -127,8 +127,8 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result { /// The vendor IFD (`KodakIFD`): a plain IFD with absolute value offsets. fn kodak_ifd(bytes: &[u8], tiff: &Tiff, ifd0: &Ifd) -> Option { let off = u64::from(ifd0.u32(KODAK_IFD)?); - let opts = lightcraft_tiff::ParseOptions { max_ifds: 4, max_depth: 1, follow_children: false, ..Default::default() }; - lightcraft_tiff::parse_ifd_at(bytes, off, tiff.order, 0, false, &opts).ok().map(|(i, _)| i) + let opts = craft_tiff::ParseOptions { max_ifds: 4, max_depth: 1, follow_children: false, ..Default::default() }; + craft_tiff::parse_ifd_at(bytes, off, tiff.order, 0, false, &opts).ok().map(|(i, _)| i) } /// Black level per CFA position (the mosaic's first sample is position 0): the value below which only 0.01% of that @@ -167,7 +167,7 @@ fn measured_black(d: &[u16], w: usize) -> BlackLevel { mod tests { use super::*; use crate::{decode, probe, probe_info}; - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; const W: usize = 16; const H: usize = 8; diff --git a/crates/raw/src/vendor/mef.rs b/crates/raw/src/vendor/mef.rs index d1c9a7754d..8755e9e06c 100644 --- a/crates/raw/src/vendor/mef.rs +++ b/crates/raw/src/vendor/mef.rs @@ -16,9 +16,9 @@ //! - No white-balance tag was found (the maker note holds an ICC-like profile), so the as-shot gains are measured //! from that preview's neutral pixels ([`crate::wb_estimate`]). use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result}; +use craft_tiff::image::chunk_bytes; +use craft_tiff::{Ifd, Tiff, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::chunk_bytes; -use lightcraft_tiff::{Ifd, Tiff, tags as t}; /// Where the preview's window starts in the sensor frame, and how many sensor pixels one preview pixel covers. const CROP_ORIGIN: (usize, usize) = (24, 12); @@ -142,7 +142,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result { #[cfg(test)] mod tests { use super::*; - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; fn pack(px: &[u16]) -> Vec { px.chunks(2).flat_map(|p| [(p[0] >> 4) as u8, ((p[0] & 15) << 4) as u8 | (p[1] >> 8) as u8, p[1] as u8]).collect() diff --git a/crates/raw/src/vendor/mrw.rs b/crates/raw/src/vendor/mrw.rs index 6404ec9aa2..a59de3d3ef 100644 --- a/crates/raw/src/vendor/mrw.rs +++ b/crates/raw/src/vendor/mrw.rs @@ -24,8 +24,8 @@ //! - `TTW` is a TIFF with IFD0 (orientation), Exif and the maker note; the preview JPEG sits in it with its first //! byte overwritten (see `preview::scan_for_jpeg`). use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result, unpack}; +use craft_tiff::{Tiff, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::{Tiff, tags as t}; /// Storage method codes in `PRD`. const PACKED_12: u8 = 0x59; @@ -80,7 +80,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result { if p.packed { unpack::unpack_msb(src, 12, &mut d); } else { - unpack::read_u16s(src, lightcraft_tiff::ByteOrder::Big, &mut d); + unpack::read_u16s(src, craft_tiff::ByteOrder::Big, &mut d); for v in &mut d { *v = (*v).min(4095); } @@ -154,10 +154,10 @@ pub(crate) mod tests { for v in wbg { wb.extend_from_slice(&v.to_be_bytes()); } - let mut ifd0 = lightcraft_tiff::IfdBuilder::new(); - ifd0.set(t::MAKE, lightcraft_tiff::Value::Ascii("Minolta Co., Ltd.".into())); - ifd0.set(t::ORIENTATION, lightcraft_tiff::Value::Short(vec![6])); - let ttw = lightcraft_tiff::TiffWriter::default().write(&[ifd0]).unwrap(); + let mut ifd0 = craft_tiff::IfdBuilder::new(); + ifd0.set(t::MAKE, craft_tiff::Value::Ascii("Minolta Co., Ltd.".into())); + ifd0.set(t::ORIENTATION, craft_tiff::Value::Short(vec![6])); + let ttw = craft_tiff::TiffWriter::default().write(&[ifd0]).unwrap(); let mut body = Vec::new(); for (name, data) in [(b"PRD", &prd), (b"WBG", &wb), (b"TTW", &ttw)] { body.push(0); diff --git a/crates/raw/src/vendor/nef.rs b/crates/raw/src/vendor/nef.rs index 10bb24d501..916acae60f 100644 --- a/crates/raw/src/vendor/nef.rs +++ b/crates/raw/src/vendor/nef.rs @@ -15,10 +15,10 @@ use super::{nefc, white_from_data}; use crate::tiffraw::{Packing, check_image, read_image}; use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result}; +use craft_tiff::image::ImageInfo; +use craft_tiff::tags::{self as t, photometric}; +use craft_tiff::{ByteOrder, Ifd, Tiff, makernote}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::ImageInfo; -use lightcraft_tiff::tags::{self as t, photometric}; -use lightcraft_tiff::{ByteOrder, Ifd, Tiff, makernote}; const WB_RB_LEVELS: u16 = 0x000c; const BLACK_LEVEL: u16 = 0x003d; @@ -500,7 +500,7 @@ fn packed(bytes: &[u8], info: &ImageInfo, rows: usize) -> Result { let (Some(layout), [c]) = (layout, chunks.as_slice()) else { return Err(RawError::Unsupported("Nikon compressed NEF without a linearization table (maker note 0x96)".into())); }; - let src = lightcraft_tiff::image::chunk_bytes(bytes, c) + let src = craft_tiff::image::chunk_bytes(bytes, c) .filter(|src| u64::try_from(src.len()).ok() == Some(c.len)) .ok_or_else(|| RawError::Corrupt("NEF: incomplete image strip".into()))?; if (w as u64).saturating_mul(h as u64) > crate::MAX_SAMPLES as u64 { @@ -538,7 +538,7 @@ const SMALL_RAW_B_GAIN: f32 = 4.4; /// The strip of a small raw: compression 34713, 12 bits, no maker note `0x0096`, one strip of exactly /// `3 * width * height` bytes (even width). -fn small_raw_strip(info: &ImageInfo, file_len: usize, mn: Option<&makernote::MakerNote>) -> Option { +fn small_raw_strip(info: &ImageInfo, file_len: usize, mn: Option<&makernote::MakerNote>) -> Option { if info.compression != t::compression::NIKON || info.bits() != 12 || info.samples_per_pixel != 1 { return None; } @@ -584,12 +584,12 @@ fn small_raw_row(src: &[u8], w: usize, out: &mut [u16]) { } } -fn small_raw(bytes: &[u8], tiff: &Tiff, info: &ImageInfo, strip: lightcraft_tiff::image::Chunk, mode: Mode) -> Result { +fn small_raw(bytes: &[u8], tiff: &Tiff, info: &ImageInfo, strip: craft_tiff::image::Chunk, mode: Mode) -> Result { use rayon::prelude::*; let (w, h) = (info.width as usize, info.height as usize); let stride = w.checked_mul(3).ok_or(RawError::Limit("image too large"))?; let count = stride.checked_mul(h).filter(|n| *n > 0 && *n <= crate::MAX_SAMPLES).ok_or(RawError::Limit("image too large"))?; - let src = lightcraft_tiff::image::chunk_bytes(bytes, &strip) + let src = craft_tiff::image::chunk_bytes(bytes, &strip) .filter(|src| u64::try_from(src.len()).ok() == Some(strip.len)) .ok_or_else(|| RawError::Corrupt("NEF: incomplete image strip".into()))?; let data = match mode { @@ -634,7 +634,7 @@ fn small_raw(bytes: &[u8], tiff: &Tiff, info: &ImageInfo, strip: lightcraft_tiff #[cfg(test)] mod tests { use super::*; - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; fn nef(compression: u16, bits: u16, strips: Vec>, w: u32, h: u32, rps: u32) -> Vec { nef_with_note(compression, bits, strips, w, h, rps, None) @@ -1397,7 +1397,7 @@ mod tests { let raw = raw_ifd(&tiff).unwrap(); let info = raw.image().unwrap(); let chunk = info.chunks(bytes.len() as u64)[0]; - let data = lightcraft_tiff::image::chunk_bytes(&bytes, &chunk).unwrap().to_vec(); + let data = craft_tiff::image::chunk_bytes(&bytes, &chunk).unwrap().to_vec(); let offset_entry = raw.get(t::STRIP_OFFSETS).unwrap().offset as usize; let start = bytes.len() as u32; bytes[offset_entry..offset_entry + 4].copy_from_slice(&start.to_be_bytes()); diff --git a/crates/raw/src/vendor/nef_lens.rs b/crates/raw/src/vendor/nef_lens.rs index c5e9490ebd..ee320c36d1 100644 --- a/crates/raw/src/vendor/nef_lens.rs +++ b/crates/raw/src/vendor/nef_lens.rs @@ -8,7 +8,7 @@ //! No lens database or external decoder code. use crate::{Opcode, Rect}; -use lightcraft_tiff::{ByteOrder, Ifd, ParseOptions, parse_ifd_at}; +use craft_tiff::{ByteOrder, Ifd, ParseOptions, parse_ifd_at}; const NEF_INFO: u16 = 0xc7d5; const DISTORTION_INFO: u16 = 0x0005; @@ -38,7 +38,7 @@ fn rational(b: &[u8], at: usize, order: ByteOrder) -> Option { /// The NikonNEFInfo entries: the blob is `"Nikon\0"`, a 4-byte version, then a little TIFF stream. fn nef_info(raw: &Ifd) -> Option<(Ifd, ByteOrder)> { let tiff = raw.bytes(NEF_INFO)?.strip_prefix(b"Nikon\0")?.get(4..)?; - let (order, false) = lightcraft_tiff::Tiff::sniff(tiff)? else { return None }; + let (order, false) = craft_tiff::Tiff::sniff(tiff)? else { return None }; let first = order.u32(tiff.get(4..8)?.try_into().ok()?); let opts = ParseOptions { follow_children: false, ..Default::default() }; let (ifd, _) = parse_ifd_at(tiff, u64::from(first), order, 0, false, &opts).ok()?; @@ -121,7 +121,7 @@ pub(super) fn distortion(model: &str, raw: &Ifd, active: Rect, crop: Rect) -> Op #[cfg(test)] pub(in crate::vendor) mod tests { use super::*; - use lightcraft_tiff::{Entry, IfdBuilder, TiffWriter, Value}; + use craft_tiff::{Entry, IfdBuilder, TiffWriter, Value}; const AREA: Rect = Rect { x: 0, y: 0, width: 6064, height: 4040 }; const CROP: Rect = Rect { x: 8, y: 8, width: 6048, height: 4024 }; diff --git a/crates/raw/src/vendor/nefc.rs b/crates/raw/src/vendor/nefc.rs index fd8e964b7f..27c7467f9b 100644 --- a/crates/raw/src/vendor/nefc.rs +++ b/crates/raw/src/vendor/nefc.rs @@ -58,7 +58,7 @@ use super::pef::{Bits, Huffman, diff}; use crate::{MAX_SAMPLES, RawError, Result}; -use lightcraft_tiff::ByteOrder; +use craft_tiff::ByteOrder; /// A table code word whose symbol was never observed (see the module docs). const UNSEEN: u8 = u8::MAX; @@ -633,8 +633,8 @@ mod tests { /// A minimal NEF: CFA SubIFD with one compressed strip, Exif maker note (`Nikon\0` v2 header + embedded TIFF in /// `mn_order`) holding the linearization table. fn nef_file(strip: Vec, w: u32, h: u32, bits: u16, table: Vec, mn_order: ByteOrder) -> Vec { - use lightcraft_tiff::tags::{self as t, photometric}; - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::tags::{self as t, photometric}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let mut mn = IfdBuilder::new(); mn.set(0x0096, Value::Undefined(table)); let mut note = b"Nikon\0\x02\x10\0\0".to_vec(); diff --git a/crates/raw/src/vendor/orf.rs b/crates/raw/src/vendor/orf.rs index 8c2bd28398..78cfdbe54b 100644 --- a/crates/raw/src/vendor/orf.rs +++ b/crates/raw/src/vendor/orf.rs @@ -40,10 +40,10 @@ use super::{cfa_from_exif, white_from_data}; use crate::tiffraw::{Packing, read_image}; use crate::unpack::unpack_msb; use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result}; +use craft_tiff::image::chunk_bytes; +use craft_tiff::makernote::MakerNote; +use craft_tiff::{Ifd, Tiff, Value, makernote, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::chunk_bytes; -use lightcraft_tiff::makernote::MakerNote; -use lightcraft_tiff::{Ifd, Tiff, Value, makernote, tags as t}; use rayon::prelude::*; pub(crate) const CAMERA_SETTINGS: u16 = 0x2020; @@ -73,8 +73,8 @@ pub(crate) fn sub_ifd(bytes: &[u8], mn: &MakerNote, tag: u16) -> Option { Value::Undefined(_) | Value::Byte(_) => e.offset, _ => mn.base.checked_add(mn.ifd.u64(tag)?)?, }; - let opts = lightcraft_tiff::ParseOptions { max_ifds: 4, max_depth: 1, follow_children: false, ..Default::default() }; - lightcraft_tiff::parse_ifd_at(bytes, at, mn.order, mn.base, false, &opts).ok().map(|(i, _)| i) + let opts = craft_tiff::ParseOptions { max_ifds: 4, max_depth: 1, follow_children: false, ..Default::default() }; + craft_tiff::parse_ifd_at(bytes, at, mn.order, mn.base, false, &opts).ok().map(|(i, _)| i) } /// Black level of a body without ImageProcessing: the main note's `0x1012` BlackLevel (the mean of its four values) @@ -365,7 +365,7 @@ pub(crate) fn preview(bytes: &[u8]) -> Option<&[u8]> { mod tests { use super::*; use crate::vendor::EXIF_CFA_PATTERN; - use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter}; + use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter}; fn orf(w: u32, h: u32, bits: u16, strip: Vec) -> Vec { orf_with(w, h, bits, strip, None) diff --git a/crates/raw/src/vendor/pef.rs b/crates/raw/src/vendor/pef.rs index 45efeec685..466ccdd023 100644 --- a/crates/raw/src/vendor/pef.rs +++ b/crates/raw/src/vendor/pef.rs @@ -19,9 +19,9 @@ use super::{black_from_columns, cfa_from_exif, white_from_data}; use crate::tiffraw::{Packing, read_image_in}; use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result}; +use craft_tiff::image::{ImageInfo, chunk_bytes}; +use craft_tiff::{ByteOrder, Tiff, makernote, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::{ImageInfo, chunk_bytes}; -use lightcraft_tiff::{ByteOrder, Tiff, makernote, tags as t}; const CROP_ORIGIN: u16 = 0x0038; const CROP_SIZE: u16 = 0x0039; @@ -523,7 +523,7 @@ mod tests { /// `CFAPattern` `pattern` and an AOC maker note with the area tags (and, for 65535, a Huffman table). The samples /// are plain 16-bit words (1), packed 12-bit (32773) or Huffman coded (65535). fn pef_with_pattern(compression: u16, pattern: [u8; 4]) -> Vec { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let (w, h) = (16usize, 8usize); let px: Vec = (0..w * h).map(|i| ((i * 37) % 900 + 100) as u16).collect(); let (tb, codes) = test_table(); @@ -589,7 +589,7 @@ mod tests { /// A `w x h` big-endian 14-bit PEF of plain 16-bit words without area tags, whose maker note has only a /// BlackPoint of `black`, with `px(x, y)` as the samples. fn pef_with_black_point(w: usize, h: usize, black: u16, px: impl Fn(usize, usize) -> u16) -> Vec { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let strip: Vec = (0..w * h).flat_map(|i| px(i % w, i / w).to_be_bytes()).collect(); let build = |levels_at: u32| { let mut ifd = IfdBuilder::new(); diff --git a/crates/raw/src/vendor/raf.rs b/crates/raw/src/vendor/raf.rs index b60a742660..e485931114 100644 --- a/crates/raw/src/vendor/raf.rs +++ b/crates/raw/src/vendor/raf.rs @@ -24,8 +24,8 @@ use super::white_from_data; use crate::unpack::{unpack_lsb, unpack_words32_msb}; use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result}; +use craft_tiff::{ByteOrder, Ifd, Tiff}; use lightcraft_geom::Orientation; -use lightcraft_tiff::{ByteOrder, Ifd, Tiff}; use rayon::prelude::*; const CROP_TOP_LEFT: u16 = 0x0110; @@ -88,7 +88,7 @@ fn pair(h: &Header, tag: u16) -> Option<(usize, usize)> { pub(crate) fn raw_ifd(raw: &[u8]) -> Result { let tiff = Tiff::parse(raw).map_err(|_| RawError::Unsupported("RAF without a raw IFD (older FinePix layout)".into()))?; let off = tiff.ifds.first().and_then(|i| i.u64(0xf000)).ok_or_else(|| RawError::Unsupported("RAF without a raw IFD".into()))?; - let (ifd, _) = lightcraft_tiff::parse_ifd_at(raw, off, ByteOrder::Little, 0, false, &Default::default())?; + let (ifd, _) = craft_tiff::parse_ifd_at(raw, off, ByteOrder::Little, 0, false, &Default::default())?; Ok(ifd) } diff --git a/crates/raw/src/vendor/raf_lens.rs b/crates/raw/src/vendor/raf_lens.rs index 283a3d0ea3..60275cd0d8 100644 --- a/crates/raw/src/vendor/raf_lens.rs +++ b/crates/raw/src/vendor/raf_lens.rs @@ -18,7 +18,7 @@ //! - vignette: relative illumination in percent at the source radius; the correction is the gain `100 / V`. use crate::{Opcode, Rect}; -use lightcraft_tiff::Ifd; +use craft_tiff::Ifd; const DISTORTION: u16 = 0xf00b; const VIGNETTING: u16 = 0xf010; @@ -334,7 +334,7 @@ pub(super) fn corrections(model: &str, raw: &Ifd, active: Rect) -> Vec { #[cfg(test)] mod tests { use super::*; - use lightcraft_tiff::{Entry, Value}; + use craft_tiff::{Entry, Value}; pub(crate) const KNOTS9: [f64; 9] = [0.3535211268, 0.5, 0.6126760563, 0.7070422535, 0.7908450704, 0.8661971831, 0.9352112676, 1.0, 1.06056338]; /// X-T4 with the XF16-55 at 16 mm (3913): the tables as ExifTool prints them. diff --git a/crates/raw/src/vendor/rw2.rs b/crates/raw/src/vendor/rw2.rs index 4acd53a020..7938da9d8e 100644 --- a/crates/raw/src/vendor/rw2.rs +++ b/crates/raw/src/vendor/rw2.rs @@ -105,8 +105,8 @@ use super::pef::{Bits, Huffman, diff}; use super::{active_rows, white_from_data}; use crate::{BlackLevel, Cfa, ColorData, MAX_SAMPLES, Mode, Opcode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result}; +use craft_tiff::{ByteOrder, Ifd, Tiff, Value, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::{ByteOrder, Ifd, Tiff, Value, tags as t}; use rayon::prelude::*; const SENSOR_WIDTH: u16 = 0x0002; @@ -698,7 +698,7 @@ fn distortion(ifd: &Ifd, active: Rect) -> Option { #[cfg(test)] mod tests { use super::*; - use lightcraft_tiff::{IfdBuilder, TiffWriter}; + use craft_tiff::{IfdBuilder, TiffWriter}; /// Writes bit fields into a 16-byte block from bit 127 down (the inverse of [`Fields`]). struct FieldWriter { diff --git a/crates/raw/src/vendor/sr2.rs b/crates/raw/src/vendor/sr2.rs index 10fc15074b..01535a228e 100644 --- a/crates/raw/src/vendor/sr2.rs +++ b/crates/raw/src/vendor/sr2.rs @@ -45,7 +45,7 @@ //! of an accident 2⁻⁴⁰⁶⁴). For the DSC-R1's key `63 be 01 3e` the 11932-byte block becomes a well-formed 101-entry //! directory (black `0x7300`, white balance `0x7303`, crop `0x74c3`). -use lightcraft_tiff::{ByteOrder, EntrySpan, Ifd, ParseOptions, decode_value, directory_entries, entry_span, tags as t}; +use craft_tiff::{ByteOrder, EntrySpan, Ifd, ParseOptions, decode_value, directory_entries, entry_span, tags as t}; /// `SR2Private` tags. const SUBIFD_OFFSET: u16 = 0x7200; @@ -260,7 +260,7 @@ pub(crate) mod tests { const LONG: u16 = 4; const UNDEFINED: u16 = 7; const IFD: u16 = 13; - use lightcraft_tiff::ByteOrder::{Big, Little}; + use craft_tiff::ByteOrder::{Big, Little}; /// An `SR2SubIFD` block for file offset `start`, encrypted: SHORT/SSHORT entries `(tag, type, values)`, values /// of more than two shorts stored after the table at file offsets, as Sony does. @@ -429,8 +429,8 @@ pub(crate) mod tests { /// What `SubIfd::read` on main selects: the TIFF reader's parse of the directory with main's options, then the /// directory's `u64` and `bytes` lookups. fn reader_selects(bytes: &[u8], at: usize, order: ByteOrder) -> Selected { - let opts = lightcraft_tiff::ParseOptions { max_ifds: 1, max_depth: 0, follow_children: false, ..Default::default() }; - let Ok((private, _)) = lightcraft_tiff::parse_ifd_at(bytes, at as u64, order, 0, false, &opts) else { return (None, None, None) }; + let opts = craft_tiff::ParseOptions { max_ifds: 1, max_depth: 0, follow_children: false, ..Default::default() }; + let Ok((private, _)) = craft_tiff::parse_ifd_at(bytes, at as u64, order, 0, false, &opts) else { return (None, None, None) }; let n = |tag: u16| private.u64(tag).and_then(|v| usize::try_from(v).ok()); (n(SUBIFD_OFFSET), n(SUBIFD_LENGTH), private.bytes(SUBIFD_KEY).and_then(|b| <[u8; 4]>::try_from(b).ok())) } @@ -594,7 +594,7 @@ pub(crate) mod tests { let mut pointer = Vec::new(); order.put_u32(&mut pointer, 0); let ifd0 = Ifd { - entries: vec![lightcraft_tiff::Entry { tag: t::DNG_PRIVATE_DATA, value: lightcraft_tiff::Value::Byte(pointer), offset: 0 }], + entries: vec![craft_tiff::Entry { tag: t::DNG_PRIVATE_DATA, value: craft_tiff::Value::Byte(pointer), offset: 0 }], ..Default::default() }; let black = SubIfd::read(&file, &ifd0, order).and_then(|s| s.shorts(0x7310)); diff --git a/crates/raw/src/vendor/srw.rs b/crates/raw/src/vendor/srw.rs index dbdb21b52f..298aeed238 100644 --- a/crates/raw/src/vendor/srw.rs +++ b/crates/raw/src/vendor/srw.rs @@ -36,9 +36,9 @@ use super::{black_from_columns, white_from_data}; use crate::unpack::{read_u16s, unpack_lsb, unpack_msb}; use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result}; +use craft_tiff::image::chunk_bytes; +use craft_tiff::{ByteOrder, Ifd, Tiff, tags as t}; use lightcraft_geom::Orientation; -use lightcraft_tiff::image::chunk_bytes; -use lightcraft_tiff::{ByteOrder, Ifd, Tiff, tags as t}; use rayon::prelude::*; const SENSOR_AREAS: u16 = 0xa010; @@ -53,8 +53,8 @@ const COMPRESSIONS: std::ops::RangeInclusive = 32769..=32773; /// The maker-note IFD (offsets relative to the note's own start). fn maker_note(bytes: &[u8], tiff: &Tiff) -> Option { let e = tiff.exif()?.get(t::MAKER_NOTE)?; - let opts = lightcraft_tiff::ParseOptions { max_ifds: 4, max_depth: 1, follow_children: false, ..Default::default() }; - lightcraft_tiff::parse_ifd_at(bytes, e.offset, tiff.order, e.offset, false, &opts).ok().map(|(i, _)| i) + let opts = craft_tiff::ParseOptions { max_ifds: 4, max_depth: 1, follow_children: false, ..Default::default() }; + craft_tiff::parse_ifd_at(bytes, e.offset, tiff.order, e.offset, false, &opts).ok().map(|(i, _)| i) } /// A key-offset vector: the entries of `tag` shifted by the maker note's key (`sign` is +1 or -1 times the key). @@ -281,7 +281,7 @@ fn masked_black(d: &[u16], w: usize, h: usize, a: Rect, white: f32) -> BlackLeve mod tests { use super::*; use crate::{decode, probe, probe_info}; - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; const KEY: [u32; 11] = [305, 72, 737, 456, 282, 307, 519, 724, 13, 505, 193]; @@ -362,7 +362,7 @@ mod tests { } ifd0.set_child(t::EXIF_IFD, exif); ifd0.add_sub_ifd(raw); - TiffWriter::new(lightcraft_tiff::ByteOrder::Big, false).write(&[ifd0]).unwrap() + TiffWriter::new(craft_tiff::ByteOrder::Big, false).write(&[ifd0]).unwrap() } /// Strip byte counts that add up past `u64::MAX` (LONG8 `[u64::MAX, 1]`) are an error or a picture, not an overflow. diff --git a/crates/raw/tests/it/corpus.rs b/crates/raw/tests/it/corpus.rs index 0be98991de..44ac741076 100644 --- a/crates/raw/tests/it/corpus.rs +++ b/crates/raw/tests/it/corpus.rs @@ -1378,7 +1378,7 @@ fn a7cr_enabled_distortion_agrees_in_header_full_and_dng() { let Some(mut bytes) = pinned_sony(&root, name) else { continue }; let original = probe_info(&bytes).unwrap(); assert!(original.opcodes.list3.is_empty(), "Off files must remain uncorrected"); - let tiff = lightcraft_tiff::Tiff::parse(&bytes).unwrap(); + let tiff = craft_tiff::Tiff::parse(&bytes).unwrap(); let at = tiff.find(0x7036).unwrap().offset as usize; let mut enabled = Vec::new(); tiff.order.put_u16(&mut enabled, 17); diff --git a/crates/raw/tests/it/dng.rs b/crates/raw/tests/it/dng.rs index dddafd5d0d..e8e5185374 100644 --- a/crates/raw/tests/it/dng.rs +++ b/crates/raw/tests/it/dng.rs @@ -1,14 +1,14 @@ //! Synthetic DNG round trips: every storage variant we decode is written with our own TIFF writer (and LJ92 //! encoder) and must decode bit-exactly. +use craft_tiff::tags::{self as t, compression, photometric}; +use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; use lightcraft_color::{D65, Mat3, Xy}; use lightcraft_raw::opcodes::{Area, Opcode}; use lightcraft_raw::{ BlackLevel, Cfa, ColorData, DngCompression, DngWriteOptions, Method, OpcodeLists, Orientation, RawData, RawFormat, RawImage, Rect, decode, embedded_preview, probe, write_dng, }; -use lightcraft_tiff::tags::{self as t, compression, photometric}; -use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; fn scene_value(x: usize, y: usize, c: u8, max: f32) -> f32 { let base = [0.55, 0.8, 0.4][c as usize]; @@ -120,7 +120,7 @@ fn writer_camera_identity_tags_roundtrip() { raw.metadata.model = model.map(str::to_owned); for order in [ByteOrder::Little, ByteOrder::Big] { let bytes = write_dng(&raw, &DngWriteOptions { compression: DngCompression::Uncompressed, order, xmp: None }).unwrap(); - let tiff = lightcraft_tiff::Tiff::parse(&bytes).unwrap(); + let tiff = craft_tiff::Tiff::parse(&bytes).unwrap(); let ifd = &tiff.ifds[0]; assert_eq!(ifd.value(t::UNIQUE_CAMERA_MODEL), Some(&Value::Ascii(unique.into())), "{make:?} / {model:?}, {order:?}"); for (tag, original) in [(t::MAKE, make), (t::MODEL, model)] { diff --git a/crates/raw/tests/it/robust.rs b/crates/raw/tests/it/robust.rs index ce41c1710c..3cd54e47e9 100644 --- a/crates/raw/tests/it/robust.rs +++ b/crates/raw/tests/it/robust.rs @@ -97,8 +97,8 @@ fn truncation_at_every_length() { #[test] fn hostile_dimensions_are_rejected_quickly() { // a DNG claiming a 60000 × 60000 16-bit image with 10 bytes of data - use lightcraft_tiff::tags as t; - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::tags as t; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let mut ifd = IfdBuilder::new(); ifd.set(t::DNG_VERSION, Value::Byte(vec![1, 4, 0, 0])); ifd.set(t::IMAGE_WIDTH, Value::Long(vec![60000])); @@ -120,8 +120,8 @@ fn hostile_dimensions_are_rejected_quickly() { /// read as 0 and non-finite samples as black: the photo develops to finite numbers. #[test] fn non_finite_black_levels_and_samples_develop() { - use lightcraft_tiff::tags as t; - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; + use craft_tiff::tags as t; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value}; let (w, h) = (32u32, 16u32); for black in [Value::Float(vec![f32::NAN]), Value::Double(vec![f64::INFINITY]), Value::Float(vec![64.0, f32::NAN, 64.0, 64.0])] { let mut ifd = IfdBuilder::new(); diff --git a/crates/raw/tests/it/sony_lens_inventory.rs b/crates/raw/tests/it/sony_lens_inventory.rs index 3eda884187..bea6dfde48 100644 --- a/crates/raw/tests/it/sony_lens_inventory.rs +++ b/crates/raw/tests/it/sony_lens_inventory.rs @@ -292,7 +292,7 @@ impl Drop for Scratch { /// A small Sony CFA file with a distortion setting (a lens record), or, `unsupported`, the packed 12-bit ARW variant /// the decoder refuses as unsupported. fn synthetic_arw(unsupported: bool) -> Vec { - use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; + use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags as t}; let mut raw = IfdBuilder::new(); raw.set(t::MAKE, Value::Ascii("SONY".into())); raw.set(t::MODEL, Value::Ascii("ILCE-7CR".into())); diff --git a/crates/raw/tests/it/vendor_robust.rs b/crates/raw/tests/it/vendor_robust.rs index 446c1fb60a..1ebbae6633 100644 --- a/crates/raw/tests/it/vendor_robust.rs +++ b/crates/raw/tests/it/vendor_robust.rs @@ -1,7 +1,7 @@ //! Malformed vendor raw files (NEF, ARW, PEF, ORF, RW2 of every raw format, CR2, RAF, CRW) must decode to an error, never panic. -use lightcraft_tiff::tags as t; -use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; +use craft_tiff::tags as t; +use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value}; use proptest::prelude::*; const W: u32 = 32; diff --git a/crates/raw/tests/sr2_heap.rs b/crates/raw/tests/sr2_heap.rs index 2b936d18c2..8839e66c8d 100644 --- a/crates/raw/tests/sr2_heap.rs +++ b/crates/raw/tests/sr2_heap.rs @@ -3,7 +3,7 @@ //! it must not cost memory sized by its other entries: a hostile file can give it fields that each alias most of the //! file. Only the block's offset, length and key may be read. One test per binary (dhat's profiler is global). -use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, Tiff, TiffWriter, Value, tags as t}; +use craft_tiff::{ByteOrder, IfdBuilder, ImageData, Tiff, TiffWriter, Value, tags as t}; #[global_allocator] static ALLOC: dhat::Alloc = dhat::Alloc; diff --git a/crates/tiff/Cargo.toml b/crates/tiff/Cargo.toml deleted file mode 100644 index 74919c6928..0000000000 --- a/crates/tiff/Cargo.toml +++ /dev/null @@ -1,16 +0,0 @@ -[package] -name = "lightcraft-tiff" -version.workspace = true -edition.workspace = true -license.workspace = true -description = "LightCraft TIFF/IFD reader and writer (L0)" - -[lints] -workspace = true - -[dependencies] -serde = { workspace = true } -thiserror = { workspace = true } - -[dev-dependencies] -proptest = { workspace = true } diff --git a/crates/tiff/README.md b/crates/tiff/README.md deleted file mode 100644 index 2436b0d311..0000000000 --- a/crates/tiff/README.md +++ /dev/null @@ -1,45 +0,0 @@ -# lightcraft-tiff (L0) - -TIFF / IFD reader and writer. Used by `lightcraft-raw` (DNG, CR2, NEF, ARW…), `lightcraft-meta` (Exif) and -later the TIFF/DNG exporters. - -## Features - -- Classic TIFF and BigTIFF, little- and big-endian (`II`/`MM`). Also accepts the TIFF-like magic numbers of - some raw formats (ORF `IIRO`/`IIRS`, RW2 `IIU`) when `ParseOptions::accept_raw_magic` is set (default). -- Every field type: BYTE, ASCII, SHORT, LONG, RATIONAL, SBYTE, UNDEFINED, SSHORT, SLONG, SRATIONAL, FLOAT, - DOUBLE, IFD, LONG8, SLONG8, IFD8. -- IFD chain + `SubIFDs` (330) + Exif (34665) / GPS (34853) / Interoperability (40965) pointer IFDs, resolved - into a tree (`Ifd::sub_ifds`, `exif`, `gps`, `interop`). `Entry::offset` records the absolute position of - each value (needed for maker notes and embedded blobs). -- `parse_ifd_at(data, offset, order, base, bigtiff, opts)` parses an IFD whose offsets are relative to an - arbitrary base; `makernote::parse_makernote` knows the header / byte-order / offset-base conventions of - Canon, Nikon (types 1 and 3), Sony, Fujifilm, Olympus (old and new), Panasonic and Pentax notes. -- `image::ImageInfo` — width/height, bits, samples, compression, photometric, planar config, predictor, - sample format and the strip or tile chunk list (`chunks()`, `chunk_bytes()`); missing byte counts are - inferred. -- `directory_entries`, `entry_span`, `ParseOptions::budget_for` and `decode_value` are the reader's own rules - (directory layout and entry limit, which entries it reads, its value budget, value decoding), for callers that - must select entries exactly as `parse_ifd_at` would without decoding the whole directory (`lightcraft-raw`'s - Sony `SR2Private` lookup). -- `TiffWriter` writes IFD chains with strips or tiles, `SubIFDs` and pointer IFDs, in either byte order, - classic or BigTIFF; `writer::rational` / `srational` approximate floats as rationals. - -## Robustness - -The reader never panics on malformed input (proptests feed random and mutated files): offsets are -bounds-checked; out-of-range or unknown-type entries are skipped; IFD loops are detected; IFD count, -nesting depth and entries per IFD are limited; at most 65,536 directory entry slots -(`ParseOptions::max_entries_total`) are accepted across the main IFD chain and all child IFDs, even when tables -overlap at distinct offsets, and an IFD past that bound ends the chain or is skipped like any other bad IFD after -the first; a next-IFD pointer is followed only when every declared entry was read, with the counts compared as -64-bit numbers (a BigTIFF declaring 4,294,967,297 entries but holding one can't pass for a whole directory on a -32-bit target); the total bytes of decoded values are capped at -`8 × input + 1 MiB` so a file cannot make us allocate far more than its own size. - -## Sources - -Public specifications only: TIFF 6.0 (Adobe, 1992), the TIFF 6.0 supplements (IFD type, SubIFDs), the -BigTIFF format description (AWare Systems), Adobe DNG Specification 1.7 (tag numbers), CIPA DC-008 Exif 2.32, -and the ExifTool tag-name documentation (maker-note header conventions, prose only). No third-party code -was consulted. diff --git a/crates/tiff/src/image.rs b/crates/tiff/src/image.rs deleted file mode 100644 index 16e24f3676..0000000000 --- a/crates/tiff/src/image.rs +++ /dev/null @@ -1,248 +0,0 @@ -//! Image layout of an IFD: dimensions, sample format and the strip / tile chunks holding the pixels. - -use crate::{Ifd, Result, TiffError, tags}; -use serde::{Deserialize, Serialize}; - -/// How pixel data is split into chunks. -#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] -pub enum Layout { - Strips { rows_per_strip: u32 }, - Tiles { tile_width: u32, tile_height: u32 }, -} - -/// Pixel layout description of an IFD (TIFF 6.0 §3–§8, §15). -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -pub struct ImageInfo { - pub width: u32, - pub height: u32, - pub bits_per_sample: Vec, - pub samples_per_pixel: u16, - pub compression: u16, - pub photometric: u16, - /// 1 = chunky (interleaved), 2 = planar. - pub planar: u16, - pub predictor: u16, - /// 1 = unsigned int, 2 = signed int, 3 = IEEE float. - pub sample_format: u16, - pub new_subfile_type: u32, - pub layout: Layout, - pub offsets: Vec, - pub byte_counts: Vec, -} - -/// One strip or tile. -#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] -pub struct Chunk { - pub index: usize, - /// Top-left pixel of the chunk. - pub x: u32, - pub y: u32, - /// Nominal chunk size (tiles may extend past the image; strips are clipped to the image height). - pub width: u32, - pub height: u32, - /// Plane index for planar configuration 2 (else 0). - pub plane: u16, - pub offset: u64, - pub len: u64, -} - -impl ImageInfo { - pub fn from_ifd(ifd: &Ifd) -> Result { - let width = ifd.u32(tags::IMAGE_WIDTH).ok_or(TiffError::MissingTag(tags::IMAGE_WIDTH))?; - let height = ifd.u32(tags::IMAGE_LENGTH).ok_or(TiffError::MissingTag(tags::IMAGE_LENGTH))?; - if width == 0 || height == 0 { - return Err(TiffError::Invalid("zero image dimension".into())); - } - let samples_per_pixel = ifd.u16(tags::SAMPLES_PER_PIXEL).unwrap_or(1).max(1); - let bits_per_sample: Vec = - ifd.u64s(tags::BITS_PER_SAMPLE).map(|v| v.into_iter().map(|b| b.min(u16::MAX as u64) as u16).collect()).unwrap_or_else(|| vec![1]); - let bits_per_sample = if bits_per_sample.is_empty() { vec![1] } else { bits_per_sample }; - let planar = ifd.u16(tags::PLANAR_CONFIGURATION).unwrap_or(1); - let (layout, offsets, byte_counts) = if let Some(tw) = ifd.u32(tags::TILE_WIDTH) { - let th = ifd.u32(tags::TILE_LENGTH).ok_or(TiffError::MissingTag(tags::TILE_LENGTH))?; - if tw == 0 || th == 0 { - return Err(TiffError::Invalid("zero tile size".into())); - } - let offs = ifd.u64s(tags::TILE_OFFSETS).or_else(|| ifd.u64s(tags::STRIP_OFFSETS)).ok_or(TiffError::MissingTag(tags::TILE_OFFSETS))?; - let cnts = ifd - .u64s(tags::TILE_BYTE_COUNTS) - .or_else(|| ifd.u64s(tags::STRIP_BYTE_COUNTS)) - .ok_or(TiffError::MissingTag(tags::TILE_BYTE_COUNTS))?; - (Layout::Tiles { tile_width: tw, tile_height: th }, offs, cnts) - } else { - let offs = ifd.u64s(tags::STRIP_OFFSETS).ok_or(TiffError::MissingTag(tags::STRIP_OFFSETS))?; - let cnts = ifd.u64s(tags::STRIP_BYTE_COUNTS).unwrap_or_default(); - let rps = ifd.u32(tags::ROWS_PER_STRIP).unwrap_or(height).clamp(1, height); - (Layout::Strips { rows_per_strip: rps }, offs, cnts) - }; - Ok(ImageInfo { - width, - height, - bits_per_sample, - samples_per_pixel, - compression: ifd.u16(tags::COMPRESSION).unwrap_or(1), - photometric: ifd.u16(tags::PHOTOMETRIC).unwrap_or(1), - planar, - predictor: ifd.u16(tags::PREDICTOR).unwrap_or(1), - sample_format: ifd.u16(tags::SAMPLE_FORMAT).unwrap_or(1), - new_subfile_type: ifd.u32(tags::NEW_SUBFILE_TYPE).unwrap_or(0), - layout, - offsets, - byte_counts, - }) - } - - /// Bits of the first sample. - pub fn bits(&self) -> u16 { - self.bits_per_sample[0] - } - - /// Whether this IFD is a reduced-resolution image (NewSubfileType bit 0). - pub fn is_reduced(&self) -> bool { - self.new_subfile_type & 1 != 0 - } - - /// Number of chunks across and down per plane. - pub fn grid(&self) -> (u32, u32) { - match self.layout { - Layout::Strips { rows_per_strip } => (1, self.height.div_ceil(rows_per_strip)), - Layout::Tiles { tile_width, tile_height } => (self.width.div_ceil(tile_width), self.height.div_ceil(tile_height)), - } - } - - /// Nominal chunk dimensions. - pub fn chunk_size(&self) -> (u32, u32) { - match self.layout { - Layout::Strips { rows_per_strip } => (self.width, rows_per_strip), - Layout::Tiles { tile_width, tile_height } => (tile_width, tile_height), - } - } - - /// The chunk count the image declares (offsets present, cut to the layout's plane capacity) with the - /// geometry `chunks` needs to place each one. No descriptors are built, so a pathological strip array - /// costs it a length check. - fn chunk_grid(&self) -> (usize, u32, usize) { - let (across, down) = self.grid(); - let per_plane = across as usize * down as usize; - let planes = if self.planar == 2 { self.samples_per_pixel as usize } else { 1 }; - (self.offsets.len().min(per_plane.saturating_mul(planes)), across, per_plane) - } - - fn declared_chunk_count(&self) -> usize { - self.chunk_grid().0 - } - - /// The one chunk when the image has exactly one, else `None` — and no descriptor vector beyond it. Preview - /// extraction only serves single-chunk images, so it asks here before serving a hostile multi-strip layout. - pub fn single_chunk(&self, data_len: u64) -> Option { - if self.declared_chunk_count() != 1 { - return None; - } - self.chunks(data_len).into_iter().next() - } - - /// All chunks that have an offset. Missing byte counts are inferred as "to the next offset / end of data" - /// using `data_len`. - pub fn chunks(&self, data_len: u64) -> Vec { - let (n, across, per_plane) = self.chunk_grid(); - let (cw, ch) = self.chunk_size(); - let mut out = Vec::with_capacity(n); - // the distinct offsets in order, for chunks without a byte count (sorted once, not scanned per chunk) - let mut sorted: Vec = Vec::new(); - if (0..n).any(|i| self.byte_counts.get(i).is_none_or(|&l| l == 0)) { - sorted = self.offsets.clone(); - sorted.sort_unstable(); - sorted.dedup(); - } - for i in 0..n { - let plane = i / per_plane.max(1); - let j = i % per_plane.max(1); - let (cx, cy) = (j as u32 % across, j as u32 / across); - let x = cx * cw; - let y = cy * ch; - let height = match self.layout { - Layout::Strips { .. } => ch.min(self.height - y), - Layout::Tiles { .. } => ch, - }; - let offset = self.offsets[i]; - let len = match self.byte_counts.get(i) { - Some(&l) if l > 0 => l, - _ => { - // infer: up to the next larger offset, else end of data - let next = sorted.get(sorted.partition_point(|&o| o <= offset)).copied().unwrap_or(data_len); - next.saturating_sub(offset) - } - }; - out.push(Chunk { index: i, x, y, width: cw, height, plane: plane as u16, offset, len }); - } - out - } -} - -/// The bytes of a chunk, clipped to the available data (truncated files yield a shorter slice). -/// Returns `None` only when the chunk starts past the end of `data`. -pub fn chunk_bytes<'a>(data: &'a [u8], c: &Chunk) -> Option<&'a [u8]> { - let start = usize::try_from(c.offset).ok()?; - if start >= data.len() { - return None; - } - let end = (c.offset.saturating_add(c.len)).min(data.len() as u64) as usize; - Some(&data[start..end]) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn strips(offsets: Vec, byte_counts: Vec) -> ImageInfo { - ImageInfo { - width: 1, - height: offsets.len() as u32, - bits_per_sample: vec![8], - samples_per_pixel: 1, - compression: 1, - photometric: 1, - planar: 1, - predictor: 1, - sample_format: 1, - new_subfile_type: 0, - layout: Layout::Strips { rows_per_strip: 1 }, - offsets, - byte_counts, - } - } - - /// One offset is one chunk, and `single_chunk` refuses to build descriptors when the image declares more. - #[test] - fn single_chunk_is_the_only_chunk() { - let one = strips(vec![50], vec![10]); - assert_eq!(one.single_chunk(100).map(|c| (c.index, c.offset, c.len)), one.chunks(100).first().map(|c| (c.index, c.offset, c.len))); - // the inferred length matches too, and never falls back past the data - let inferred = strips(vec![70], vec![]); - assert_eq!(inferred.single_chunk(100).map(|c| c.len), Some(30)); - assert!(strips(vec![50, 10], vec![10, 5]).single_chunk(100).is_none(), "a multi-chunk image has no single chunk"); - assert!(strips(Vec::new(), Vec::new()).single_chunk(100).is_none()); - } - - #[test] - fn missing_byte_counts_run_to_the_next_larger_offset() { - let info = strips(vec![50, 10, 30, 10, 70], vec![0, 0, 5]); - let lens: Vec = info.chunks(100).iter().map(|c| c.len).collect(); - assert_eq!(lens, vec![20, 20, 5, 20, 30]); - } - - /// A million strips without byte counts (offsets in descending order) are measured in one sort, not one - /// scan of all offsets per strip. - #[test] - fn many_strips_without_byte_counts_are_fast() { - let n = 1_000_000u64; - let info = strips((0..n).rev().map(|i| 1000 + i * 2).collect(), Vec::new()); - let (tx, rx) = std::sync::mpsc::channel(); - std::thread::spawn(move || { - let chunks = info.chunks(1000 + n * 2); - let _ = tx.send(chunks.iter().map(|c| c.len).collect::>()); - }); - let lens = rx.recv_timeout(std::time::Duration::from_secs(20)).expect("chunks() took longer than 20 s"); - assert!(lens.iter().all(|&l| l == 2)); - } -} diff --git a/crates/tiff/src/lib.rs b/crates/tiff/src/lib.rs deleted file mode 100644 index 2072c4936e..0000000000 --- a/crates/tiff/src/lib.rs +++ /dev/null @@ -1,468 +0,0 @@ -//! TIFF / IFD reading and writing for LightCraft. -//! -//! - [`Tiff::parse`] reads classic TIFF and BigTIFF in both byte orders, following the IFD chain, -//! `SubIFDs`, and the Exif / GPS / Interoperability IFD pointers. All field types of TIFF 6.0, -//! the TIFF 6.0 supplement (`IFD`) and BigTIFF (`LONG8`, `SLONG8`, `IFD8`) are decoded. -//! - [`parse_ifd_at`] parses a single IFD with an arbitrary offset base — the building block for -//! maker-note IFDs ([`makernote`]). -//! - [`image::ImageInfo`] describes the pixel layout of an IFD (strips or tiles, planar config, -//! compression, predictor) and enumerates its [`image::Chunk`]s. -//! - [`writer::TiffWriter`] writes IFD trees (with strips/tiles, `SubIFDs` and pointer IFDs) in -//! either byte order, classic or BigTIFF. -//! -//! The reader never panics on malformed input: every offset is bounds-checked, IFD loops are -//! detected, nesting depth / IFD count are limited, at most 65,536 directory entry slots are read -//! across the main chain and child IFDs, and decoded value bytes are capped relative to the input -//! size (so overlapping tables cannot multiply entry-vector allocations without bound). -//! -//! Sources: TIFF 6.0 specification (Adobe, 1992), TIFF Technical Note / supplements, the BigTIFF -//! design notes (AWare Systems), Adobe DNG specification 1.7 (tag numbers), CIPA DC-008 (Exif 2.32). -#![forbid(unsafe_code)] -#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] - -pub mod image; -pub mod makernote; -mod reader; -pub mod tags; -pub mod writer; - -pub use reader::{DirectoryEntries, EntrySpan, ParseOptions, decode as decode_value, directory_entries, entry_span, parse_ifd_at}; -pub use writer::{IfdBuilder, ImageData, TiffWriter}; - -use serde::{Deserialize, Serialize}; - -/// Errors from TIFF parsing / writing. -#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] -pub enum TiffError { - #[error("not a TIFF stream (bad header)")] - NotTiff, - #[error("data truncated at offset {0}")] - Truncated(u64), - #[error("invalid TIFF structure: {0}")] - Invalid(String), - #[error("resource limit exceeded: {0}")] - Limit(&'static str), - #[error("missing required tag {0}")] - MissingTag(u16), -} - -pub type Result = std::result::Result; - -/// Byte order of a TIFF stream. -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Default)] -pub enum ByteOrder { - /// `II` — Intel, little-endian. - #[default] - Little, - /// `MM` — Motorola, big-endian. - Big, -} - -impl ByteOrder { - #[inline] - pub fn u16(self, b: [u8; 2]) -> u16 { - match self { - ByteOrder::Little => u16::from_le_bytes(b), - ByteOrder::Big => u16::from_be_bytes(b), - } - } - #[inline] - pub fn u32(self, b: [u8; 4]) -> u32 { - match self { - ByteOrder::Little => u32::from_le_bytes(b), - ByteOrder::Big => u32::from_be_bytes(b), - } - } - #[inline] - pub fn u64(self, b: [u8; 8]) -> u64 { - match self { - ByteOrder::Little => u64::from_le_bytes(b), - ByteOrder::Big => u64::from_be_bytes(b), - } - } - /// Read a `u16` at `off`, or `None` if out of bounds. - #[inline] - pub fn read_u16(self, data: &[u8], off: usize) -> Option { - data.get(off..off.checked_add(2)?).map(|s| self.u16([s[0], s[1]])) - } - #[inline] - pub fn read_u32(self, data: &[u8], off: usize) -> Option { - data.get(off..off.checked_add(4)?).map(|s| self.u32([s[0], s[1], s[2], s[3]])) - } - #[inline] - pub fn read_u64(self, data: &[u8], off: usize) -> Option { - data.get(off..off.checked_add(8)?).map(|s| self.u64([s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]])) - } - pub fn put_u16(self, out: &mut Vec, v: u16) { - out.extend_from_slice(&match self { - ByteOrder::Little => v.to_le_bytes(), - ByteOrder::Big => v.to_be_bytes(), - }); - } - pub fn put_u32(self, out: &mut Vec, v: u32) { - out.extend_from_slice(&match self { - ByteOrder::Little => v.to_le_bytes(), - ByteOrder::Big => v.to_be_bytes(), - }); - } - pub fn put_u64(self, out: &mut Vec, v: u64) { - out.extend_from_slice(&match self { - ByteOrder::Little => v.to_le_bytes(), - ByteOrder::Big => v.to_be_bytes(), - }); - } -} - -/// TIFF field types (TIFF 6.0 §2 + supplements + BigTIFF). -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] -#[repr(u16)] -pub enum FieldType { - Byte = 1, - Ascii = 2, - Short = 3, - Long = 4, - Rational = 5, - SByte = 6, - Undefined = 7, - SShort = 8, - SLong = 9, - SRational = 10, - Float = 11, - Double = 12, - Ifd = 13, - Long8 = 16, - SLong8 = 17, - Ifd8 = 18, -} - -impl FieldType { - pub fn from_u16(v: u16) -> Option { - use FieldType::*; - Some(match v { - 1 => Byte, - 2 => Ascii, - 3 => Short, - 4 => Long, - 5 => Rational, - 6 => SByte, - 7 => Undefined, - 8 => SShort, - 9 => SLong, - 10 => SRational, - 11 => Float, - 12 => Double, - 13 => Ifd, - 16 => Long8, - 17 => SLong8, - 18 => Ifd8, - _ => return None, - }) - } - /// Size in bytes of one value. - pub fn size(self) -> usize { - use FieldType::*; - match self { - Byte | Ascii | SByte | Undefined => 1, - Short | SShort => 2, - Long | SLong | Float | Ifd => 4, - Rational | SRational | Double | Long8 | SLong8 | Ifd8 => 8, - } - } -} - -/// A decoded field value. Arrays are stored in their native type. -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -pub enum Value { - Byte(Vec), - /// ASCII text (bytes up to the first NUL, decoded lossily as UTF-8). - Ascii(String), - Short(Vec), - Long(Vec), - Rational(Vec<(u32, u32)>), - SByte(Vec), - Undefined(Vec), - SShort(Vec), - SLong(Vec), - SRational(Vec<(i32, i32)>), - Float(Vec), - Double(Vec), - Ifd(Vec), - Long8(Vec), - SLong8(Vec), - Ifd8(Vec), -} - -impl Value { - pub fn field_type(&self) -> FieldType { - match self { - Value::Byte(_) => FieldType::Byte, - Value::Ascii(_) => FieldType::Ascii, - Value::Short(_) => FieldType::Short, - Value::Long(_) => FieldType::Long, - Value::Rational(_) => FieldType::Rational, - Value::SByte(_) => FieldType::SByte, - Value::Undefined(_) => FieldType::Undefined, - Value::SShort(_) => FieldType::SShort, - Value::SLong(_) => FieldType::SLong, - Value::SRational(_) => FieldType::SRational, - Value::Float(_) => FieldType::Float, - Value::Double(_) => FieldType::Double, - Value::Ifd(_) => FieldType::Ifd, - Value::Long8(_) => FieldType::Long8, - Value::SLong8(_) => FieldType::SLong8, - Value::Ifd8(_) => FieldType::Ifd8, - } - } - - /// Number of values (for ASCII: bytes including the terminating NUL). - pub fn count(&self) -> usize { - match self { - Value::Byte(v) | Value::Undefined(v) => v.len(), - Value::Ascii(s) => s.len() + 1, - Value::Short(v) => v.len(), - Value::Long(v) | Value::Ifd(v) => v.len(), - Value::Rational(v) => v.len(), - Value::SByte(v) => v.len(), - Value::SShort(v) => v.len(), - Value::SLong(v) => v.len(), - Value::SRational(v) => v.len(), - Value::Float(v) => v.len(), - Value::Double(v) => v.len(), - Value::Long8(v) | Value::Ifd8(v) => v.len(), - Value::SLong8(v) => v.len(), - } - } - - /// Value `i` as `f64` (rationals divided; zero denominators give `None`). ASCII has no numbers. - pub fn get_f64(&self, i: usize) -> Option { - Some(match self { - Value::Byte(v) | Value::Undefined(v) => *v.get(i)? as f64, - Value::Ascii(_) => return None, - Value::Short(v) => *v.get(i)? as f64, - Value::Long(v) | Value::Ifd(v) => *v.get(i)? as f64, - Value::Rational(v) => { - let (n, d) = *v.get(i)?; - if d == 0 { - return None; - } - n as f64 / d as f64 - } - Value::SByte(v) => *v.get(i)? as f64, - Value::SShort(v) => *v.get(i)? as f64, - Value::SLong(v) => *v.get(i)? as f64, - Value::SRational(v) => { - let (n, d) = *v.get(i)?; - if d == 0 { - return None; - } - n as f64 / d as f64 - } - Value::Float(v) => *v.get(i)? as f64, - Value::Double(v) => *v.get(i)?, - Value::Long8(v) | Value::Ifd8(v) => *v.get(i)? as f64, - Value::SLong8(v) => *v.get(i)? as f64, - }) - } - - /// Value `i` as an unsigned integer (integer types only; negative values give `None`). - pub fn get_u64(&self, i: usize) -> Option { - match self { - Value::Byte(v) | Value::Undefined(v) => v.get(i).map(|&x| x as u64), - Value::Short(v) => v.get(i).map(|&x| x as u64), - Value::Long(v) | Value::Ifd(v) => v.get(i).map(|&x| x as u64), - Value::Long8(v) | Value::Ifd8(v) => v.get(i).copied(), - Value::SByte(v) => v.get(i).and_then(|&x| u64::try_from(x).ok()), - Value::SShort(v) => v.get(i).and_then(|&x| u64::try_from(x).ok()), - Value::SLong(v) => v.get(i).and_then(|&x| u64::try_from(x).ok()), - Value::SLong8(v) => v.get(i).and_then(|&x| u64::try_from(x).ok()), - _ => None, - } - } - - /// Value `i` as a signed integer (integer types only). - pub fn get_i64(&self, i: usize) -> Option { - match self { - Value::SByte(v) => v.get(i).map(|&x| x as i64), - Value::SShort(v) => v.get(i).map(|&x| x as i64), - Value::SLong(v) => v.get(i).map(|&x| x as i64), - Value::SLong8(v) => v.get(i).copied(), - _ => self.get_u64(i).and_then(|x| i64::try_from(x).ok()), - } - } - - /// All values as `f64` (missing/invalid entries skipped for rationals with zero denominators → 0). - pub fn to_f64_vec(&self) -> Vec { - (0..self.len_values()).map(|i| self.get_f64(i).unwrap_or(0.0)).collect() - } - - /// All values as `u64` (integer types only; otherwise empty). - pub fn to_u64_vec(&self) -> Vec { - (0..self.len_values()).map_while(|i| self.get_u64(i)).collect() - } - - fn len_values(&self) -> usize { - match self { - Value::Ascii(_) => 0, - _ => self.count(), - } - } - - /// Text for ASCII values (trimmed of trailing NULs / spaces); `Byte`/`Undefined` are decoded as UTF-8 (lossy) - /// up to the first NUL, which covers XMP packets and UCS-less Exif strings. - pub fn as_str(&self) -> Option { - match self { - Value::Ascii(s) => Some(s.trim_end_matches([' ', '\0']).to_string()), - Value::Byte(b) | Value::Undefined(b) => { - let end = b.iter().position(|&c| c == 0).unwrap_or(b.len()); - Some(String::from_utf8_lossy(&b[..end]).trim_end().to_string()) - } - _ => None, - } - } - - /// Raw bytes for `Byte` / `Undefined` / `SByte` / `Ascii`. - pub fn as_bytes(&self) -> Option<&[u8]> { - match self { - Value::Byte(b) | Value::Undefined(b) => Some(b), - Value::Ascii(s) => Some(s.as_bytes()), - _ => None, - } - } -} - -/// One IFD entry. -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -pub struct Entry { - pub tag: u16, - pub value: Value, - /// Absolute position in the parsed buffer of the value bytes (inline or out-of-line). - pub offset: u64, -} - -impl Entry { - pub fn field_type(&self) -> FieldType { - self.value.field_type() - } - pub fn count(&self) -> usize { - self.value.count() - } -} - -/// An Image File Directory with its child IFDs already resolved. -#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] -pub struct Ifd { - /// Absolute offset of the IFD in the buffer. - pub offset: u64, - /// Entries sorted by tag (duplicate tags: the first occurrence wins). - pub entries: Vec, - /// IFDs referenced by `SubIFDs` (330). - pub sub_ifds: Vec, - /// Exif private IFD (34665). - pub exif: Option>, - /// GPS IFD (34853). - pub gps: Option>, - /// Interoperability IFD (40965). - pub interop: Option>, -} - -impl Ifd { - pub fn get(&self, tag: u16) -> Option<&Entry> { - self.entries.binary_search_by_key(&tag, |e| e.tag).ok().map(|i| &self.entries[i]) - } - pub fn contains(&self, tag: u16) -> bool { - self.get(tag).is_some() - } - pub fn value(&self, tag: u16) -> Option<&Value> { - self.get(tag).map(|e| &e.value) - } - /// First value as `u32` (integer types, saturating from wider types). - pub fn u32(&self, tag: u16) -> Option { - self.value(tag)?.get_u64(0).map(|v| v.min(u32::MAX as u64) as u32) - } - pub fn u64(&self, tag: u16) -> Option { - self.value(tag)?.get_u64(0) - } - pub fn u16(&self, tag: u16) -> Option { - self.value(tag)?.get_u64(0).map(|v| v.min(u16::MAX as u64) as u16) - } - pub fn i64(&self, tag: u16) -> Option { - self.value(tag)?.get_i64(0) - } - pub fn f64(&self, tag: u16) -> Option { - self.value(tag)?.get_f64(0) - } - pub fn f64s(&self, tag: u16) -> Option> { - self.value(tag).map(|v| v.to_f64_vec()) - } - pub fn u64s(&self, tag: u16) -> Option> { - self.value(tag).map(|v| v.to_u64_vec()) - } - /// Text value (ASCII, or UTF-8 bytes). - pub fn string(&self, tag: u16) -> Option { - self.value(tag)?.as_str().filter(|s| !s.is_empty()) - } - pub fn bytes(&self, tag: u16) -> Option<&[u8]> { - self.value(tag)?.as_bytes() - } - - /// This IFD and all descendants (sub-IFDs, Exif, GPS, Interop), depth-first, pre-order. - pub fn walk(&self) -> Vec<&Ifd> { - let mut out = vec![self]; - for s in &self.sub_ifds { - out.extend(s.walk()); - } - for c in [&self.exif, &self.gps, &self.interop].into_iter().flatten() { - out.extend(c.walk()); - } - out - } - - /// Image layout of this IFD, if it describes an image. - pub fn image(&self) -> Result { - image::ImageInfo::from_ifd(self) - } -} - -/// A parsed TIFF stream (IFD chain with resolved children). -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -pub struct Tiff { - pub order: ByteOrder, - pub bigtiff: bool, - /// The main IFD chain (IFD0, IFD1, …). - pub ifds: Vec, -} - -impl Tiff { - /// Parse a TIFF stream (the header must be at offset 0 of `data`). - pub fn parse(data: &[u8]) -> Result { - reader::parse(data, &ParseOptions::default()) - } - pub fn parse_with(data: &[u8], opts: &ParseOptions) -> Result { - reader::parse(data, opts) - } - /// Header check only: returns the byte order and BigTIFF flag. - pub fn sniff(data: &[u8]) -> Option<(ByteOrder, bool)> { - reader::header(data).ok().map(|(o, b, _)| (o, b)) - } - /// Every IFD (main chain and all children), depth-first. - pub fn all_ifds(&self) -> Vec<&Ifd> { - self.ifds.iter().flat_map(|i| i.walk()).collect() - } - /// The Exif IFD attached to IFD0 (or any IFD). - pub fn exif(&self) -> Option<&Ifd> { - self.all_ifds().into_iter().find_map(|i| i.exif.as_deref()) - } - pub fn gps(&self) -> Option<&Ifd> { - self.all_ifds().into_iter().find_map(|i| i.gps.as_deref()) - } - /// First entry for `tag` in IFD0, then the Exif IFD, then any IFD. - pub fn find(&self, tag: u16) -> Option<&Entry> { - if let Some(e) = self.ifds.first().and_then(|i| i.get(tag)) { - return Some(e); - } - if let Some(e) = self.exif().and_then(|i| i.get(tag)) { - return Some(e); - } - self.all_ifds().into_iter().find_map(|i| i.get(tag)) - } -} diff --git a/crates/tiff/src/makernote.rs b/crates/tiff/src/makernote.rs deleted file mode 100644 index 288b366f64..0000000000 --- a/crates/tiff/src/makernote.rs +++ /dev/null @@ -1,235 +0,0 @@ -//! Maker-note IFD helpers. -//! -//! Most vendors store their maker note (Exif tag 37500) as a TIFF IFD, but each uses its own header, -//! byte order and *offset base* (what stored value offsets are relative to). The header layouts here -//! follow the public descriptions in the ExifTool tag documentation (`MakerNotes` table) and the -//! vendors' own published notes; no third-party code was consulted. - -use crate::{ByteOrder, Ifd, ParseOptions, parse_ifd_at}; -use serde::{Deserialize, Serialize}; - -/// Maker-note dialects we know how to locate. -#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] -pub enum MakerNoteKind { - /// Plain IFD at the start of the note, offsets relative to the enclosing TIFF header (Canon, many others). - Plain, - /// `Nikon\0` + version + embedded TIFF header at +10; offsets relative to that header. - NikonV3, - /// `Nikon\0\x01\0`: IFD at +8, offsets relative to the enclosing TIFF header. - NikonV1, - /// `SONY DSC `/`SONY CAM `/`SONY MOBILE` etc.: 12-byte header, offsets relative to the TIFF header. - Sony, - /// `FUJIFILM` + LE u32 IFD offset; little-endian, offsets relative to the note start. - Fujifilm, - /// `OLYMPUS\0` + byte order + version: IFD at +12, offsets relative to the note start. - OlympusNew, - /// `OLYMP\0` / `EPSON\0` etc.: IFD at +8, offsets relative to the TIFF header. - OlympusOld, - /// `Panasonic\0\0\0`: IFD at +12, offsets relative to the TIFF header. - Panasonic, - /// `AOC\0` + byte order: IFD at +6, offsets relative to the TIFF header. - PentaxAoc, - /// `PENTAX \0` + byte order: IFD at +10, offsets relative to the note start. - Pentax, -} - -/// A parsed maker-note IFD. -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -pub struct MakerNote { - pub kind: MakerNoteKind, - pub order: ByteOrder, - /// Absolute offset that stored value offsets are relative to. - pub base: u64, - pub ifd: Ifd, -} - -/// Locate and parse the maker note stored at absolute `offset` (length `len`) inside `data`, the buffer whose -/// start is the enclosing TIFF header. `order` is the enclosing stream's byte order. `make` (the Exif Make) is -/// used only as a hint for header-less notes. Returns `None` for unknown or unparsable notes. -pub fn parse_makernote(data: &[u8], offset: u64, len: u64, order: ByteOrder, make: &str) -> Option { - let start = usize::try_from(offset).ok()?; - let end = start.checked_add(usize::try_from(len).ok()?)?.min(data.len()); - let note = data.get(start..end)?; - let order_at = |i: usize| match note.get(i..i + 2) { - Some(b"II") => Some(ByteOrder::Little), - Some(b"MM") => Some(ByteOrder::Big), - _ => None, - }; - // A fixed value budget: a maker note is at most tens of kilobytes of values in any honest file, and - // computing the budget from the buffer's length multiplies the file length (a hostile entry in a - // sparse header-read buffer, where the buffer holds the file's logical size but only a few - // kilobytes are loaded, would decode allocations no actual data backs). - let opts = ParseOptions { max_ifds: 64, max_depth: 3, value_budget: Some(1 << 20), ..Default::default() }; - let try_parse = |kind: MakerNoteKind, ifd_at: u64, base: u64, ord: ByteOrder| -> Option { - let (ifd, _) = parse_ifd_at(data, ifd_at, ord, base, false, &opts).ok()?; - (!ifd.entries.is_empty()).then_some(MakerNote { kind, order: ord, base, ifd }) - }; - if note.starts_with(b"Nikon\0") { - if note.get(6) == Some(&1) { - return try_parse(MakerNoteKind::NikonV1, offset + 8, 0, order); - } - let ord = order_at(10)?; - let ifd_rel = ord.read_u32(note, 14)? as u64; - let base = offset + 10; - return try_parse(MakerNoteKind::NikonV3, base + ifd_rel, base, ord); - } - if note.starts_with(b"FUJIFILM") || note.starts_with(b"GENERALE") { - let rel = ByteOrder::Little.read_u32(note, 8)? as u64; - return try_parse(MakerNoteKind::Fujifilm, offset + rel, offset, ByteOrder::Little); - } - if note.starts_with(b"OLYMPUS\0") || note.starts_with(b"OM SYSTEM\0") { - let (ord_at, ifd_at) = if note.starts_with(b"OM SYSTEM\0") { (12, 16) } else { (8, 12) }; - let ord = order_at(ord_at).unwrap_or(order); - return try_parse(MakerNoteKind::OlympusNew, offset + ifd_at, offset, ord); - } - for p in [b"OLYMP\0", b"EPSON\0", b"MINOL\0", b"CAMER\0", b"SANYO\0"] { - if note.starts_with(p) { - return try_parse(MakerNoteKind::OlympusOld, offset + 8, 0, order); - } - } - if note.starts_with(b"Panasonic\0") { - return try_parse(MakerNoteKind::Panasonic, offset + 12, 0, order); - } - if note.starts_with(b"AOC\0") { - let ord = order_at(4).unwrap_or(order); - return try_parse(MakerNoteKind::PentaxAoc, offset + 6, 0, ord); - } - if note.starts_with(b"PENTAX \0") { - let ord = order_at(8).unwrap_or(order); - return try_parse(MakerNoteKind::Pentax, offset + 10, offset, ord); - } - if (note.starts_with(b"SONY") || note.starts_with(b"VHAB \0")) - && let Some(m) = try_parse(MakerNoteKind::Sony, offset + 12, 0, order) - { - return Some(m); - } - let _ = make; - try_parse(MakerNoteKind::Plain, offset, 0, order) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::{IfdBuilder, TiffWriter, Value, tags}; - - /// Build a TIFF whose Exif IFD carries `note` as the maker note, return (bytes, note offset, len). - fn with_note(order: ByteOrder, note: Vec) -> (Vec, u64, u64) { - let mut exif = IfdBuilder::new(); - exif.set(tags::MAKER_NOTE, Value::Undefined(note)); - let mut ifd0 = IfdBuilder::new(); - ifd0.set(tags::MAKE, Value::Ascii("Test".into())); - ifd0.set_child(tags::EXIF_IFD, exif); - let bytes = TiffWriter { order, bigtiff: false }.write(&[ifd0]).unwrap(); - let t = crate::Tiff::parse(&bytes).unwrap(); - let e = t.exif().unwrap().get(tags::MAKER_NOTE).unwrap(); - let (off, len) = (e.offset, e.count() as u64); - (bytes, off, len) - } - - /// An IFD with one SHORT entry (tag 1, value 7) and one out-of-line LONG[2] entry at `rel` (relative to base). - fn tiny_ifd(order: ByteOrder, rel_values: u32) -> Vec { - let mut v = Vec::new(); - order.put_u16(&mut v, 2); - order.put_u16(&mut v, 1); - order.put_u16(&mut v, 3); - order.put_u32(&mut v, 1); - order.put_u16(&mut v, 7); - order.put_u16(&mut v, 0); - order.put_u16(&mut v, 2); - order.put_u16(&mut v, 4); - order.put_u32(&mut v, 2); - order.put_u32(&mut v, rel_values); - order.put_u32(&mut v, 0); - v - } - - #[test] - fn nikon_v3_uses_embedded_header_base() { - for order in [ByteOrder::Little, ByteOrder::Big] { - let mut note = b"Nikon\0\x02\x10\0\0".to_vec(); - let hdr_at = note.len(); - note.extend_from_slice(if order == ByteOrder::Little { b"II" } else { b"MM" }); - order.put_u16(&mut note, 42); - order.put_u32(&mut note, 8); - // IFD at +8 (relative to embedded header), values after IFD: 8 + 2 + 24 + 4 = 38 - note.extend(tiny_ifd(order, 38)); - order.put_u32(&mut note, 111); - order.put_u32(&mut note, 222); - let (bytes, off, len) = with_note(order, note); - let m = parse_makernote(&bytes, off, len, order, "NIKON CORPORATION").unwrap(); - assert_eq!(m.kind, MakerNoteKind::NikonV3); - assert_eq!(m.base, off + hdr_at as u64); - assert_eq!(m.ifd.u32(1), Some(7)); - assert_eq!(m.ifd.u64s(2).unwrap(), vec![111, 222]); - } - } - - #[test] - fn fujifilm_offsets_relative_to_note() { - let mut note = b"FUJIFILM".to_vec(); - ByteOrder::Little.put_u32(&mut note, 12); - // IFD at 12 (relative to note), values at 12 + 30 = 42 - note.extend(tiny_ifd(ByteOrder::Little, 42)); - ByteOrder::Little.put_u32(&mut note, 5); - ByteOrder::Little.put_u32(&mut note, 6); - // enclosing file is big-endian: Fuji notes are always little-endian - let (bytes, off, len) = with_note(ByteOrder::Big, note); - let m = parse_makernote(&bytes, off, len, ByteOrder::Big, "FUJIFILM").unwrap(); - assert_eq!(m.kind, MakerNoteKind::Fujifilm); - assert_eq!(m.order, ByteOrder::Little); - assert_eq!(m.ifd.u64s(2).unwrap(), vec![5, 6]); - } - - #[test] - fn plain_canon_style_note() { - // Plain IFD whose out-of-line offset is relative to the TIFF header: we need the absolute - // position, which we only know after writing. Write once to learn the offset, then patch. - let order = ByteOrder::Little; - let mut note = tiny_ifd(order, 0); - note.extend_from_slice(&[0; 8]); - let (mut bytes, off, len) = with_note(order, note); - let values_abs = off as u32 + 30; - bytes[off as usize + 22..off as usize + 26].copy_from_slice(&values_abs.to_le_bytes()); - bytes[off as usize + 30..off as usize + 34].copy_from_slice(&9u32.to_le_bytes()); - let m = parse_makernote(&bytes, off, len, order, "Canon").unwrap(); - assert_eq!(m.kind, MakerNoteKind::Plain); - assert_eq!(m.ifd.u64s(2).unwrap(), vec![9, 0]); - } - - /// A maker note's value budget is fixed, not computed from the length of the buffer it sits in: - /// an entry claiming more than the note budget (here 2 MB) is dropped, a fitting one is read. In a - /// sparse header read the buffer holds the file's logical size while only kilobytes were loaded, - /// so a length-scaled budget would let an unrelated entry decode megabytes of zeros (see the focus - /// reader, try_read_exif_with). - #[test] - fn a_note_entry_past_the_fixed_value_budget_is_dropped() { - let order = ByteOrder::Little; - let mut note = b"SONY DSC \0\0\0".to_vec(); - // the Sony IFD directly after the 12-byte header, one fitting BYTE entry and a decoy - // BYTE[2 MB] entry pointing into the file's own (zero-filled) body - order.put_u16(&mut note, 2); - order.put_u16(&mut note, 0x201b); - order.put_u16(&mut note, 1); - order.put_u32(&mut note, 1); - note.extend([3, 0, 0, 0]); - order.put_u16(&mut note, 0x9900); - order.put_u16(&mut note, 1); - order.put_u32(&mut note, 2 << 20); - order.put_u32(&mut note, 200); - order.put_u32(&mut note, 0); - let mut bytes = note.clone(); - bytes.resize(200 + (2 << 20), 0); // the decoy's value range is inside the real bytes - let m = parse_makernote(&bytes, 0, note.len() as u64, order, "SONY").unwrap(); - assert_eq!(m.kind, MakerNoteKind::Sony); - assert!(m.ifd.get(0x201b).is_some(), "the fitting entry is read"); - assert!(m.ifd.get(0x9900).is_none(), "the decoy is dropped by the value budget"); - } - - #[test] - fn garbage_note_is_none() { - let (bytes, off, len) = with_note(ByteOrder::Little, vec![0xff; 40]); - assert!(parse_makernote(&bytes, off, len, ByteOrder::Little, "X").is_none()); - assert!(parse_makernote(&bytes, 1 << 40, 10, ByteOrder::Little, "X").is_none()); - assert!(parse_makernote(&bytes, off, u64::MAX, ByteOrder::Little, "X").is_none()); - } -} diff --git a/crates/tiff/src/reader.rs b/crates/tiff/src/reader.rs deleted file mode 100644 index 70c66c5a74..0000000000 --- a/crates/tiff/src/reader.rs +++ /dev/null @@ -1,536 +0,0 @@ -//! Bounds-checked IFD parsing. - -use crate::{ByteOrder, Entry, FieldType, Ifd, Result, Tiff, TiffError, Value, tags}; -use std::collections::HashSet; - -/// Limits applied while parsing. The defaults are generous for real files and safe for hostile ones. -#[derive(Clone, Debug)] -pub struct ParseOptions { - /// Maximum number of IFDs visited in total (chain + children). - pub max_ifds: usize, - /// Maximum nesting depth of child IFDs. - pub max_depth: usize, - /// Maximum number of entries read from one IFD. - pub max_entries: usize, - /// Maximum total number of entries read across all IFDs (chain + children). - /// - /// Hostile files can reuse the same bytes for up to `max_ifds` tables of `max_entries` - /// entries each (overlapping IFD tables via SubIFD pointers shifted by one entry), which can - /// allocate millions of `Entry`s from a small input (~100 KB → ~400 MB). This hard cap bounds - /// that amplification regardless of entry size. 65 536 is generous for real files — a 50 MB - /// scanned TIFF with thousands of entries across chain + children stays well under it — yet - /// stops a small file from allocating hundreds of megabytes of `Entry`s. - pub max_entries_total: usize, - /// Maximum total bytes of decoded values; `None` = `8 × input length + 1 MiB`. - pub value_budget: Option, - /// Follow `SubIFDs` / Exif / GPS / Interop pointers. - pub follow_children: bool, - /// Accept the TIFF-like magic numbers used by some raw formats (ORF `IIRO`/`IIRS`, RW2 `IIU`). - pub accept_raw_magic: bool, -} - -impl Default for ParseOptions { - fn default() -> Self { - Self { - max_ifds: 1024, - max_depth: 10, - max_entries: 8192, - max_entries_total: 65536, - value_budget: None, - follow_children: true, - accept_raw_magic: true, - } - } -} - -impl ParseOptions { - /// The value budget for `data_len` bytes of input: [`Self::value_budget`], else `8 × data_len + 1 MiB`. - pub fn budget_for(&self, data_len: usize) -> u64 { - self.value_budget.unwrap_or((data_len as u64).saturating_mul(8).saturating_add(1 << 20)) - } -} - -/// Where a directory's entries are and how many of them the reader reads, as [`directory_entries`] found them. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct DirectoryEntries { - /// Position of the first entry. - table: usize, - /// Entries read: the declared count, cut to the entries the data holds and to the `max_entries` limit. - read: usize, - /// The declared entry count. - declared: u64, - /// Bytes per entry: 12, or 20 in BigTIFF. - entry_size: usize, -} - -impl DirectoryEntries { - /// Positions of the entries read, in directory order. Checked arithmetic: the iteration ends rather than - /// overflow, whatever the layout. - pub fn positions(&self) -> impl Iterator + use<> { - let (table, size) = (self.table, self.entry_size); - (0..self.read).map_while(move |i| i.checked_mul(size)?.checked_add(table)) - } - - /// The number of entries read. - pub fn read(&self) -> usize { - self.read - } - - /// The entry count the directory declares. - pub fn declared(&self) -> u64 { - self.declared - } -} - -/// The directory at `offset` as the reader walks it: its entry table and how many entries it reads. The same errors -/// as [`parse_ifd_at`] for a directory it can't read: past the data, empty, or without room for one entry. -pub fn directory_entries(data: &[u8], offset: u64, order: ByteOrder, bigtiff: bool, max_entries: usize) -> Result { - let pos = usize::try_from(offset).map_err(|_| TiffError::Truncated(offset))?; - let (n, head, entry_size) = if bigtiff { - (order.read_u64(data, pos).ok_or(TiffError::Truncated(offset))?, 8usize, 20usize) - } else { - (order.read_u16(data, pos).ok_or(TiffError::Truncated(offset))? as u64, 2, 12) - }; - let table = pos + head; - let fit = (data.len().saturating_sub(table) / entry_size) as u64; - let read = n.min(fit).min(max_entries as u64) as usize; - if n == 0 { - return Err(TiffError::Invalid(format!("empty IFD at {offset}"))); - } - if read == 0 { - return Err(TiffError::Truncated(offset)); - } - Ok(DirectoryEntries { table, read, declared: n, entry_size }) -} - -/// A directory entry the reader can read: its tag, type and count, and where its values are. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct EntrySpan { - pub tag: u16, - pub field_type: FieldType, - pub count: u64, - /// Position of the values in the data: the entry's own value field when they fit it, else `base` plus the offset - /// stored there. - pub start: u64, - /// `count × size` bytes. - pub len: u64, -} - -/// The entry at `pos`, when the reader reads it: a known field type, `count × size` without overflow, and values -/// inside `data`. Nothing is decoded; [`parse_ifd_at`] also drops an entry whose values exceed what is left of its -/// value budget ([`ParseOptions::budget_for`]), which this leaves to the caller. -pub fn entry_span(data: &[u8], pos: usize, order: ByteOrder, bigtiff: bool, base: u64) -> Option { - let tag = order.read_u16(data, pos)?; - let field_type = FieldType::from_u16(order.read_u16(data, pos.checked_add(2)?)?)?; - let (count, field, inline) = if bigtiff { - (order.read_u64(data, pos.checked_add(4)?)?, pos.checked_add(12)?, 8u64) - } else { - (order.read_u32(data, pos.checked_add(4)?)? as u64, pos.checked_add(8)?, 4) - }; - let len = count.checked_mul(field_type.size() as u64)?; - let start = if len <= inline { - field as u64 - } else { - let rel = if bigtiff { order.read_u64(data, field)? } else { order.read_u32(data, field)? as u64 }; - base.checked_add(rel)? - }; - let end = start.checked_add(len)?; - (end <= data.len() as u64).then_some(EntrySpan { tag, field_type, count, start, len }) -} - -/// Whether a directory declaring `declared` entries was read whole (`read` entries), so that its next-IFD pointer -/// follows them. The counts compare as 64-bit numbers: narrowing the declared count to `usize` instead would, on a -/// 32-bit target, let a BigTIFF declaring 4,294,967,297 entries but holding one pass for a whole directory. -fn reads_every_entry(declared: u64, read: usize) -> bool { - u64::try_from(read).is_ok_and(|read| read == declared) -} - -/// Parse the header: (byte order, bigtiff, first IFD offset). -pub(crate) fn header(data: &[u8]) -> Result<(ByteOrder, bool, u64)> { - header_with(data, true) -} - -fn header_with(data: &[u8], raw_magic: bool) -> Result<(ByteOrder, bool, u64)> { - let order = match data.get(0..2) { - Some(b"II") => ByteOrder::Little, - Some(b"MM") => ByteOrder::Big, - _ => return Err(TiffError::NotTiff), - }; - let magic = order.read_u16(data, 2).ok_or(TiffError::NotTiff)?; - match magic { - 42 => Ok((order, false, order.read_u32(data, 4).ok_or(TiffError::Truncated(4))? as u64)), - 43 => { - let bytesize = order.read_u16(data, 4).ok_or(TiffError::Truncated(4))?; - let zero = order.read_u16(data, 6).ok_or(TiffError::Truncated(6))?; - if bytesize != 8 || zero != 0 { - return Err(TiffError::NotTiff); - } - Ok((order, true, order.read_u64(data, 8).ok_or(TiffError::Truncated(8))?)) - } - 0x4f52 | 0x5352 | 0x0055 if raw_magic => Ok((order, false, order.read_u32(data, 4).ok_or(TiffError::Truncated(4))? as u64)), - _ => Err(TiffError::NotTiff), - } -} - -pub(crate) fn parse(data: &[u8], opts: &ParseOptions) -> Result { - let (order, big, first) = header_with(data, opts.accept_raw_magic)?; - let mut ctx = Ctx::new(data, order, big, opts); - let mut ifds = Vec::new(); - let mut off = first; - while off != 0 { - match ctx.ifd(off, 0, 0) { - Ok((ifd, next)) => { - ifds.push(ifd); - off = next; - } - Err(e) => { - if ifds.is_empty() { - return Err(e); - } - break; - } - } - } - if ifds.is_empty() { - return Err(TiffError::Invalid("no IFDs".into())); - } - Ok(Tiff { order, bigtiff: big, ifds }) -} - -/// Parse one IFD at absolute `offset` whose value offsets (and child IFD pointers) are relative to -/// `base` (absolute position = `base + stored offset`). Returns the IFD and the absolute offset of the -/// next IFD (0 when there is none). Used for maker notes, which often use their own offset base. -pub fn parse_ifd_at(data: &[u8], offset: u64, order: ByteOrder, base: u64, bigtiff: bool, opts: &ParseOptions) -> Result<(Ifd, u64)> { - let mut ctx = Ctx::new(data, order, bigtiff, opts); - ctx.ifd(offset, base, 0) -} - -struct Ctx<'a> { - data: &'a [u8], - order: ByteOrder, - big: bool, - opts: &'a ParseOptions, - visited: HashSet, - budget: u64, - entries_total: usize, -} - -impl<'a> Ctx<'a> { - fn new(data: &'a [u8], order: ByteOrder, big: bool, opts: &'a ParseOptions) -> Self { - let budget = opts.budget_for(data.len()); - Self { data, order, big, opts, visited: HashSet::new(), budget, entries_total: 0 } - } - - fn read_off(&self, pos: usize) -> Option { - if self.big { self.order.read_u64(self.data, pos) } else { self.order.read_u32(self.data, pos).map(|v| v as u64) } - } - - /// Returns (ifd, absolute next offset or 0). - fn ifd(&mut self, offset: u64, base: u64, depth: usize) -> Result<(Ifd, u64)> { - if depth > self.opts.max_depth { - return Err(TiffError::Limit("IFD nesting depth")); - } - if self.visited.len() >= self.opts.max_ifds { - return Err(TiffError::Limit("IFD count")); - } - if !self.visited.insert(offset) { - return Err(TiffError::Invalid(format!("IFD loop at {offset}"))); - } - let dir = directory_entries(self.data, offset, self.order, self.big, self.opts.max_entries)?; - // Bound total entries across the whole parse so overlapping IFD tables (SubIFD pointers - // shifted by one entry) cannot allocate millions of `Entry`s from a small input. - self.entries_total = self.entries_total.saturating_add(dir.read); - if self.entries_total > self.opts.max_entries_total { - return Err(TiffError::Limit("entry count")); - } - let mut entries = Vec::with_capacity(dir.read); - for p in dir.positions() { - if let Some(e) = self.entry(p, base) { - entries.push(e); - } - } - entries.sort_by_key(|e| e.tag); - entries.dedup_by_key(|e| e.tag); - // the next-IFD pointer follows the last entry, read only when every declared entry was (checked: a BigTIFF - // count can be anything up to u64::MAX) - let next = if reads_every_entry(dir.declared, dir.read) { - match dir.read.checked_mul(dir.entry_size).and_then(|n| n.checked_add(dir.table)).and_then(|p| self.read_off(p)) { - Some(0) | None => 0, - Some(v) => base.checked_add(v).unwrap_or(0), - } - } else { - 0 - }; - let mut ifd = Ifd { offset, entries, ..Default::default() }; - if self.opts.follow_children { - self.children(&mut ifd, base, depth); - } - Ok((ifd, next)) - } - - fn children(&mut self, ifd: &mut Ifd, base: u64, depth: usize) { - if let Some(v) = ifd.value(tags::SUB_IFDS) { - let offs = v.to_u64_vec(); - for o in offs { - if let Some(abs) = base.checked_add(o) - && let Ok((sub, _)) = self.ifd(abs, base, depth + 1) - { - ifd.sub_ifds.push(sub); - } - } - } - let child = |tag: u16, ctx: &mut Self| -> Option> { - let o = ifd.value(tag)?.get_u64(0)?; - let abs = base.checked_add(o)?; - ctx.ifd(abs, base, depth + 1).ok().map(|(i, _)| Box::new(i)) - }; - let exif = child(tags::EXIF_IFD, self); - let gps = child(tags::GPS_IFD, self); - let interop = child(tags::INTEROP_IFD, self); - ifd.exif = exif; - ifd.gps = gps; - ifd.interop = interop; - } - - fn entry(&mut self, p: usize, base: u64) -> Option { - let span = entry_span(self.data, p, self.order, self.big, base)?; - if span.len > self.budget { - return None; - } - self.budget -= span.len; - let bytes = self.data.get(usize::try_from(span.start).ok()?..usize::try_from(span.start + span.len).ok()?)?; - Some(Entry { tag: span.tag, value: decode(self.order, span.field_type, bytes), offset: span.start }) - } -} - -/// Decode `bytes` (exactly `count × size` long, or the first values of an entry) as values of type `typ`. -pub fn decode(o: ByteOrder, typ: FieldType, b: &[u8]) -> Value { - fn arr(c: &[u8]) -> [u8; N] { - let mut a = [0u8; N]; - a.copy_from_slice(c); - a - } - match typ { - FieldType::Byte => Value::Byte(b.to_vec()), - FieldType::Undefined => Value::Undefined(b.to_vec()), - FieldType::Ascii => { - let end = b.iter().position(|&c| c == 0).unwrap_or(b.len()); - Value::Ascii(String::from_utf8_lossy(&b[..end]).into_owned()) - } - FieldType::SByte => Value::SByte(b.iter().map(|&x| x as i8).collect()), - FieldType::Short => Value::Short(b.as_chunks::<2>().0.iter().map(|c| o.u16(arr(c))).collect()), - FieldType::SShort => Value::SShort(b.as_chunks::<2>().0.iter().map(|c| o.u16(arr(c)) as i16).collect()), - FieldType::Long => Value::Long(b.as_chunks::<4>().0.iter().map(|c| o.u32(arr(c))).collect()), - FieldType::Ifd => Value::Ifd(b.as_chunks::<4>().0.iter().map(|c| o.u32(arr(c))).collect()), - FieldType::SLong => Value::SLong(b.as_chunks::<4>().0.iter().map(|c| o.u32(arr(c)) as i32).collect()), - FieldType::Float => Value::Float(b.as_chunks::<4>().0.iter().map(|c| f32::from_bits(o.u32(arr(c)))).collect()), - FieldType::Rational => Value::Rational(b.as_chunks::<8>().0.iter().map(|c| (o.u32(arr(&c[..4])), o.u32(arr(&c[4..])))).collect()), - FieldType::SRational => { - Value::SRational(b.as_chunks::<8>().0.iter().map(|c| (o.u32(arr(&c[..4])) as i32, o.u32(arr(&c[4..])) as i32)).collect()) - } - FieldType::Double => Value::Double(b.as_chunks::<8>().0.iter().map(|c| f64::from_bits(o.u64(arr(c)))).collect()), - FieldType::Long8 => Value::Long8(b.as_chunks::<8>().0.iter().map(|c| o.u64(arr(c))).collect()), - FieldType::Ifd8 => Value::Ifd8(b.as_chunks::<8>().0.iter().map(|c| o.u64(arr(c))).collect()), - FieldType::SLong8 => Value::SLong8(b.as_chunks::<8>().0.iter().map(|c| o.u64(arr(c)) as i64).collect()), - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::Value; - use crate::tags as t; - use crate::writer::{IfdBuilder, TiffWriter}; - - /// A value budget the caller sets bounds what is decoded: an entry claiming more value bytes than - /// the budget allows is dropped, entries that fit are read (the sparse header-read path, where the - /// buffer holds the file's logical size but only a few kilobytes were ever loaded, sizes its - /// budget from what was fetched, not from whatever length the file claims). - #[test] - fn the_value_budget_drops_over_budget_entries_and_keeps_the_rest() { - let mut ifd0 = IfdBuilder::new(); - ifd0.set(t::MAKE, Value::Ascii("Keep".into())); - ifd0.set(0x9000, Value::Byte(vec![0; 2 << 20])); - let file = TiffWriter { order: ByteOrder::Little, bigtiff: false }.write(&[ifd0]).unwrap(); - let opts = ParseOptions { value_budget: Some(1 << 20), ..Default::default() }; - let tiff = Tiff::parse_with(&file, &opts).unwrap(); - assert_eq!(tiff.ifds[0].string(t::MAKE), Some("Keep".to_string()), "a fitting entry is read"); - assert!(tiff.ifds[0].get(0x9000).is_none(), "the over-budget entry is dropped"); - } - - /// A BigTIFF whose first IFD, at 80, declares `declared` entries but holds one, followed by a next-IFD pointer - /// `next`; a valid one-entry IFD sits at 16. - fn bigtiff_chain(order: ByteOrder, declared: u64, next: u64) -> Vec { - let ifd = |d: &mut Vec, count: u64, tag: u16, next: u64| { - order.put_u64(d, count); - order.put_u16(d, tag); - order.put_u16(d, 3); - order.put_u64(d, 1); - order.put_u16(d, 8); - d.extend([0; 6]); - order.put_u64(d, next); - }; - let mut d = if order == ByteOrder::Little { b"II".to_vec() } else { b"MM".to_vec() }; - order.put_u16(&mut d, 43); - order.put_u16(&mut d, 8); - order.put_u16(&mut d, 0); - order.put_u64(&mut d, 80); - ifd(&mut d, 1, 0x0101, 0); - d.resize(80, 0); - ifd(&mut d, declared, 0x0100, next); - d - } - - #[test] - fn only_a_directory_read_whole_has_a_next_pointer() { - // the comparison itself, on every target: a declared count past u32::MAX never matches a small read count - for (declared, read, whole) in [ - (0, 0, true), - (1, 1, true), - (8192, 8192, true), - (8193, 8192, false), - (1, 0, false), - ((1 << 32) + 1, 1, false), - ((2 << 32) + 1, 1, false), - ((1 << 63) + 1, 1, false), - (u64::MAX, 1, false), - ] { - assert_eq!(reads_every_entry(declared, read), whole, "{declared} declared, {read} read"); - } - } - - #[test] - fn a_bigtiff_count_past_u32_max_never_follows_the_next_pointer() { - // the whole chain: on 32-bit targets (wasm32) the old cast truncated these counts to 1 and followed the pointer - for order in [ByteOrder::Little, ByteOrder::Big] { - for declared in [(1u64 << 32) + 1, (2u64 << 32) + 1, (1u64 << 63) + 1] { - let d = bigtiff_chain(order, declared, 16); - let tiff = Tiff::parse(&d).unwrap(); - assert_eq!(tiff.ifds.len(), 1, "{order:?} {declared}"); - assert_eq!(tiff.ifds[0].u64(0x0100), Some(8)); - assert_eq!(parse_ifd_at(&d, 80, order, 0, true, &ParseOptions::default()).unwrap().1, 0, "{order:?} {declared}"); - } - // control: the same file declaring its one entry follows the pointer to the IFD at 16 - let whole = Tiff::parse(&bigtiff_chain(order, 1, 16)).unwrap(); - assert_eq!(whole.ifds.len(), 2, "{order:?}"); - assert_eq!(whole.ifds[1].u64(0x0101), Some(8)); - } - } - - #[test] - fn directory_positions_never_overflow() { - // a hand-built layout the reader never produces: the iterator stops instead of overflowing - let hostile = DirectoryEntries { table: usize::MAX, read: 2, declared: 2, entry_size: 12 }; - assert_eq!(hostile.positions().collect::>(), vec![usize::MAX]); - assert_eq!(hostile.positions().nth(1), None); - let wide = DirectoryEntries { table: usize::MAX - 30, read: 4, declared: 4, entry_size: 12 }; - assert_eq!(wide.positions().collect::>(), vec![usize::MAX - 30, usize::MAX - 18, usize::MAX - 6]); - // a directory read from data lists its entries - let mut data = Vec::new(); - ByteOrder::Little.put_u16(&mut data, 2); - data.extend([0; 24]); - let dir = directory_entries(&data, 0, ByteOrder::Little, false, 8192).unwrap(); - assert_eq!(dir.positions().collect::>(), vec![2, 14]); - } - - #[test] - fn a_bigtiff_directory_declaring_u64_max_entries_parses_without_overflow() { - // 44 bytes: BigTIFF header (first IFD at 16), an entry count of u64::MAX, one 20-byte entry - let mut data = b"II\x2b\x00\x08\x00\x00\x00".to_vec(); - data.extend(16u64.to_le_bytes()); - data.extend(u64::MAX.to_le_bytes()); - data.extend(0x0100u16.to_le_bytes()); - data.extend(3u16.to_le_bytes()); - data.extend(1u64.to_le_bytes()); - data.extend([8, 0, 0, 0, 0, 0, 0, 0]); - assert_eq!(data.len(), 44); - let tiff = Tiff::parse(&data).unwrap(); - assert_eq!(tiff.ifds.len(), 1); - assert_eq!(tiff.ifds[0].u64(0x0100), Some(8)); - } - #[test] - fn overlapping_ifd_tables_hit_entry_cap_instead_of_amplifying() { - // classic TIFF; IFDs at 8, 20, 32, ... each declaring 8192 entries whose tables overlap - // (next table starts one entry after the previous table's start). Without the cap, a single - // `Tiff::parse` would run `Vec::with_capacity(8192)` per IFD inside one `Ctx`, amplifying a - // small file into millions of `Entry`s; the per-`Ctx` `max_entries_total` cap rejects the - // 9th IFD before any allocation. - let mut data = vec![0u8; 200_000]; - data[0..2].copy_from_slice(b"II"); - data[2..4].copy_from_slice(&42u16.to_le_bytes()); - data[4..8].copy_from_slice(&8u32.to_le_bytes()); // first IFD at 8 - - for k in 0..9u64 { - let ifd_off = (8 + 12 * k) as usize; - data[ifd_off..ifd_off + 2].copy_from_slice(&8192u16.to_le_bytes()); // count - let table = ifd_off + 2; - let ptr = table + 8192 * 12; // next-IFD pointer lives right after the entries - let next = if k + 1 < 9 { (8 + 12 * (k + 1)) as u32 } else { 0 }; - data[ptr..ptr + 4].copy_from_slice(&next.to_le_bytes()); - } - - let tiff = Tiff::parse(&data).unwrap(); - assert_eq!(tiff.ifds.len(), 8, "8 IFDs parsed, 9th rejected by max_entries_total before allocation"); - } - - #[test] - fn a_legitimate_multi_ifd_file_still_parses_under_the_entry_cap() { - // classic TIFF: IFD0 @8 (3 entries: value + Exif + GPS child pointers) -> IFD1 @58 chain, - // plus Exif child @60 and GPS child @90. Total entries = 6, far under max_entries_total. - let mut data = vec![0u8; 128]; - data[0..2].copy_from_slice(b"II"); - data[2..4].copy_from_slice(&42u16.to_le_bytes()); - data[4..8].copy_from_slice(&8u32.to_le_bytes()); // first IFD at 8 - - // IFD0 @8: count 3, table @10, next-IFD @46 -> IFD1 @58 - data[8..10].copy_from_slice(&3u16.to_le_bytes()); - // entry0 @10: tag 0x0100, SHORT, count 1, value 8 (inline @18..22) - data[10..12].copy_from_slice(&0x0100u16.to_le_bytes()); - data[12..14].copy_from_slice(&3u16.to_le_bytes()); - data[14..18].copy_from_slice(&1u32.to_le_bytes()); - data[18..22].copy_from_slice(&8u32.to_le_bytes()); - // entry1 @22: tag 0x8769 ExifIFD, LONG, count 1, value 60 (inline @30..34) - data[22..24].copy_from_slice(&0x8769u16.to_le_bytes()); - data[24..26].copy_from_slice(&4u16.to_le_bytes()); - data[26..30].copy_from_slice(&1u32.to_le_bytes()); - data[30..34].copy_from_slice(&60u32.to_le_bytes()); - // entry2 @34: tag 0x8825 GPSIFD, LONG, count 1, value 90 (inline @42..46) - data[34..36].copy_from_slice(&0x8825u16.to_le_bytes()); - data[36..38].copy_from_slice(&4u16.to_le_bytes()); - data[38..42].copy_from_slice(&1u32.to_le_bytes()); - data[42..46].copy_from_slice(&90u32.to_le_bytes()); - data[46..50].copy_from_slice(&58u32.to_le_bytes()); // next IFD - - // IFD1 @58: count 1, table @60, next 0 - data[58..60].copy_from_slice(&1u16.to_le_bytes()); - data[60..62].copy_from_slice(&0x0100u16.to_le_bytes()); - data[62..64].copy_from_slice(&3u16.to_le_bytes()); - data[64..68].copy_from_slice(&1u32.to_le_bytes()); - data[68..72].copy_from_slice(&8u32.to_le_bytes()); - data[72..76].copy_from_slice(&0u32.to_le_bytes()); - - // Exif child IFD @60: count 1, entry tag 0x9000 value 1, next 0 - data[60..62].copy_from_slice(&1u16.to_le_bytes()); - data[62..64].copy_from_slice(&0x9000u16.to_le_bytes()); - data[64..66].copy_from_slice(&3u16.to_le_bytes()); - data[66..70].copy_from_slice(&1u32.to_le_bytes()); - data[70..74].copy_from_slice(&1u32.to_le_bytes()); - data[74..78].copy_from_slice(&0u32.to_le_bytes()); - - // GPS child IFD @90: count 1, entry tag 0 value 1, next 0 - data[90..92].copy_from_slice(&1u16.to_le_bytes()); - data[92..94].copy_from_slice(&0u16.to_le_bytes()); - data[94..96].copy_from_slice(&3u16.to_le_bytes()); - data[96..100].copy_from_slice(&1u32.to_le_bytes()); - data[100..104].copy_from_slice(&1u32.to_le_bytes()); - data[104..108].copy_from_slice(&0u32.to_le_bytes()); - - let tiff = Tiff::parse(&data).unwrap(); - assert_eq!(tiff.ifds.len(), 2, "chain IFDs parse fully"); - assert_eq!(tiff.ifds[0].u64(0x0100), Some(8)); - let exif = tiff.ifds[0].exif.as_ref().expect("Exif child present"); - assert_eq!(exif.u64(0x9000), Some(1)); - let gps = tiff.ifds[0].gps.as_ref().expect("GPS child present"); - assert_eq!(gps.u64(0x0000), Some(1)); - } -} diff --git a/crates/tiff/src/tags.rs b/crates/tiff/src/tags.rs deleted file mode 100644 index 458aefe535..0000000000 --- a/crates/tiff/src/tags.rs +++ /dev/null @@ -1,226 +0,0 @@ -//! Tag numbers (TIFF 6.0, TIFF/EP, Exif 2.32, GPS, DNG 1.7). Public specification constants. - -// --- TIFF baseline / extensions -pub const NEW_SUBFILE_TYPE: u16 = 254; -pub const SUBFILE_TYPE: u16 = 255; -pub const IMAGE_WIDTH: u16 = 256; -pub const IMAGE_LENGTH: u16 = 257; -pub const BITS_PER_SAMPLE: u16 = 258; -pub const COMPRESSION: u16 = 259; -pub const PHOTOMETRIC: u16 = 262; -pub const FILL_ORDER: u16 = 266; -pub const DOCUMENT_NAME: u16 = 269; -pub const IMAGE_DESCRIPTION: u16 = 270; -pub const MAKE: u16 = 271; -pub const MODEL: u16 = 272; -pub const STRIP_OFFSETS: u16 = 273; -pub const ORIENTATION: u16 = 274; -pub const SAMPLES_PER_PIXEL: u16 = 277; -pub const ROWS_PER_STRIP: u16 = 278; -pub const STRIP_BYTE_COUNTS: u16 = 279; -pub const X_RESOLUTION: u16 = 282; -pub const Y_RESOLUTION: u16 = 283; -pub const PLANAR_CONFIGURATION: u16 = 284; -pub const RESOLUTION_UNIT: u16 = 296; -pub const SOFTWARE: u16 = 305; -pub const DATE_TIME: u16 = 306; -pub const ARTIST: u16 = 315; -pub const PREDICTOR: u16 = 317; -pub const TILE_WIDTH: u16 = 322; -pub const TILE_LENGTH: u16 = 323; -pub const TILE_OFFSETS: u16 = 324; -pub const TILE_BYTE_COUNTS: u16 = 325; -pub const SUB_IFDS: u16 = 330; -pub const EXTRA_SAMPLES: u16 = 338; -pub const SAMPLE_FORMAT: u16 = 339; -pub const JPEG_INTERCHANGE_FORMAT: u16 = 513; -pub const JPEG_INTERCHANGE_FORMAT_LENGTH: u16 = 514; -pub const YCBCR_SUBSAMPLING: u16 = 530; -pub const XMP: u16 = 700; -pub const RATING: u16 = 18246; -pub const RATING_PERCENT: u16 = 18249; -pub const CFA_REPEAT_PATTERN_DIM: u16 = 33421; -pub const CFA_PATTERN_EP: u16 = 33422; -pub const COPYRIGHT: u16 = 33432; -pub const EXPOSURE_TIME_EP: u16 = 33434; -pub const IPTC_NAA: u16 = 33723; -pub const EXIF_IFD: u16 = 34665; -pub const ICC_PROFILE: u16 = 34675; -pub const GPS_IFD: u16 = 34853; -pub const INTEROP_IFD: u16 = 40965; - -// --- Exif private IFD -pub const EXPOSURE_TIME: u16 = 33434; -pub const F_NUMBER: u16 = 33437; -pub const EXPOSURE_PROGRAM: u16 = 34850; -pub const ISO_SPEED: u16 = 34855; -pub const SENSITIVITY_TYPE: u16 = 34864; -pub const RECOMMENDED_EXPOSURE_INDEX: u16 = 34866; -pub const ISO_SPEED_RATINGS_EXT: u16 = 34867; -pub const EXIF_VERSION: u16 = 36864; -pub const DATE_TIME_ORIGINAL: u16 = 36867; -pub const DATE_TIME_DIGITIZED: u16 = 36868; -pub const OFFSET_TIME: u16 = 36880; -pub const OFFSET_TIME_ORIGINAL: u16 = 36881; -pub const OFFSET_TIME_DIGITIZED: u16 = 36882; -pub const SHUTTER_SPEED_VALUE: u16 = 37377; -pub const APERTURE_VALUE: u16 = 37378; -pub const EXPOSURE_BIAS: u16 = 37380; -pub const MAX_APERTURE: u16 = 37381; -pub const METERING_MODE: u16 = 37383; -pub const LIGHT_SOURCE: u16 = 37384; -pub const FLASH: u16 = 37385; -pub const FOCAL_LENGTH: u16 = 37386; -pub const MAKER_NOTE: u16 = 37500; -pub const USER_COMMENT: u16 = 37510; -pub const SUBSEC_TIME: u16 = 37520; -pub const SUBSEC_TIME_ORIGINAL: u16 = 37521; -pub const SUBSEC_TIME_DIGITIZED: u16 = 37522; -pub const PIXEL_X_DIMENSION: u16 = 40962; -pub const PIXEL_Y_DIMENSION: u16 = 40963; -pub const FOCAL_PLANE_X_RESOLUTION: u16 = 41486; -pub const EXPOSURE_MODE: u16 = 41986; -pub const WHITE_BALANCE: u16 = 41987; -pub const FOCAL_LENGTH_35MM: u16 = 41989; -pub const SCENE_CAPTURE_TYPE: u16 = 41990; -pub const BODY_SERIAL_NUMBER: u16 = 42033; -pub const LENS_SPECIFICATION: u16 = 42034; -pub const LENS_MAKE: u16 = 42035; -pub const LENS_MODEL: u16 = 42036; -pub const LENS_SERIAL_NUMBER: u16 = 42037; - -// --- GPS IFD -pub const GPS_VERSION_ID: u16 = 0; -pub const GPS_LATITUDE_REF: u16 = 1; -pub const GPS_LATITUDE: u16 = 2; -pub const GPS_LONGITUDE_REF: u16 = 3; -pub const GPS_LONGITUDE: u16 = 4; -pub const GPS_ALTITUDE_REF: u16 = 5; -pub const GPS_ALTITUDE: u16 = 6; -pub const GPS_TIME_STAMP: u16 = 7; -pub const GPS_IMG_DIRECTION_REF: u16 = 16; -pub const GPS_IMG_DIRECTION: u16 = 17; -pub const GPS_DATE_STAMP: u16 = 29; - -// --- DNG -pub const DNG_VERSION: u16 = 50706; -pub const DNG_BACKWARD_VERSION: u16 = 50707; -pub const UNIQUE_CAMERA_MODEL: u16 = 50708; -pub const LOCALIZED_CAMERA_MODEL: u16 = 50709; -pub const CFA_PLANE_COLOR: u16 = 50710; -pub const CFA_LAYOUT: u16 = 50711; -pub const LINEARIZATION_TABLE: u16 = 50712; -pub const BLACK_LEVEL_REPEAT_DIM: u16 = 50713; -pub const BLACK_LEVEL: u16 = 50714; -pub const BLACK_LEVEL_DELTA_H: u16 = 50715; -pub const BLACK_LEVEL_DELTA_V: u16 = 50716; -pub const WHITE_LEVEL: u16 = 50717; -pub const DEFAULT_SCALE: u16 = 50718; -pub const DEFAULT_CROP_ORIGIN: u16 = 50719; -pub const DEFAULT_CROP_SIZE: u16 = 50720; -pub const COLOR_MATRIX_1: u16 = 50721; -pub const COLOR_MATRIX_2: u16 = 50722; -pub const CAMERA_CALIBRATION_1: u16 = 50723; -pub const CAMERA_CALIBRATION_2: u16 = 50724; -pub const REDUCTION_MATRIX_1: u16 = 50725; -pub const REDUCTION_MATRIX_2: u16 = 50726; -pub const ANALOG_BALANCE: u16 = 50727; -pub const AS_SHOT_NEUTRAL: u16 = 50728; -pub const AS_SHOT_WHITE_XY: u16 = 50729; -pub const BASELINE_EXPOSURE: u16 = 50730; -pub const BASELINE_NOISE: u16 = 50731; -pub const BASELINE_SHARPNESS: u16 = 50732; -pub const BAYER_GREEN_SPLIT: u16 = 50733; -pub const LINEAR_RESPONSE_LIMIT: u16 = 50734; -pub const CAMERA_SERIAL_NUMBER: u16 = 50735; -pub const LENS_INFO: u16 = 50736; -pub const CHROMA_BLUR_RADIUS: u16 = 50737; -pub const ANTI_ALIAS_STRENGTH: u16 = 50738; -pub const SHADOW_SCALE: u16 = 50739; -pub const DNG_PRIVATE_DATA: u16 = 50740; -pub const MAKER_NOTE_SAFETY: u16 = 50741; -pub const CALIBRATION_ILLUMINANT_1: u16 = 50778; -pub const CALIBRATION_ILLUMINANT_2: u16 = 50779; -pub const BEST_QUALITY_SCALE: u16 = 50780; -pub const RAW_DATA_UNIQUE_ID: u16 = 50781; -pub const ORIGINAL_RAW_FILE_NAME: u16 = 50827; -pub const ACTIVE_AREA: u16 = 50829; -pub const MASKED_AREAS: u16 = 50830; -pub const AS_SHOT_ICC_PROFILE: u16 = 50831; -pub const COLORIMETRIC_REFERENCE: u16 = 50879; -pub const CAMERA_CALIBRATION_SIGNATURE: u16 = 50931; -pub const PROFILE_CALIBRATION_SIGNATURE: u16 = 50932; -pub const AS_SHOT_PROFILE_NAME: u16 = 50934; -pub const PROFILE_NAME: u16 = 50936; -pub const PROFILE_HUE_SAT_MAP_DIMS: u16 = 50937; -pub const PROFILE_HUE_SAT_MAP_DATA_1: u16 = 50938; -pub const PROFILE_HUE_SAT_MAP_DATA_2: u16 = 50939; -pub const PROFILE_TONE_CURVE: u16 = 50940; -pub const PROFILE_EMBED_POLICY: u16 = 50941; -pub const PROFILE_LOOK_TABLE_DIMS: u16 = 50981; -pub const PROFILE_LOOK_TABLE_DATA: u16 = 50982; -pub const PROFILE_HUE_SAT_MAP_ENCODING: u16 = 51107; -pub const PROFILE_LOOK_TABLE_ENCODING: u16 = 51108; -pub const BASELINE_EXPOSURE_OFFSET: u16 = 51109; -pub const DEFAULT_BLACK_RENDER: u16 = 51110; -pub const FORWARD_MATRIX_1: u16 = 50964; -pub const FORWARD_MATRIX_2: u16 = 50965; -pub const PREVIEW_COLOR_SPACE: u16 = 50970; -pub const CURRENT_PREVIEW_DATE_TIME: u16 = 50971; -pub const OPCODE_LIST_1: u16 = 51008; -pub const OPCODE_LIST_2: u16 = 51009; -pub const OPCODE_LIST_3: u16 = 51022; -pub const NOISE_PROFILE: u16 = 51041; -pub const DEFAULT_USER_CROP: u16 = 51125; -pub const PROFILE_GAIN_TABLE_MAP: u16 = 52525; -/// DNG 1.7 row interleave: the stored raster holds this many interleaved row groups (each group is -/// every `n`-th row of the image), so it must be un-interleaved before the data is a mosaic. -pub const ROW_INTERLEAVE_FACTOR: u16 = 50975; -/// DNG 1.7 column interleave, the column-wise counterpart of [`ROW_INTERLEAVE_FACTOR`]. -pub const COLUMN_INTERLEAVE_FACTOR: u16 = 52547; -pub const CALIBRATION_ILLUMINANT_3: u16 = 52529; -pub const CAMERA_CALIBRATION_3: u16 = 52530; -pub const COLOR_MATRIX_3: u16 = 52531; -pub const FORWARD_MATRIX_3: u16 = 52532; -pub const ILLUMINANT_DATA_1: u16 = 52533; -pub const ILLUMINANT_DATA_2: u16 = 52534; -pub const ILLUMINANT_DATA_3: u16 = 52535; -// DNG 1.6 semantic masks (spec chapter 4, "Semantic Masks") -pub const SEMANTIC_NAME: u16 = 52526; -pub const SEMANTIC_INSTANCE_ID: u16 = 52528; -pub const MASK_SUB_AREA: u16 = 52536; -/// NewSubFileType of a semantic mask IFD. -pub const SUBFILE_SEMANTIC_MASK: u32 = 0x10004; -pub const PROFILE_GAIN_TABLE_MAP_2: u16 = 52544; - -// --- Compression codes (TIFF 6.0, DNG, and widely used registrations) -pub mod compression { - pub const NONE: u16 = 1; - pub const LZW: u16 = 5; - pub const OLD_JPEG: u16 = 6; - pub const JPEG: u16 = 7; - pub const ADOBE_DEFLATE: u16 = 8; - pub const DEFLATE: u16 = 32946; - pub const PACKBITS: u16 = 32773; - /// DNG lossy JPEG (baseline DCT, 8-bit). - pub const LOSSY_JPEG: u16 = 34892; - pub const JPEG_XL: u16 = 52546; - /// SMPTE ST 2073 (VC-5) as written by GoPro's GPR files (the value measured in them). - pub const VC5: u16 = 9; - /// Nikon NEF Huffman compression. - pub const NIKON: u16 = 34713; - /// Sony ARW compressed (the value used by ARW files). - pub const SONY_ARW: u16 = 32767; -} - -// --- PhotometricInterpretation -pub mod photometric { - pub const WHITE_IS_ZERO: u16 = 0; - pub const BLACK_IS_ZERO: u16 = 1; - pub const RGB: u16 = 2; - pub const YCBCR: u16 = 6; - pub const CFA: u16 = 32803; - pub const LINEAR_RAW: u16 = 34892; - /// DNG 1.6 semantic mask. - pub const MASK: u16 = 52527; -} diff --git a/crates/tiff/src/writer.rs b/crates/tiff/src/writer.rs deleted file mode 100644 index 5732e7d060..0000000000 --- a/crates/tiff/src/writer.rs +++ /dev/null @@ -1,293 +0,0 @@ -//! TIFF writer: IFD trees with strips / tiles, `SubIFDs` and pointer IFDs (Exif, GPS, Interop, …). -//! -//! Layout: header, then for each IFD of the main chain its image chunks, child IFDs, out-of-line values -//! and finally the IFD itself (all word-aligned). Children are written before their parent so every -//! pointer is known when the parent's entries are emitted; only the chain's next-IFD pointers are patched. - -use crate::{ByteOrder, Result, TiffError, Value, tags}; -use std::collections::BTreeMap; - -/// Pixel data attached to an IFD. The writer fills in the offset / byte-count tags. -#[derive(Clone, Debug, PartialEq)] -pub enum ImageData { - /// Strips (each already compressed as the IFD's `Compression` says). Sets `RowsPerStrip`. - Strips { rows_per_strip: u32, strips: Vec> }, - /// Tiles in row-major tile order. Sets `TileWidth` / `TileLength`. - Tiles { tile_width: u32, tile_height: u32, tiles: Vec> }, -} - -/// An IFD to be written. -#[derive(Clone, Debug, Default, PartialEq)] -pub struct IfdBuilder { - pub entries: BTreeMap, - /// Written and referenced through the `SubIFDs` (330) tag. - pub sub_ifds: Vec, - /// Pointer IFDs keyed by the pointer tag (e.g. [`tags::EXIF_IFD`], [`tags::GPS_IFD`], [`tags::INTEROP_IFD`]). - pub children: BTreeMap, - pub image: Option, -} - -impl IfdBuilder { - pub fn new() -> Self { - Self::default() - } - pub fn set(&mut self, tag: u16, value: Value) -> &mut Self { - self.entries.insert(tag, value); - self - } - /// Builder-style [`IfdBuilder::set`]. - pub fn with(mut self, tag: u16, value: Value) -> Self { - self.entries.insert(tag, value); - self - } - pub fn set_child(&mut self, tag: u16, child: IfdBuilder) -> &mut Self { - self.children.insert(tag, child); - self - } - pub fn add_sub_ifd(&mut self, sub: IfdBuilder) -> &mut Self { - self.sub_ifds.push(sub); - self - } - pub fn set_image(&mut self, image: ImageData) -> &mut Self { - self.image = Some(image); - self - } -} - -/// Serialises IFD chains. -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] -pub struct TiffWriter { - pub order: ByteOrder, - pub bigtiff: bool, -} - -impl TiffWriter { - pub fn new(order: ByteOrder, bigtiff: bool) -> Self { - Self { order, bigtiff } - } - - /// Write `chain` (IFD0, IFD1, …) as a complete TIFF stream. - pub fn write(&self, chain: &[IfdBuilder]) -> Result> { - if chain.is_empty() { - return Err(TiffError::Invalid("no IFDs to write".into())); - } - let o = self.order; - let mut buf = Vec::new(); - buf.extend_from_slice(match o { - ByteOrder::Little => b"II", - ByteOrder::Big => b"MM", - }); - let mut patch = if self.bigtiff { - o.put_u16(&mut buf, 43); - o.put_u16(&mut buf, 8); - o.put_u16(&mut buf, 0); - let p = buf.len(); - o.put_u64(&mut buf, 0); - p - } else { - o.put_u16(&mut buf, 42); - let p = buf.len(); - o.put_u32(&mut buf, 0); - p - }; - for ifd in chain { - let (off, next_pos) = self.write_ifd(&mut buf, ifd, 0)?; - self.patch_offset(&mut buf, patch, off)?; - patch = next_pos; - } - Ok(buf) - } - - fn patch_offset(&self, buf: &mut [u8], pos: usize, v: u64) -> Result<()> { - let mut tmp = Vec::with_capacity(8); - if self.bigtiff { - self.order.put_u64(&mut tmp, v); - } else { - self.order.put_u32(&mut tmp, u32::try_from(v).map_err(|_| TiffError::Limit("classic TIFF larger than 4 GiB"))?); - } - buf[pos..pos + tmp.len()].copy_from_slice(&tmp); - Ok(()) - } - - fn offset_value(&self, v: Vec) -> Result { - if self.bigtiff { - Ok(Value::Long8(v)) - } else { - Ok(Value::Long( - v.into_iter().map(|x| u32::try_from(x).map_err(|_| TiffError::Limit("classic TIFF larger than 4 GiB"))).collect::>()?, - )) - } - } - - /// Writes the IFD (and everything it references); returns (IFD offset, position of its next-IFD pointer). - fn write_ifd(&self, buf: &mut Vec, ifd: &IfdBuilder, depth: usize) -> Result<(u64, usize)> { - if depth > 16 { - return Err(TiffError::Limit("IFD nesting depth")); - } - let o = self.order; - let mut entries = ifd.entries.clone(); - if let Some(img) = &ifd.image { - let chunks = match img { - ImageData::Strips { rows_per_strip, strips } => { - entries.insert(tags::ROWS_PER_STRIP, Value::Long(vec![*rows_per_strip])); - strips - } - ImageData::Tiles { tile_width, tile_height, tiles } => { - entries.insert(tags::TILE_WIDTH, Value::Long(vec![*tile_width])); - entries.insert(tags::TILE_LENGTH, Value::Long(vec![*tile_height])); - tiles - } - }; - let mut offs = Vec::with_capacity(chunks.len()); - let mut counts = Vec::with_capacity(chunks.len()); - for c in chunks { - align(buf); - offs.push(buf.len() as u64); - counts.push(c.len() as u64); - buf.extend_from_slice(c); - } - let (ot, ct) = match img { - ImageData::Strips { .. } => (tags::STRIP_OFFSETS, tags::STRIP_BYTE_COUNTS), - ImageData::Tiles { .. } => (tags::TILE_OFFSETS, tags::TILE_BYTE_COUNTS), - }; - entries.insert(ot, self.offset_value(offs)?); - entries.insert(ct, self.offset_value(counts)?); - } - if !ifd.sub_ifds.is_empty() { - let mut offs = Vec::new(); - for s in &ifd.sub_ifds { - offs.push(self.write_ifd(buf, s, depth + 1)?.0); - } - entries.insert(tags::SUB_IFDS, self.offset_value(offs)?); - } - for (&tag, child) in &ifd.children { - let off = self.write_ifd(buf, child, depth + 1)?.0; - entries.insert(tag, self.offset_value(vec![off])?); - } - let inline = if self.bigtiff { 8 } else { 4 }; - // out-of-line values - let mut encoded: Vec<(u16, &Value, Vec, Option)> = Vec::with_capacity(entries.len()); - for (&tag, v) in &entries { - let bytes = encode(o, v); - let pos = if bytes.len() > inline { - align(buf); - let p = buf.len() as u64; - buf.extend_from_slice(&bytes); - Some(p) - } else { - None - }; - encoded.push((tag, v, bytes, pos)); - } - align(buf); - let ifd_off = buf.len() as u64; - if !self.bigtiff && ifd_off > u32::MAX as u64 { - return Err(TiffError::Limit("classic TIFF larger than 4 GiB")); - } - if self.bigtiff { - o.put_u64(buf, encoded.len() as u64); - } else { - o.put_u16(buf, u16::try_from(encoded.len()).map_err(|_| TiffError::Limit("more than 65535 entries"))?); - } - for (tag, v, bytes, pos) in &encoded { - o.put_u16(buf, *tag); - o.put_u16(buf, v.field_type() as u16); - if self.bigtiff { - o.put_u64(buf, v.count() as u64); - } else { - o.put_u32(buf, u32::try_from(v.count()).map_err(|_| TiffError::Limit("value count"))?); - } - match pos { - Some(p) => { - if self.bigtiff { - o.put_u64(buf, *p); - } else { - o.put_u32(buf, u32::try_from(*p).map_err(|_| TiffError::Limit("classic TIFF larger than 4 GiB"))?); - } - } - None => { - buf.extend_from_slice(bytes); - buf.extend(std::iter::repeat_n(0u8, inline - bytes.len())); - } - } - } - let next_pos = buf.len(); - if self.bigtiff { - o.put_u64(buf, 0); - } else { - o.put_u32(buf, 0); - } - Ok((ifd_off, next_pos)) - } -} - -fn align(buf: &mut Vec) { - if buf.len() % 2 == 1 { - buf.push(0); - } -} - -/// Serialise a value's bytes in `o` order. -pub fn encode(o: ByteOrder, v: &Value) -> Vec { - let mut b = Vec::new(); - match v { - Value::Byte(x) | Value::Undefined(x) => b.extend_from_slice(x), - Value::Ascii(s) => { - b.extend_from_slice(s.as_bytes()); - b.push(0); - } - Value::SByte(x) => b.extend(x.iter().map(|&c| c as u8)), - Value::Short(x) => x.iter().for_each(|&c| o.put_u16(&mut b, c)), - Value::SShort(x) => x.iter().for_each(|&c| o.put_u16(&mut b, c as u16)), - Value::Long(x) | Value::Ifd(x) => x.iter().for_each(|&c| o.put_u32(&mut b, c)), - Value::SLong(x) => x.iter().for_each(|&c| o.put_u32(&mut b, c as u32)), - Value::Float(x) => x.iter().for_each(|&c| o.put_u32(&mut b, c.to_bits())), - Value::Rational(x) => x.iter().for_each(|&(n, d)| { - o.put_u32(&mut b, n); - o.put_u32(&mut b, d); - }), - Value::SRational(x) => x.iter().for_each(|&(n, d)| { - o.put_u32(&mut b, n as u32); - o.put_u32(&mut b, d as u32); - }), - Value::Double(x) => x.iter().for_each(|&c| o.put_u64(&mut b, c.to_bits())), - Value::Long8(x) | Value::Ifd8(x) => x.iter().for_each(|&c| o.put_u64(&mut b, c)), - Value::SLong8(x) => x.iter().for_each(|&c| o.put_u64(&mut b, c as u64)), - } - b -} - -/// Convenience: approximate `v` by an unsigned rational with denominator up to 1e6 (for writing Exif rationals). -pub fn rational(v: f64) -> (u32, u32) { - if !v.is_finite() || v <= 0.0 { - return (0, 1); - } - for d in [1u32, 10, 100, 1000, 10_000, 100_000, 1_000_000] { - let n = v * d as f64; - if n > u32::MAX as f64 { - return ((v * (d / 10).max(1) as f64).round().min(u32::MAX as f64) as u32, (d / 10).max(1)); - } - if (n - n.round()).abs() < 1e-9 * d as f64 || d == 1_000_000 { - return (n.round() as u32, d); - } - } - (0, 1) -} - -/// Signed variant of [`rational`]. -pub fn srational(v: f64) -> (i32, i32) { - if !v.is_finite() { - return (0, 1); - } - for d in [1i32, 10, 100, 1000, 10_000, 100_000, 1_000_000] { - let n = v * d as f64; - if n.abs() > i32::MAX as f64 { - let d = (d / 10).max(1); - return ((v * d as f64).round().clamp(i32::MIN as f64, i32::MAX as f64) as i32, d); - } - if (n - n.round()).abs() < 1e-9 * d as f64 || d == 1_000_000 { - return (n.round() as i32, d); - } - } - (0, 1) -} diff --git a/crates/tiff/tests/it/main.rs b/crates/tiff/tests/it/main.rs deleted file mode 100644 index e415ed5377..0000000000 --- a/crates/tiff/tests/it/main.rs +++ /dev/null @@ -1,3 +0,0 @@ -//! The integration tests, one module per file, linked into one test binary. - -mod roundtrip; diff --git a/crates/tiff/tests/it/roundtrip.rs b/crates/tiff/tests/it/roundtrip.rs deleted file mode 100644 index 3b9a1bd1cf..0000000000 --- a/crates/tiff/tests/it/roundtrip.rs +++ /dev/null @@ -1,429 +0,0 @@ -use lightcraft_tiff::image::{Layout, chunk_bytes}; -use lightcraft_tiff::writer::{rational, srational}; -use lightcraft_tiff::{ByteOrder, FieldType, IfdBuilder, ImageData, ParseOptions, Tiff, TiffError, TiffWriter, Value, parse_ifd_at, tags}; -use proptest::prelude::*; - -const ORDERS: [ByteOrder; 2] = [ByteOrder::Little, ByteOrder::Big]; - -fn all_values() -> Vec<(u16, Value)> { - vec![ - (1000, Value::Byte(vec![1, 2, 3, 255])), - (1001, Value::Ascii("hello tiff".into())), - (1002, Value::Short(vec![1, 65535, 3])), - (1003, Value::Long(vec![7])), - (1004, Value::Rational(vec![(1, 3), (22, 7)])), - (1005, Value::SByte(vec![-1, 0, 127, -128])), - (1006, Value::Undefined(vec![9; 17])), - (1007, Value::SShort(vec![-32768, 32767])), - (1008, Value::SLong(vec![-5, i32::MAX])), - (1009, Value::SRational(vec![(-1, 3), (5, -2)])), - (1010, Value::Float(vec![1.5, -0.25, f32::MAX])), - (1011, Value::Double(vec![std::f64::consts::PI])), - (1012, Value::Ifd(vec![0])), - (1013, Value::Short(vec![42])), - (1014, Value::Ascii(String::new())), - ] -} - -fn big_values() -> Vec<(u16, Value)> { - vec![(1020, Value::Long8(vec![1 << 40, 3])), (1021, Value::SLong8(vec![-(1 << 50)])), (1022, Value::Ifd8(vec![0]))] -} - -#[test] -fn all_field_types_roundtrip_every_variant() { - for order in ORDERS { - for big in [false, true] { - let mut ifd = IfdBuilder::new(); - for (t, v) in all_values() { - ifd.set(t, v); - } - if big { - for (t, v) in big_values() { - ifd.set(t, v); - } - } - let bytes = TiffWriter::new(order, big).write(&[ifd]).unwrap(); - let t = Tiff::parse(&bytes).unwrap(); - assert_eq!(t.order, order); - assert_eq!(t.bigtiff, big); - assert_eq!(Tiff::sniff(&bytes), Some((order, big))); - let ifd0 = &t.ifds[0]; - for (tag, v) in all_values().into_iter().chain(if big { big_values() } else { vec![] }) { - assert_eq!(ifd0.value(tag), Some(&v), "tag {tag} order {order:?} big {big}"); - } - } - } -} - -#[test] -fn accessors() { - let mut ifd = IfdBuilder::new(); - ifd.set(1, Value::Rational(vec![(28, 10), (0, 0)])); - ifd.set(2, Value::Short(vec![5, 6])); - ifd.set(3, Value::SLong(vec![-3])); - ifd.set(4, Value::Ascii("Canon ".into())); - ifd.set(5, Value::Byte(b"\0junk".to_vec())); - let bytes = TiffWriter::default().write(&[ifd]).unwrap(); - let t = Tiff::parse(&bytes).unwrap(); - let i = &t.ifds[0]; - assert_eq!(i.f64(1), Some(2.8)); - assert_eq!(i.f64s(1).unwrap(), vec![2.8, 0.0]); - assert_eq!(i.u32(2), Some(5)); - assert_eq!(i.u64s(2).unwrap(), vec![5, 6]); - assert_eq!(i.u32(3), None); - assert_eq!(i.i64(3), Some(-3)); - assert_eq!(i.string(4).as_deref(), Some("Canon")); - assert_eq!(i.string(5).as_deref(), Some("")); - assert_eq!(i.get(4).unwrap().field_type(), FieldType::Ascii); - assert!(i.u32(999).is_none()); - assert_eq!(t.find(2).map(|e| e.tag), Some(2)); -} - -#[test] -fn chain_subifds_and_pointer_ifds() { - for order in ORDERS { - for big in [false, true] { - let mut interop = IfdBuilder::new(); - interop.set(1, Value::Ascii("R98".into())); - let mut exif = IfdBuilder::new(); - exif.set(tags::F_NUMBER, Value::Rational(vec![(56, 10)])); - exif.set_child(tags::INTEROP_IFD, interop); - let mut gps = IfdBuilder::new(); - gps.set(tags::GPS_LATITUDE_REF, Value::Ascii("N".into())); - let mut ifd0 = IfdBuilder::new(); - ifd0.set(tags::MAKE, Value::Ascii("Maker".into())); - ifd0.set_child(tags::EXIF_IFD, exif); - ifd0.set_child(tags::GPS_IFD, gps); - let mut raw = IfdBuilder::new(); - raw.set(tags::IMAGE_WIDTH, Value::Long(vec![4])); - let mut nested = IfdBuilder::new(); - nested.set(tags::IMAGE_WIDTH, Value::Long(vec![2])); - raw.add_sub_ifd(nested); - ifd0.add_sub_ifd(raw); - ifd0.add_sub_ifd(IfdBuilder::new().with(tags::IMAGE_WIDTH, Value::Short(vec![3]))); - let ifd1 = IfdBuilder::new().with(tags::IMAGE_WIDTH, Value::Short(vec![160])); - let ifd2 = IfdBuilder::new().with(tags::IMAGE_WIDTH, Value::Short(vec![80])); - let bytes = TiffWriter::new(order, big).write(&[ifd0, ifd1, ifd2]).unwrap(); - let t = Tiff::parse(&bytes).unwrap(); - assert_eq!(t.ifds.len(), 3); - assert_eq!(t.ifds[1].u32(tags::IMAGE_WIDTH), Some(160)); - assert_eq!(t.ifds[2].u32(tags::IMAGE_WIDTH), Some(80)); - let i0 = &t.ifds[0]; - assert_eq!(i0.sub_ifds.len(), 2); - assert_eq!(i0.sub_ifds[0].u32(tags::IMAGE_WIDTH), Some(4)); - assert_eq!(i0.sub_ifds[0].sub_ifds[0].u32(tags::IMAGE_WIDTH), Some(2)); - assert_eq!(i0.sub_ifds[1].u32(tags::IMAGE_WIDTH), Some(3)); - let exif = t.exif().unwrap(); - assert_eq!(exif.f64(tags::F_NUMBER), Some(5.6)); - assert_eq!(exif.interop.as_ref().unwrap().string(1).as_deref(), Some("R98")); - assert_eq!(t.gps().unwrap().string(tags::GPS_LATITUDE_REF).as_deref(), Some("N")); - // IFD0, sub0, sub0.sub, sub1, exif, interop, gps, ifd1, ifd2 - assert_eq!(t.all_ifds().len(), 9); - } - } -} - -fn gradient(w: usize, h: usize) -> Vec { - (0..w * h).map(|i| (i * 7 % 251) as u8).collect() -} - -#[test] -fn strips_layout_and_bytes() { - let (w, h) = (10usize, 7usize); - let px = gradient(w, h); - let rps = 3; - let strips: Vec> = px.chunks(w * rps).map(|c| c.to_vec()).collect(); - let mut ifd = IfdBuilder::new(); - ifd.set(tags::IMAGE_WIDTH, Value::Long(vec![w as u32])); - ifd.set(tags::IMAGE_LENGTH, Value::Long(vec![h as u32])); - ifd.set(tags::BITS_PER_SAMPLE, Value::Short(vec![8])); - ifd.set(tags::COMPRESSION, Value::Short(vec![1])); - ifd.set_image(ImageData::Strips { rows_per_strip: rps as u32, strips }); - for order in ORDERS { - for big in [false, true] { - let bytes = TiffWriter::new(order, big).write(std::slice::from_ref(&ifd)).unwrap(); - let t = Tiff::parse(&bytes).unwrap(); - let info = t.ifds[0].image().unwrap(); - assert_eq!(info.layout, Layout::Strips { rows_per_strip: 3 }); - assert_eq!(info.grid(), (1, 3)); - let chunks = info.chunks(bytes.len() as u64); - assert_eq!(chunks.len(), 3); - assert_eq!(chunks[2].height, 1); - let mut out = Vec::new(); - for c in &chunks { - out.extend_from_slice(chunk_bytes(&bytes, c).unwrap()); - } - assert_eq!(out, px); - } - } -} - -#[test] -fn tiles_layout_and_bytes() { - let (w, h, tw, th) = (20usize, 13usize, 16usize, 8usize); - let px = gradient(w, h); - let (ta, td) = (w.div_ceil(tw), h.div_ceil(th)); - let mut tiles = Vec::new(); - for ty in 0..td { - for tx in 0..ta { - let mut t = vec![0u8; tw * th]; - for y in 0..th { - for x in 0..tw { - let (sx, sy) = (tx * tw + x, ty * th + y); - if sx < w && sy < h { - t[y * tw + x] = px[sy * w + sx]; - } - } - } - tiles.push(t); - } - } - let mut ifd = IfdBuilder::new(); - ifd.set(tags::IMAGE_WIDTH, Value::Short(vec![w as u16])); - ifd.set(tags::IMAGE_LENGTH, Value::Short(vec![h as u16])); - ifd.set_image(ImageData::Tiles { tile_width: tw as u32, tile_height: th as u32, tiles }); - let bytes = TiffWriter::new(ByteOrder::Big, false).write(&[ifd]).unwrap(); - let t = Tiff::parse(&bytes).unwrap(); - let info = t.ifds[0].image().unwrap(); - assert_eq!(info.grid(), (2, 2)); - let chunks = info.chunks(bytes.len() as u64); - assert_eq!(chunks.len(), 4); - let mut out = vec![0u8; w * h]; - for c in &chunks { - let b = chunk_bytes(&bytes, c).unwrap(); - for y in 0..c.height as usize { - for x in 0..c.width as usize { - let (sx, sy) = (c.x as usize + x, c.y as usize + y); - if sx < w && sy < h { - out[sy * w + sx] = b[y * tw + x]; - } - } - } - } - assert_eq!(out, px); -} - -#[test] -fn missing_byte_counts_are_inferred() { - let mut ifd = IfdBuilder::new(); - ifd.set(tags::IMAGE_WIDTH, Value::Long(vec![4])); - ifd.set(tags::IMAGE_LENGTH, Value::Long(vec![2])); - ifd.set_image(ImageData::Strips { rows_per_strip: 1, strips: vec![vec![1; 4], vec![2; 4]] }); - let bytes = TiffWriter::default().write(&[ifd]).unwrap(); - let t = Tiff::parse(&bytes).unwrap(); - let mut info = t.ifds[0].image().unwrap(); - info.byte_counts.clear(); - let c = info.chunks(bytes.len() as u64); - assert_eq!(c[0].len, 4); - assert_eq!(&chunk_bytes(&bytes, &c[0]).unwrap()[..4], &[1; 4]); - assert!(c[1].len >= 4); -} - -#[test] -fn bad_headers() { - assert_eq!(Tiff::parse(b""), Err(TiffError::NotTiff)); - assert_eq!(Tiff::parse(b"XX*\0\0\0\0\0"), Err(TiffError::NotTiff)); - assert_eq!(Tiff::parse(b"II\x2b\0\x04\0\0\0"), Err(TiffError::NotTiff)); - assert!(Tiff::parse(b"II*\0").is_err()); - assert!(Tiff::parse(b"II*\0\x08\0\0\0").is_err()); - assert!(Tiff::parse(b"II*\0\x08\0\0\0\0\0").is_err()); - assert!(Tiff::sniff(b"MM\0*\0\0\0\x08").is_some()); -} - -#[test] -fn ifd_loops_are_detected() { - // IFD0 at 8 whose next pointer points back to itself, and whose SubIFDs point to itself too. - let mut b = b"II*\0\x08\0\0\0".to_vec(); - b.extend_from_slice(&1u16.to_le_bytes()); - b.extend_from_slice(&330u16.to_le_bytes()); - b.extend_from_slice(&4u16.to_le_bytes()); - b.extend_from_slice(&1u32.to_le_bytes()); - b.extend_from_slice(&8u32.to_le_bytes()); - b.extend_from_slice(&8u32.to_le_bytes()); - let t = Tiff::parse(&b).unwrap(); - assert_eq!(t.ifds.len(), 1); - assert!(t.ifds[0].sub_ifds.is_empty()); -} - -#[test] -fn out_of_range_entries_are_skipped() { - let mut ifd = IfdBuilder::new(); - ifd.set(1, Value::Long(vec![1, 2, 3])); - ifd.set(2, Value::Short(vec![5])); - let mut bytes = TiffWriter::default().write(&[ifd]).unwrap(); - let t = Tiff::parse(&bytes).unwrap(); - let e = t.ifds[0].get(1).unwrap().clone(); - // point tag 1's value offset past EOF - let ifd_off = t.ifds[0].offset as usize; - let field = ifd_off + 2 + 8; - assert_eq!(u32::from_le_bytes(bytes[field..field + 4].try_into().unwrap()) as u64, e.offset); - bytes[field..field + 4].copy_from_slice(&0xffff_fff0u32.to_le_bytes()); - let t = Tiff::parse(&bytes).unwrap(); - assert!(t.ifds[0].get(1).is_none()); - assert_eq!(t.ifds[0].u32(2), Some(5)); -} - -#[test] -fn value_budget_limits_allocation() { - // 50 entries all pointing at the same 1000-byte blob. - let mut ifd = IfdBuilder::new(); - ifd.set(1, Value::Undefined(vec![7; 1000])); - let bytes = TiffWriter::default().write(&[ifd]).unwrap(); - let t = Tiff::parse(&bytes).unwrap(); - let blob = t.ifds[0].get(1).unwrap().offset as u32; - let mut b = b"II*\0".to_vec(); - b.extend_from_slice(&(bytes.len() as u32).to_le_bytes()); - let mut file = bytes.clone(); - file[..8].copy_from_slice(&b); - file.extend_from_slice(&50u16.to_le_bytes()); - for i in 0..50u16 { - file.extend_from_slice(&i.to_le_bytes()); - file.extend_from_slice(&7u16.to_le_bytes()); - file.extend_from_slice(&1000u32.to_le_bytes()); - file.extend_from_slice(&blob.to_le_bytes()); - } - file.extend_from_slice(&0u32.to_le_bytes()); - let opts = ParseOptions { value_budget: Some(10_000), ..Default::default() }; - let t = Tiff::parse_with(&file, &opts).unwrap(); - assert_eq!(t.ifds[0].entries.len(), 10); - let t = Tiff::parse(&file).unwrap(); - assert_eq!(t.ifds[0].entries.len(), 50); -} - -#[test] -fn parse_ifd_with_base() { - // an IFD blob embedded at 100 whose offsets are relative to 100 - let mut blob = Vec::new(); - let o = ByteOrder::Big; - o.put_u16(&mut blob, 1); - o.put_u16(&mut blob, 5); - o.put_u16(&mut blob, 4); - o.put_u32(&mut blob, 3); - o.put_u32(&mut blob, 18); - o.put_u32(&mut blob, 0); - for v in [10u32, 20, 30] { - o.put_u32(&mut blob, v); - } - let mut data = vec![0u8; 100]; - data.extend(blob); - let (ifd, next) = parse_ifd_at(&data, 100, o, 100, false, &ParseOptions::default()).unwrap(); - assert_eq!(next, 0); - assert_eq!(ifd.u64s(5).unwrap(), vec![10, 20, 30]); - assert_eq!(ifd.get(5).unwrap().offset, 118); -} - -#[test] -fn rationals() { - assert_eq!(rational(2.8), (28, 10)); - assert_eq!(rational(0.004), (4, 1000)); - assert_eq!(rational(-1.0), (0, 1)); - assert_eq!(srational(-0.333), (-333, 1000)); - assert_eq!(srational(7.0), (7, 1)); - let (n, d) = rational(1.0 / 3.0); - assert!((n as f64 / d as f64 - 1.0 / 3.0).abs() < 1e-6); -} - -fn sample_file() -> Vec { - let mut exif = IfdBuilder::new(); - exif.set(tags::F_NUMBER, Value::Rational(vec![(4, 1)])); - exif.set(tags::MAKER_NOTE, Value::Undefined(b"Nikon\0\x02\x10\0\0II*\0\x08\0\0\0\x01\0\x01\0\x03\0\x01\0\0\0\x05\0\0\0\0\0\0\0".to_vec())); - let mut ifd0 = IfdBuilder::new(); - ifd0.set(tags::IMAGE_WIDTH, Value::Long(vec![8])); - ifd0.set(tags::IMAGE_LENGTH, Value::Long(vec![4])); - ifd0.set(tags::MAKE, Value::Ascii("NIKON".into())); - ifd0.set_child(tags::EXIF_IFD, exif); - ifd0.set_image(ImageData::Strips { rows_per_strip: 2, strips: vec![vec![1; 16], vec![2; 16]] }); - ifd0.add_sub_ifd(IfdBuilder::new().with(tags::IMAGE_WIDTH, Value::Long(vec![2]))); - TiffWriter::default().write(&[ifd0, IfdBuilder::new().with(1, Value::Short(vec![1]))]).unwrap() -} - -fn exercise(t: &Tiff, data: &[u8]) { - for ifd in t.all_ifds() { - if let Ok(info) = ifd.image() { - for c in info.chunks(data.len() as u64).iter().take(64) { - let _ = chunk_bytes(data, c); - } - } - for e in &ifd.entries { - let _ = e.value.to_f64_vec(); - let _ = e.value.as_str(); - } - } - if let Some(e) = t.exif().and_then(|x| x.get(tags::MAKER_NOTE)) { - let _ = lightcraft_tiff::makernote::parse_makernote(data, e.offset, e.count() as u64, t.order, "NIKON"); - } -} - -proptest! { - #![proptest_config(ProptestConfig { cases: 2000, .. ProptestConfig::default() })] - - #[test] - fn random_bytes_never_panic(mut data in proptest::collection::vec(any::(), 0..512), hdr in 0usize..4) { - let heads: [&[u8]; 4] = [b"II*\0", b"MM\0*", b"II+\0\x08\0\0\0", b"MM\0+\0\x08\0\0"]; - let h = heads[hdr]; - if data.len() >= h.len() { - data[..h.len()].copy_from_slice(h); - } - if let Ok(t) = Tiff::parse(&data) { - exercise(&t, &data); - } - } - - #[test] - fn mutated_files_never_panic(flips in proptest::collection::vec((any::(), any::()), 1..16), cut in any::()) { - let mut data = sample_file(); - for (i, v) in flips { - let n = data.len(); - data[i % n] = v; - } - let keep = if cut % 4 == 0 { cut % data.len() } else { data.len() }; - let data = &data[..keep]; - if let Ok(t) = Tiff::parse(data) { - exercise(&t, data); - } - } - - #[test] - fn random_short_arrays_roundtrip(v in proptest::collection::vec(any::(), 1..300), big in any::(), le in any::()) { - let order = if le { ByteOrder::Little } else { ByteOrder::Big }; - let ifd = IfdBuilder::new().with(500, Value::Short(v.clone())).with(501, Value::Double(v.iter().map(|&x| x as f64 / 3.0).collect())); - let bytes = TiffWriter::new(order, big).write(&[ifd]).unwrap(); - let t = Tiff::parse(&bytes).unwrap(); - prop_assert_eq!(t.ifds[0].value(500), Some(&Value::Short(v.clone()))); - prop_assert_eq!(t.ifds[0].f64s(501).unwrap().len(), v.len()); - } -} - -/// A BigTIFF whose IFD says it has an enormous number of entries, with one readable, computed where the next-IFD -/// offset would be from the advertised count: an add overflow, a panic in builds with overflow checks (issue -/// #1516). The readable entry is kept and there is no next IFD; complete chains still link. -#[test] -fn bigtiff_with_an_enormous_entry_count_does_not_panic() { - for order in ORDERS { - for count in [u64::MAX, 1 << 62, 2] { - // little-endian bytes, reversed for big-endian files - let e = |le: &[u8]| -> Vec { if order == ByteOrder::Little { le.to_vec() } else { le.iter().rev().copied().collect() } }; - let mut f = if order == ByteOrder::Little { b"II".to_vec() } else { b"MM".to_vec() }; - for part in [e(&43u16.to_le_bytes()), e(&8u16.to_le_bytes()), e(&0u16.to_le_bytes()), e(&16u64.to_le_bytes()), e(&count.to_le_bytes())] { - f.extend(part); - } - // one entry: ImageWidth, LONG, 1 value (inline in the 8-byte field) - for part in [e(&tags::IMAGE_WIDTH.to_le_bytes()), e(&4u16.to_le_bytes()), e(&1u64.to_le_bytes()), e(&640u32.to_le_bytes())] { - f.extend(part); - } - f.extend([0; 4]); - let (ifd, next) = parse_ifd_at(&f, 16, order, 0, true, &ParseOptions::default()).unwrap(); - assert_eq!(ifd.value(tags::IMAGE_WIDTH), Some(&Value::Long(vec![640])), "{order:?} {count}"); - assert_eq!(next, 0, "{order:?} {count}"); - let t = Tiff::parse(&f).unwrap(); - assert_eq!(t.ifds.len(), 1); - } - // a complete chain of two IFDs still links - let mut a = IfdBuilder::new(); - a.set(1000, Value::Short(vec![1])); - let mut b = IfdBuilder::new(); - b.set(1000, Value::Short(vec![2])); - let t = Tiff::parse(&TiffWriter::new(order, true).write(&[a, b]).unwrap()).unwrap(); - assert_eq!(t.ifds.len(), 2, "{order:?}"); - } -} diff --git a/xtask/src/layers.rs b/xtask/src/layers.rs index 70597bffbd..db515980bc 100644 --- a/xtask/src/layers.rs +++ b/xtask/src/layers.rs @@ -37,7 +37,6 @@ pub const TABLE: &[(&str, Class)] = &[ ("geom", Class::Layer(0)), ("color", Class::Layer(0)), ("raster", Class::Layer(0)), - ("tiff", Class::Layer(0)), ("sysmem", Class::Layer(0)), ("wincolor", Class::Layer(0)), ("fetch", Class::Layer(0)), @@ -78,7 +77,6 @@ pub const TABLE: &[(&str, Class)] = &[ /// L1: `raw` and `codecs` read metadata through `meta`; `develop` uses `meta` for XMP. pub const INTRA_LAYER_ORDER: &[&[&str]] = &[ &["geom", "color", "raster"], - &["tiff", "raster"], &["denoise-core", "denoise"], &["meta", "raw"], &["meta", "codecs"],