Use craft-tiff from craft-libs for TIFF/IFD (#4088)

* Use craft-tiff from craft-libs; remove crates/tiff

lightcraft-tiff moved to craft-libs unchanged as craft-tiff
(storytold/craft-libs#783), the first step of sharing RAW support with
PhotoCraft (storytold/craft-libs#587). The layer table drops tiff and its
intra-layer ordering before raster.

* Pin craft-tiff to the merge of storytold/craft-libs#795
This commit is contained in:
Dylan M. Taylor authored and GitHub committed 2026-11-11 19:51:47 -05:00
1 parent 5b61ce1e1a
commit c5d60d2fa7
77 files changed
+278 -2780

No files matched your search

Generated
+12 -12
View File
@@ -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"
+2 -1
View File
@@ -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" }
+1 -1
View File
@@ -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 |
+1 -1
View File
@@ -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<Vec<u8>> {
use tiff::encoder::{Compression, DeflateLevel, TiffEncoder};
use tiff::tags::Predictor;
+1 -1
View File
@@ -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 }
+13 -13
View File
@@ -281,7 +281,7 @@ fn tiff_with_preview_strip(strip: &[u8], tail: usize, what: Fixture) -> Vec<u8>
/// [`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<u8> {
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<u8>| {
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<u8> {
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<u8> = (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<u8> {
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();
+1 -1
View File
@@ -46,7 +46,7 @@ fn jpeg(w: u32, h: u32, px: impl Fn(u32, u32) -> [u8; 3]) -> Vec<u8> {
/// 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<u8> {
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<u8>, first: bool| {
let mut ifd = IfdBuilder::new();
if first {
+2 -2
View File
@@ -34,7 +34,7 @@ fn write_png(path: &Path, seed: u8) {
}
fn exif_clock_block(original: Option<&str>, digitized: Option<&str>) -> Vec<u8> {
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();
+2 -2
View File
@@ -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<u16> = (0..16 * 6).map(|i| (i * 41 % 4096) as u16).collect();
let strip: Vec<u8> = 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]));
+1 -1
View File
@@ -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 }
+4 -4
View File
@@ -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<u8> {
let mut v = vec![0xff, marker];
+7 -7
View File
@@ -436,13 +436,13 @@ fn le32(b: &[u8], at: usize) -> Option<u32> {
/// 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<Vec<u8>> {
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<u8> {
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<u8> {
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<u8> {
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]| {
+13 -13
View File
@@ -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<String> {
}
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<String> {
}
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<String> {
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<u8> {
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<f64>) -> Option<lightcraft_tiff::Value> {
/// 1/12800 s, which [`craft_tiff::writer::rational`]'s decimal denominators cannot represent).
fn reciprocal(v: Option<f64>) -> Option<craft_tiff::Value> {
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<u8> {
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<String>| s.as_ref().filter(|v| !v.is_empty()).map(|v| Value::Ascii(v.clone()));
let mut ifd0 = IfdBuilder::new();
for (tag, v) in [
+1 -1
View File
@@ -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.
+2 -2
View File
@@ -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<u8> = 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);
+3 -4
View File
@@ -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<u8>) -> io::Result<Option<FocusPoint>> {
// 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() };
+1 -1
View File
@@ -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<u8> {
+15 -15
View File
@@ -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);
}
+3 -3
View File
@@ -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());
}
+3 -3
View File
@@ -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");
+2 -2
View File
@@ -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}")
}
+1 -1
View File
@@ -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 }
+1 -1
View File
@@ -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;
+1 -1
View File
@@ -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<String> = std::env::args().skip(1).collect();
+3 -3
View File
@@ -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<DcpProfile, DcpError> {
/// 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<Vec<u8>, 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()));
+3 -3
View File
@@ -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,
}
+3 -3
View File
@@ -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)]
+1 -1
View File
@@ -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).
+23 -23
View File
@@ -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<RawFormat> {
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<RawFormat> {
}
// 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<ThumbnailShell> {
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<ThumbnailShell> {
/// 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})");
+5 -5
View File
@@ -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<usize> {
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<u32>) -> Option<Vec<u8>> {
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);
}
+4 -5
View File
@@ -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<u8> {
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<u16>, note: Option<u16>) -> Vec<u8> {
let block = |tag: u16, v: Option<u16>| {
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));
+3 -3
View File
@@ -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<SemanticMask> {
.collect()
}
fn read_mask(bytes: &[u8], tiff: &Tiff, ifd: &lightcraft_tiff::Ifd) -> Result<Option<SemanticMask>> {
fn read_mask(bytes: &[u8], tiff: &Tiff, ifd: &craft_tiff::Ifd) -> Result<Option<SemanticMask>> {
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);
+3 -3
View File
@@ -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.
+2 -2
View File
@@ -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(_))));
+3 -3
View File
@@ -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.
+1 -1
View File
@@ -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]) {
+2 -2
View File
@@ -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`.
+27 -27
View File
@@ -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<u8> = 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<Rect> {
}
/// 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<f32> {
fn sr2_black_levels(plain: &[u8], order: craft_tiff::ByteOrder) -> Option<f32> {
let levels: Vec<u16> = (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::<f32>() / 4.0)
@@ -532,8 +532,8 @@ fn sr2_black_levels(plain: &[u8], order: lightcraft_tiff::ByteOrder) -> Option<f
/// Byte order of 16-bit-word samples: the file's own order unless the words only fit the sample width in the other
/// (see the DSC-R1 note at the top). Sampled across the strip; the order is swapped only when the file order leaves
/// more than 1 % of the sampled words at or above `1 << max(bits, 14)` while the other order leaves none.
fn word16_order(strip: &[u8], bits: u32, file: lightcraft_tiff::ByteOrder) -> 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<u8> {
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<u8>) -> Vec<u8> {
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<u16>) -> Vec<u8> {
use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value};
fn sony_file(order: craft_tiff::ByteOrder, make: &str, entries: &[(u16, u16, u32, [u8; 4])], count: Option<u16>) -> Vec<u8> {
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<u8> {
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<u16>| {
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<u8> { 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<f32> {
fn sr2_black_in(block: &[u8], start: usize, order: craft_tiff::ByteOrder) -> Option<f32> {
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<u8> = (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<u8> = (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();
+3 -3
View File
@@ -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);
+2 -2
View File
@@ -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 {
+3 -3
View File
@@ -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];
+2 -2
View File
@@ -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];
+5 -5
View File
@@ -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<RawImage> {
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<RawImage> {
#[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<u8>, Vec<u16>) {
+4 -4
View File
@@ -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<f32> {
/// 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<RawImage> {
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;
+6 -6
View File
@@ -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<RawImage> {
#[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<u8> {
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 };
+6 -6
View File
@@ -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<Ifd> {
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<RawImage> {
#[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<u8> {
@@ -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]
+3 -3
View File
@@ -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)];
+5 -5
View File
@@ -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<RawImage> {
/// The vendor IFD (`KodakIFD`): a plain IFD with absolute value offsets.
fn kodak_ifd(bytes: &[u8], tiff: &Tiff, ifd0: &Ifd) -> Option<Ifd> {
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;
+3 -3
View File
@@ -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<RawImage> {
#[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<u8> {
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()
+6 -6
View File
@@ -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<RawImage> {
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);
+9 -9
View File
@@ -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<RawData> {
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<lightcraft_tiff::image::Chunk> {
fn small_raw_strip(info: &ImageInfo, file_len: usize, mn: Option<&makernote::MakerNote>) -> Option<craft_tiff::image::Chunk> {
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<RawImage> {
fn small_raw(bytes: &[u8], tiff: &Tiff, info: &ImageInfo, strip: craft_tiff::image::Chunk, mode: Mode) -> Result<RawImage> {
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<Vec<u8>>, w: u32, h: u32, rps: u32) -> Vec<u8> {
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());
+3 -3
View File
@@ -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<f64> {
/// 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 };
+3 -3
View File
@@ -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<u8>, w: u32, h: u32, bits: u16, table: Vec<u8>, mn_order: ByteOrder) -> Vec<u8> {
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();
+6 -6
View File
@@ -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<Ifd> {
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<u8>) -> Vec<u8> {
orf_with(w, h, bits, strip, None)
+4 -4
View File
@@ -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<u8> {
use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value};
use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value};
let (w, h) = (16usize, 8usize);
let px: Vec<u16> = (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<u8> {
use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value};
use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value};
let strip: Vec<u8> = (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();
+2 -2
View File
@@ -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<Ifd> {
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)
}
+2 -2
View File
@@ -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<Opcode> {
#[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.
+2 -2
View File
@@ -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<Opcode> {
#[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 {
+5 -5
View File
@@ -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));
+6 -6
View File
@@ -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<u16> = 32769..=32773;
/// The maker-note IFD (offsets relative to the note's own start).
fn maker_note(bytes: &[u8], tiff: &Tiff) -> Option<Ifd> {
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.
+1 -1
View File
@@ -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);
+3 -3
View File
@@ -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)] {
+4 -4
View File
@@ -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();
+1 -1
View File
@@ -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<u8> {
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()));
+2 -2
View File
@@ -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;
+1 -1
View File
@@ -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;
-16
View File
@@ -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 }
-45
View File
@@ -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.
-248
View File
@@ -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<u16>,
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<u64>,
pub byte_counts: Vec<u64>,
}
/// 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<ImageInfo> {
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<u16> =
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<Chunk> {
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<Chunk> {
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<u64> = 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<u64>, byte_counts: Vec<u64>) -> 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<u64> = 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::<Vec<u64>>());
});
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));
}
}
-468
View File
@@ -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<T> = std::result::Result<T, TiffError>;
/// 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<u16> {
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<u32> {
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<u64> {
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<u8>, 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<u8>, 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<u8>, 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<FieldType> {
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<u8>),
/// ASCII text (bytes up to the first NUL, decoded lossily as UTF-8).
Ascii(String),
Short(Vec<u16>),
Long(Vec<u32>),
Rational(Vec<(u32, u32)>),
SByte(Vec<i8>),
Undefined(Vec<u8>),
SShort(Vec<i16>),
SLong(Vec<i32>),
SRational(Vec<(i32, i32)>),
Float(Vec<f32>),
Double(Vec<f64>),
Ifd(Vec<u32>),
Long8(Vec<u64>),
SLong8(Vec<i64>),
Ifd8(Vec<u64>),
}
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<f64> {
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<u64> {
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<i64> {
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<f64> {
(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<u64> {
(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<String> {
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<Entry>,
/// IFDs referenced by `SubIFDs` (330).
pub sub_ifds: Vec<Ifd>,
/// Exif private IFD (34665).
pub exif: Option<Box<Ifd>>,
/// GPS IFD (34853).
pub gps: Option<Box<Ifd>>,
/// Interoperability IFD (40965).
pub interop: Option<Box<Ifd>>,
}
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<u32> {
self.value(tag)?.get_u64(0).map(|v| v.min(u32::MAX as u64) as u32)
}
pub fn u64(&self, tag: u16) -> Option<u64> {
self.value(tag)?.get_u64(0)
}
pub fn u16(&self, tag: u16) -> Option<u16> {
self.value(tag)?.get_u64(0).map(|v| v.min(u16::MAX as u64) as u16)
}
pub fn i64(&self, tag: u16) -> Option<i64> {
self.value(tag)?.get_i64(0)
}
pub fn f64(&self, tag: u16) -> Option<f64> {
self.value(tag)?.get_f64(0)
}
pub fn f64s(&self, tag: u16) -> Option<Vec<f64>> {
self.value(tag).map(|v| v.to_f64_vec())
}
pub fn u64s(&self, tag: u16) -> Option<Vec<u64>> {
self.value(tag).map(|v| v.to_u64_vec())
}
/// Text value (ASCII, or UTF-8 bytes).
pub fn string(&self, tag: u16) -> Option<String> {
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> {
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<Ifd>,
}
impl Tiff {
/// Parse a TIFF stream (the header must be at offset 0 of `data`).
pub fn parse(data: &[u8]) -> Result<Tiff> {
reader::parse(data, &ParseOptions::default())
}
pub fn parse_with(data: &[u8], opts: &ParseOptions) -> Result<Tiff> {
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))
}
}
-235
View File
@@ -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<MakerNote> {
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<MakerNote> {
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<u8>) -> (Vec<u8>, 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<u8> {
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());
}
}
-536
View File
@@ -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<u64>,
/// 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<Item = usize> + 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<DirectoryEntries> {
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<EntrySpan> {
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<Tiff> {
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<u64>,
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<u64> {
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<Box<Ifd>> {
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<Entry> {
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<const N: usize>(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<u8> {
let ifd = |d: &mut Vec<u8>, 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<_>>(), 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<_>>(), 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<_>>(), 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));
}
}
-226
View File
@@ -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;
}
-293
View File
@@ -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<Vec<u8>> },
/// Tiles in row-major tile order. Sets `TileWidth` / `TileLength`.
Tiles { tile_width: u32, tile_height: u32, tiles: Vec<Vec<u8>> },
}
/// An IFD to be written.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct IfdBuilder {
pub entries: BTreeMap<u16, Value>,
/// Written and referenced through the `SubIFDs` (330) tag.
pub sub_ifds: Vec<IfdBuilder>,
/// Pointer IFDs keyed by the pointer tag (e.g. [`tags::EXIF_IFD`], [`tags::GPS_IFD`], [`tags::INTEROP_IFD`]).
pub children: BTreeMap<u16, IfdBuilder>,
pub image: Option<ImageData>,
}
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<Vec<u8>> {
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<u64>) -> Result<Value> {
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::<Result<_>>()?,
))
}
}
/// Writes the IFD (and everything it references); returns (IFD offset, position of its next-IFD pointer).
fn write_ifd(&self, buf: &mut Vec<u8>, 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<u8>, Option<u64>)> = 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<u8>) {
if buf.len() % 2 == 1 {
buf.push(0);
}
}
/// Serialise a value's bytes in `o` order.
pub fn encode(o: ByteOrder, v: &Value) -> Vec<u8> {
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)
}
-3
View File
@@ -1,3 +0,0 @@
//! The integration tests, one module per file, linked into one test binary.
mod roundtrip;
-429
View File
@@ -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"<x:xmpmeta/>\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("<x:xmpmeta/>"));
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<u8> {
(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<Vec<u8>> = 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<u8> {
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::<u8>(), 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::<usize>(), any::<u8>()), 1..16), cut in any::<usize>()) {
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::<u16>(), 1..300), big in any::<bool>(), le in any::<bool>()) {
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<u8> { 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:?}");
}
}
-2
View File
@@ -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"],