mirror of
https://github.com/storytold/lightcraft.git
synced 2026-11-21 01:43:51 +01:00
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:
1 parent
5b61ce1e1a
commit
c5d60d2fa7
77 files changed
+278
-2780
No files matched your search
Generated
+12
-12
@@ -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
@@ -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" }
|
||||
|
||||
@@ -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 |
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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 }
|
||||
@@ -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();
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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]));
|
||||
|
||||
@@ -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 }
|
||||
|
||||
@@ -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];
|
||||
|
||||
@@ -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
@@ -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 [
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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() };
|
||||
|
||||
@@ -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
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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}")
|
||||
}
|
||||
|
||||
|
||||
@@ -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 }
|
||||
|
||||
@@ -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;
|
||||
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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()));
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
@@ -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)]
|
||||
|
||||
@@ -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
@@ -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})");
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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(_))));
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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]) {
|
||||
|
||||
@@ -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`.
|
||||
|
||||
Vendored
+27
-27
@@ -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();
|
||||
|
||||
Vendored
+3
-3
@@ -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
@@ -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 {
|
||||
|
||||
Vendored
+3
-3
@@ -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
@@ -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];
|
||||
|
||||
Vendored
+5
-5
@@ -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>) {
|
||||
|
||||
Vendored
+4
-4
@@ -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;
|
||||
|
||||
|
||||
Vendored
+6
-6
@@ -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 };
|
||||
|
||||
Vendored
+6
-6
@@ -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]
|
||||
|
||||
Vendored
+3
-3
@@ -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)];
|
||||
|
||||
Vendored
+5
-5
@@ -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;
|
||||
|
||||
Vendored
+3
-3
@@ -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()
|
||||
|
||||
Vendored
+6
-6
@@ -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);
|
||||
|
||||
Vendored
+9
-9
@@ -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());
|
||||
|
||||
Vendored
+3
-3
@@ -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 };
|
||||
|
||||
Vendored
+3
-3
@@ -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();
|
||||
|
||||
Vendored
+6
-6
@@ -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)
|
||||
|
||||
Vendored
+4
-4
@@ -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();
|
||||
|
||||
Vendored
+2
-2
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
Vendored
+2
-2
@@ -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.
|
||||
|
||||
Vendored
+2
-2
@@ -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 {
|
||||
|
||||
Vendored
+5
-5
@@ -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));
|
||||
|
||||
Vendored
+6
-6
@@ -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.
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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)] {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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()));
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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 }
|
||||
@@ -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.
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
//! The integration tests, one module per file, linked into one test binary.
|
||||
|
||||
mod roundtrip;
|
||||
@@ -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:?}");
|
||||
}
|
||||
}
|
||||
@@ -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"],
|
||||
|
||||
Reference in new issue
Block a user