feat(metadata): parse TIFF/Exif, JPEG segments and MakerNotes
ExifParser walks IFD0, Exif, GPS and SubIFDs, selects the main raster (largest full-resolution IFD), and enumerates embedded JPEG previews (JPEGInterchangeFormat, single-strip/tile Compression 6/7, lossless raw strips excluded). JpegParser scans APP1 Exif/XMP/extended XMP, APP2 MPF large thumbnails and SOFn up to SOS, tolerating fill bytes and garbage. Vendor MakerNotes (Canon, Nikon, Sony, Fujifilm, Olympus/OM, Panasonic) fill serial, lens, shutter count, stabiliser, ISO and colour temperature only when standard tags did not. TiffTags gains GPSVersionID, GPSStatus, YCbCrPositioning, StandardOutputSensitivity and ISOSpeed. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
11 files changed
+918
No files matched your search
@@ -0,0 +1,277 @@
|
||||
using System.Buffers.Binary;
|
||||
using System.Text;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
using Titano.Core.Metadata.Xmp;
|
||||
|
||||
namespace Titano.Core.Metadata.Jpeg;
|
||||
|
||||
/// <summary>Frame header (SOFn) of a JPEG.</summary>
|
||||
internal readonly record struct JpegFrame(int Width, int Height, int Precision, bool Lossless);
|
||||
|
||||
/// <summary>
|
||||
/// JPEG marker scan: APP1 Exif, APP1 XMP and extended XMP (reassembled by GUID/offset), APP2 MPF large-thumbnail
|
||||
/// entries, SOFn. Reads only segment headers and the payloads it parses, stops at SOS, and tolerates fill bytes and
|
||||
/// garbage between segments.
|
||||
/// </summary>
|
||||
internal static class JpegParser
|
||||
{
|
||||
/// <summary>Most bytes read while looking for an embedded JPEG's frame header.</summary>
|
||||
public const int MaxFrameScanBytes = 64 * 1024;
|
||||
|
||||
private const int MaxSegments = 1024;
|
||||
private const int MaxGarbageBytes = 64 * 1024;
|
||||
private const int MaxMpEntries = 64;
|
||||
private const ushort MpEntryTag = 0xB002;
|
||||
private const uint MpLargeThumbnailVga = 0x010001;
|
||||
private const uint MpLargeThumbnailFullHd = 0x010002;
|
||||
private const int ExtendedHeaderLength = 75;
|
||||
|
||||
private static ReadOnlySpan<byte> ExifSignature => "Exif\0"u8;
|
||||
private static ReadOnlySpan<byte> XmpSignature => "http://ns.adobe.com/xap/1.0/\0"u8;
|
||||
private static ReadOnlySpan<byte> ExtendedXmpSignature => "http://ns.adobe.com/xmp/extension/\0"u8;
|
||||
private static ReadOnlySpan<byte> MpfSignature => "MPF\0"u8;
|
||||
|
||||
/// <summary>Scans the JPEG at [<paramref name="start"/>, <paramref name="end"/>). A primary JPEG defines the main image
|
||||
/// size; an embedded one (RAF, RW2 JpgFromRaw) contributes its Exif/XMP and is recorded as a preview.</summary>
|
||||
public static void Parse(MetadataBuilder m, long start, long end, bool primary)
|
||||
{
|
||||
var scanner = new SegmentScanner(m.Stream, start, Math.Min(end, m.Length), long.MaxValue);
|
||||
if (!scanner.StartsWithSoi())
|
||||
{
|
||||
m.Warn("JPEG start-of-image marker not found");
|
||||
return;
|
||||
}
|
||||
JpegFrame? frame = null;
|
||||
var exifSeen = false;
|
||||
List<ExtendedXmpChunk>? extended = null;
|
||||
while (scanner.Next(out var segment))
|
||||
{
|
||||
m.ThrowIfCancelled();
|
||||
if (segment.Marker is 0xDA or 0xD9) break;
|
||||
if (segment.Marker == 0xE1) ReadApp1(m, segment, ref exifSeen, ref extended);
|
||||
else if (segment.Marker == 0xE2) ReadMpf(m, segment);
|
||||
else if (frame is null && IsFrameMarker(segment.Marker)) frame = ReadFrameHeader(m.Stream, segment);
|
||||
}
|
||||
if (scanner.Garbage) m.Warn("JPEG: garbage between segments skipped");
|
||||
if (scanner.Truncated) m.Warn("JPEG: truncated segment");
|
||||
if (frame is { } f)
|
||||
{
|
||||
if (primary) m.SetContainerSize(f.Width, f.Height, f.Precision);
|
||||
else if (!f.Lossless && end <= m.Length) m.AddPreview(start, end - start, f.Width, f.Height);
|
||||
}
|
||||
else if (primary)
|
||||
{
|
||||
m.Warn("JPEG frame header not found");
|
||||
}
|
||||
if (extended is not null) AssembleExtendedXmp(m, extended);
|
||||
}
|
||||
|
||||
/// <summary>Frame header of an embedded JPEG reading at most <see cref="MaxFrameScanBytes"/>; null when the bytes are
|
||||
/// not a JPEG or no SOFn precedes the scan data.</summary>
|
||||
public static JpegFrame? ReadFrame(Stream stream, long offset, long length)
|
||||
{
|
||||
if (offset < 0 || length < 4 || offset > stream.Length - length) return null;
|
||||
var scanner = new SegmentScanner(stream, offset, offset + length, MaxFrameScanBytes);
|
||||
if (!scanner.StartsWithSoi()) return null;
|
||||
while (scanner.Next(out var segment))
|
||||
{
|
||||
if (segment.Marker is 0xDA or 0xD9) return null;
|
||||
if (IsFrameMarker(segment.Marker)) return ReadFrameHeader(stream, segment);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>Validates an embedded JPEG and records it as a preview unless it is lossless (raw data).</summary>
|
||||
/// <returns>The frame header, or null when the range holds no readable JPEG.</returns>
|
||||
public static JpegFrame? AddPreview(MetadataBuilder m, long offset, long length, PreviewKind? kind = null)
|
||||
{
|
||||
if (offset < 0 || length <= 0 || offset > m.Length - length)
|
||||
{
|
||||
m.Warn("Embedded JPEG outside the file");
|
||||
return null;
|
||||
}
|
||||
var frame = ReadFrame(m.Stream, offset, length);
|
||||
if (frame is { Lossless: false } f) m.AddPreview(offset, length, f.Width, f.Height, kind);
|
||||
return frame;
|
||||
}
|
||||
|
||||
private static bool IsFrameMarker(byte marker) => marker is >= 0xC0 and <= 0xCF and not (0xC4 or 0xC8 or 0xCC);
|
||||
|
||||
private static JpegFrame? ReadFrameHeader(Stream stream, Segment segment)
|
||||
{
|
||||
Span<byte> sof = stackalloc byte[6];
|
||||
if (segment.Length < 6 || !stream.TryReadAt(segment.Payload, sof)) return null;
|
||||
var lossless = segment.Marker is 0xC3 or 0xC7 or 0xCB or 0xCF;
|
||||
return new JpegFrame(BinaryPrimitives.ReadUInt16BigEndian(sof[3..]), BinaryPrimitives.ReadUInt16BigEndian(sof[1..]), sof[0], lossless);
|
||||
}
|
||||
|
||||
private static void ReadApp1(MetadataBuilder m, Segment segment, ref bool exifSeen, ref List<ExtendedXmpChunk>? extended)
|
||||
{
|
||||
Span<byte> head = stackalloc byte[ExtendedHeaderLength];
|
||||
var n = m.Stream.ReadUpTo(segment.Payload, head[..Math.Min(head.Length, segment.Length)]);
|
||||
var h = head[..n];
|
||||
if (h.StartsWith(ExifSignature) && segment.Length > 6)
|
||||
{
|
||||
if (!exifSeen) ExifParser.ParseEmbedded(m, segment.Payload + 6);
|
||||
exifSeen = true;
|
||||
}
|
||||
else if (h.StartsWith(XmpSignature))
|
||||
{
|
||||
m.AddXmp(m.Stream.ReadAt(segment.Payload + XmpSignature.Length, segment.Length - XmpSignature.Length, XmpParser.MaxPacketBytes));
|
||||
}
|
||||
else if (h.StartsWith(ExtendedXmpSignature) && n == ExtendedHeaderLength)
|
||||
{
|
||||
var guid = Encoding.ASCII.GetString(h.Slice(ExtendedXmpSignature.Length, 32));
|
||||
var full = BinaryPrimitives.ReadUInt32BigEndian(h[67..]);
|
||||
var offset = BinaryPrimitives.ReadUInt32BigEndian(h[71..]);
|
||||
(extended ??= []).Add(new ExtendedXmpChunk(guid, full, offset, segment.Payload + ExtendedHeaderLength, segment.Length - ExtendedHeaderLength));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>APP2 Multi-Picture Format: secondary large thumbnails (type 0x010001/0x010002) become previews. Offsets are
|
||||
/// relative to the MP header; other secondary types (disparity, gain maps…) are not previews.</summary>
|
||||
private static void ReadMpf(MetadataBuilder m, Segment segment)
|
||||
{
|
||||
Span<byte> head = stackalloc byte[4];
|
||||
if (segment.Length < 16 || !m.Stream.TryReadAt(segment.Payload, head) || !head.SequenceEqual(MpfSignature)) return;
|
||||
var mpBase = segment.Payload + 4;
|
||||
var r = TiffReader.Open(m.Stream, mpBase);
|
||||
if (r?.ReadIfd(r.FirstIfdOffset) is not { } index || !index.Entries.TryGetValue(MpEntryTag, out var entry)) return;
|
||||
if (entry.Count % 16 != 0 || entry.Count > 16 * MaxMpEntries || r.ReadBytes(entry) is not { } entries)
|
||||
{
|
||||
m.Warn("MPF entry table malformed");
|
||||
return;
|
||||
}
|
||||
for (var i = 16; i + 16 <= entries.Length; i += 16)
|
||||
{
|
||||
var e = entries.AsSpan(i, 16);
|
||||
var type = r.U32(e) & 0xFFFFFF;
|
||||
var size = r.U32(e[4..]);
|
||||
var offset = r.U32(e[8..]);
|
||||
if (type is MpLargeThumbnailVga or MpLargeThumbnailFullHd && offset > 0 && size > 0) AddPreview(m, mpBase + offset, size);
|
||||
}
|
||||
m.AddWarnings(r.Warnings);
|
||||
}
|
||||
|
||||
private static void AssembleExtendedXmp(MetadataBuilder m, List<ExtendedXmpChunk> chunks)
|
||||
{
|
||||
var guid = m.Xmp.ExtendedXmpGuid;
|
||||
if (guid is null)
|
||||
{
|
||||
m.Warn("Extended XMP present but not referenced by the main packet");
|
||||
return;
|
||||
}
|
||||
uint full = 0;
|
||||
long covered = 0;
|
||||
foreach (var c in chunks)
|
||||
{
|
||||
if (!string.Equals(c.Guid, guid, StringComparison.OrdinalIgnoreCase)) continue;
|
||||
if (full == 0) full = c.FullLength;
|
||||
if (c.FullLength == full) covered += c.Length;
|
||||
}
|
||||
if (full == 0 || full > XmpParser.MaxPacketBytes || covered < full)
|
||||
{
|
||||
m.Warn("Extended XMP incomplete");
|
||||
return;
|
||||
}
|
||||
var buffer = new byte[full];
|
||||
foreach (var c in chunks)
|
||||
{
|
||||
if (!string.Equals(c.Guid, guid, StringComparison.OrdinalIgnoreCase) || c.FullLength != full || (long)c.Offset + c.Length > full) continue;
|
||||
if (!m.Stream.TryReadAt(c.Position, buffer.AsSpan((int)c.Offset, c.Length)))
|
||||
{
|
||||
m.Warn("Extended XMP chunk unreadable");
|
||||
return;
|
||||
}
|
||||
}
|
||||
m.AddXmp(buffer);
|
||||
}
|
||||
|
||||
private readonly record struct Segment(byte Marker, long Payload, int Length);
|
||||
|
||||
private readonly record struct ExtendedXmpChunk(string Guid, uint FullLength, uint Offset, long Position, int Length);
|
||||
|
||||
/// <summary>Walks marker segments of one JPEG, reading only marker and length bytes within a read budget.</summary>
|
||||
private sealed class SegmentScanner(Stream stream, long start, long end, long readBudget)
|
||||
{
|
||||
private readonly byte[] _buffer = new byte[16];
|
||||
private long _position = start + 2;
|
||||
private long _budget = readBudget;
|
||||
private int _count;
|
||||
|
||||
public bool Garbage { get; private set; }
|
||||
|
||||
public bool Truncated { get; private set; }
|
||||
|
||||
public bool StartsWithSoi() => Read(start, 2) == 2 && _buffer[0] == 0xFF && _buffer[1] == 0xD8;
|
||||
|
||||
public bool Next(out Segment segment)
|
||||
{
|
||||
segment = default;
|
||||
if (++_count > MaxSegments) return false;
|
||||
long skipped = 0;
|
||||
while (true)
|
||||
{
|
||||
var n = Read(_position, _buffer.Length);
|
||||
if (n < 2)
|
||||
{
|
||||
if (_position < end) Truncated = true;
|
||||
return false;
|
||||
}
|
||||
var i = 0;
|
||||
while (i < n - 1 && !(_buffer[i] == 0xFF && _buffer[i + 1] is not (0xFF or 0x00))) i++;
|
||||
if (i == n - 1)
|
||||
{
|
||||
Garbage |= _buffer.AsSpan(0, n - 1).ContainsAnyExcept((byte)0xFF);
|
||||
_position += n - 1;
|
||||
skipped += n - 1;
|
||||
if (skipped > MaxGarbageBytes) return false;
|
||||
continue;
|
||||
}
|
||||
Garbage |= _buffer.AsSpan(0, i).ContainsAnyExcept((byte)0xFF);
|
||||
var marker = _buffer[i + 1];
|
||||
var markerPosition = _position + i + 1;
|
||||
if (marker is 0xD8 or 0xD9 or 0x01 or (>= 0xD0 and <= 0xD7))
|
||||
{
|
||||
_position = markerPosition + 1;
|
||||
segment = new Segment(marker, _position, 0);
|
||||
return true;
|
||||
}
|
||||
int length;
|
||||
if (i + 3 < n)
|
||||
{
|
||||
length = _buffer[i + 2] << 8 | _buffer[i + 3];
|
||||
}
|
||||
else if (Read(markerPosition + 1, 2) == 2)
|
||||
{
|
||||
length = _buffer[0] << 8 | _buffer[1];
|
||||
}
|
||||
else
|
||||
{
|
||||
Truncated = true;
|
||||
return false;
|
||||
}
|
||||
if (length < 2)
|
||||
{
|
||||
Garbage = true;
|
||||
return false;
|
||||
}
|
||||
var payload = markerPosition + 3;
|
||||
var available = (int)Math.Clamp(end - payload, 0, length - 2);
|
||||
Truncated |= available < length - 2;
|
||||
segment = new Segment(marker, payload, available);
|
||||
_position = payload + length - 2;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private int Read(long position, int count)
|
||||
{
|
||||
if (position >= end || _budget <= 0) return 0;
|
||||
var n = (int)Math.Min(Math.Min(count, end - position), _budget);
|
||||
n = stream.ReadUpTo(position, _buffer.AsSpan(0, n));
|
||||
_budget -= n;
|
||||
return n;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
using System.Globalization;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Metadata.MakerNotes;
|
||||
|
||||
/// <summary>Canon MakerNote: a bare IFD whose offsets are relative to the enclosing TIFF header (also CR3 CMT3).</summary>
|
||||
internal static class CanonMakerNote
|
||||
{
|
||||
private const ushort CameraSettings = 0x0001;
|
||||
private const ushort SerialNumber = 0x000C;
|
||||
private const ushort LensModel = 0x0095;
|
||||
private const ushort InternalSerialNumber = 0x0096;
|
||||
private const ushort ColorTemperature = 0x00AE;
|
||||
private const int ImageStabilizationIndex = 34;
|
||||
|
||||
public static void Parse(TiffReader r, Ifd ifd, MetadataBuilder m)
|
||||
{
|
||||
var v = m.MakerNote;
|
||||
if (IfdValue.UInt(r, ifd, SerialNumber) is { } serial and > 0)
|
||||
{
|
||||
// Canon prints 6 digits on EOS-1D bodies and 10 elsewhere.
|
||||
var digits = m.Model?.Contains("EOS-1D", StringComparison.OrdinalIgnoreCase) == true ? "D6" : "D10";
|
||||
v.BodySerial ??= serial.ToString(digits, CultureInfo.InvariantCulture);
|
||||
}
|
||||
v.BodySerial ??= IfdValue.String(r, ifd, InternalSerialNumber);
|
||||
v.LensModel ??= IfdValue.String(r, ifd, LensModel);
|
||||
v.ColorTemperature ??= IfdValue.Int(r, ifd, ColorTemperature) is { } kelvin and > 0 and < 65535 ? kelvin : null;
|
||||
if (IfdValue.UInts(r, ifd, CameraSettings) is { Length: > ImageStabilizationIndex } settings)
|
||||
{
|
||||
// 0 Off, 1 On, 2 Shoot only, 3 Panning, 4 Dynamic; +256 for the "(2)" variants.
|
||||
v.ImageStabilization ??= (settings[ImageStabilizationIndex] & 0xFF) switch
|
||||
{
|
||||
0 => false,
|
||||
>= 1 and <= 4 => true,
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
using System.Buffers.Binary;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Metadata.MakerNotes;
|
||||
|
||||
/// <summary>Fujifilm MakerNote: "FUJIFILM" + little-endian IFD offset, offsets relative to the MakerNote start,
|
||||
/// always little-endian.</summary>
|
||||
internal static class FujifilmMakerNote
|
||||
{
|
||||
private const ushort SerialNumber = 0x0010;
|
||||
private const ushort ColorTemperature = 0x1005;
|
||||
private const ushort ImageStabilization = 0x1422;
|
||||
|
||||
public static void Parse(MetadataBuilder m, long start, ReadOnlySpan<byte> header)
|
||||
{
|
||||
if (header.Length < 12) return;
|
||||
var reader = TiffReader.ForEmbedded(m.Stream, start, littleEndian: true);
|
||||
MakerNoteParser.Vendor(reader, BinaryPrimitives.ReadUInt32LittleEndian(header[8..]), m, ParseIfd);
|
||||
m.AddWarnings(reader.Warnings);
|
||||
}
|
||||
|
||||
private static void ParseIfd(TiffReader r, Ifd ifd, MetadataBuilder m)
|
||||
{
|
||||
var v = m.MakerNote;
|
||||
v.BodySerial ??= IfdValue.String(r, ifd, SerialNumber);
|
||||
v.ColorTemperature ??= IfdValue.Int(r, ifd, ColorTemperature) is { } kelvin and > 0 and < 65535 ? kelvin : null;
|
||||
// [0] type (0 none, 1 optical, 2 sensor-shift, …), [1] mode (0 off, 1/2 on).
|
||||
if (IfdValue.UInts(r, ifd, ImageStabilization) is [var type, var mode, ..])
|
||||
v.ImageStabilization ??= type != 0 && mode != 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
using System.Globalization;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Metadata.MakerNotes;
|
||||
|
||||
/// <summary>
|
||||
/// Locates the vendor IFD inside an Exif MakerNote (by header signature, then by camera make) and hands it to the
|
||||
/// vendor parser. Best effort: unknown layouts are skipped, and every read goes through the bounds-checked
|
||||
/// <see cref="TiffReader"/>.
|
||||
/// </summary>
|
||||
internal static class MakerNoteParser
|
||||
{
|
||||
private const int HeaderBytes = 16;
|
||||
|
||||
/// <param name="exif">Reader of the TIFF block holding the Exif IFD (base and byte order of relative offsets).</param>
|
||||
/// <param name="makerNote">The Exif 0x927C entry.</param>
|
||||
public static void Parse(TiffReader exif, IfdEntry makerNote, MetadataBuilder m)
|
||||
{
|
||||
if (makerNote.IsInline || makerNote.ByteLength < 14) return;
|
||||
var start = makerNote.ValuePosition(exif.Base);
|
||||
if (start < exif.Base || start > m.Length - makerNote.ByteLength)
|
||||
{
|
||||
m.Warn("MakerNote outside the file");
|
||||
return;
|
||||
}
|
||||
Span<byte> head = stackalloc byte[HeaderBytes];
|
||||
var h = head[..m.Stream.ReadUpTo(start, head[..(int)Math.Min(HeaderBytes, makerNote.ByteLength)])];
|
||||
var make = m.Make ?? string.Empty;
|
||||
var relative = (uint)(start - exif.Base);
|
||||
|
||||
if (h.StartsWith("Nikon\0"u8))
|
||||
{
|
||||
NikonMakerNote.Parse(exif, start, h, m);
|
||||
}
|
||||
else if (h.StartsWith("OLYMPUS\0"u8) || h.StartsWith("OM SYSTEM\0"u8) || h.StartsWith("OLYMP\0"u8))
|
||||
{
|
||||
OlympusMakerNote.Parse(exif, start, h, m);
|
||||
}
|
||||
else if (h.StartsWith("FUJIFILM"u8))
|
||||
{
|
||||
FujifilmMakerNote.Parse(m, start, h);
|
||||
}
|
||||
else if (h.StartsWith("Panasonic\0"u8))
|
||||
{
|
||||
Vendor(exif, relative + 12, m, PanasonicMakerNote.Parse);
|
||||
}
|
||||
else if (h.StartsWith("SONY"u8))
|
||||
{
|
||||
Vendor(exif, relative + 12, m, SonyMakerNote.Parse);
|
||||
}
|
||||
else if (make.StartsWith("Canon", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
Vendor(exif, relative, m, CanonMakerNote.Parse);
|
||||
}
|
||||
else if (make.StartsWith("NIKON", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
Vendor(exif, relative, m, NikonMakerNote.ParseIfd);
|
||||
}
|
||||
else if (make.StartsWith("SONY", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
Vendor(exif, relative, m, SonyMakerNote.Parse);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Reads the IFD at a base-relative offset with <paramref name="reader"/> and runs <paramref name="parse"/> on it.</summary>
|
||||
internal static void Vendor(TiffReader reader, uint offset, MetadataBuilder m, Action<TiffReader, Ifd, MetadataBuilder> parse)
|
||||
{
|
||||
if (reader.ReadIfd(offset) is { } ifd) parse(reader, ifd, m);
|
||||
else m.Warn("MakerNote IFD unreadable");
|
||||
}
|
||||
|
||||
/// <summary>"24-70mm f/2.8", "50mm f/1.8" or "18-55mm F3.5-5.6" from focal-length and aperture ranges.</summary>
|
||||
internal static string FormatLens(double minFocal, double maxFocal, double minAperture, double maxAperture, string aperturePrefix)
|
||||
{
|
||||
static string N(double v) => Math.Round(v, 1).ToString("0.#", CultureInfo.InvariantCulture);
|
||||
var focal = maxFocal > minFocal ? $"{N(minFocal)}-{N(maxFocal)}mm" : $"{N(minFocal)}mm";
|
||||
if (minAperture <= 0) return focal;
|
||||
var aperture = maxAperture > minAperture ? $"{N(minAperture)}-{N(maxAperture)}" : N(minAperture);
|
||||
return $"{focal} {aperturePrefix}{aperture}";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Metadata.MakerNotes;
|
||||
|
||||
/// <summary>Nikon MakerNote. Type 3 ("Nikon\0" + version 2.x) embeds its own TIFF header 10 bytes in; type 1
|
||||
/// ("Nikon\0" + version 1) has an IFD at +8 and headerless type 2 an IFD at +0, both relative to the Exif TIFF.</summary>
|
||||
internal static class NikonMakerNote
|
||||
{
|
||||
private const ushort Iso = 0x0002;
|
||||
private const ushort SerialNumber = 0x001D;
|
||||
private const ushort VrInfo = 0x001F;
|
||||
private const ushort Lens = 0x0084;
|
||||
private const ushort ShutterCount = 0x00A7;
|
||||
|
||||
public static void Parse(TiffReader exif, long start, ReadOnlySpan<byte> header, MetadataBuilder m)
|
||||
{
|
||||
if (header.Length > 6 && header[6] == 2)
|
||||
{
|
||||
if (TiffReader.Open(m.Stream, start + 10) is { } inner)
|
||||
{
|
||||
MakerNoteParser.Vendor(inner, inner.FirstIfdOffset, m, ParseIfd);
|
||||
m.AddWarnings(inner.Warnings);
|
||||
}
|
||||
else
|
||||
{
|
||||
m.Warn("Nikon MakerNote TIFF header missing");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
MakerNoteParser.Vendor(exif, (uint)(start - exif.Base + 8), m, ParseIfd);
|
||||
}
|
||||
}
|
||||
|
||||
public static void ParseIfd(TiffReader r, Ifd ifd, MetadataBuilder m)
|
||||
{
|
||||
var v = m.MakerNote;
|
||||
v.BodySerial ??= IfdValue.String(r, ifd, SerialNumber);
|
||||
v.ShutterCount ??= IfdValue.UInt(r, ifd, ShutterCount);
|
||||
v.Iso ??= IfdValue.UInts(r, ifd, Iso) is [_, var iso, ..] && iso is > 0 and <= int.MaxValue ? (int)iso : null;
|
||||
if (IfdValue.Doubles(r, ifd, Lens, 4) is [var minFocal, var maxFocal, var minAperture, var maxAperture, ..] && minFocal > 0)
|
||||
v.LensModel ??= MakerNoteParser.FormatLens(minFocal, maxFocal, minAperture, maxAperture, "f/");
|
||||
if (ifd.Entries.TryGetValue(VrInfo, out var vr) && vr.Count is >= 5 and <= 64 && r.ReadBytes(vr) is { } bytes)
|
||||
{
|
||||
// Byte 4: 1 = on, 2 = off.
|
||||
v.ImageStabilization ??= bytes[4] switch
|
||||
{
|
||||
1 => true,
|
||||
2 => false,
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
using Titano.Core.Metadata.Jpeg;
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Metadata.MakerNotes;
|
||||
|
||||
/// <summary>
|
||||
/// Olympus / OM System MakerNote. "OLYMPUS\0II\3\0" (IFD at +12) and "OM SYSTEM\0\0\0II\4\0" (IFD at +16) use offsets
|
||||
/// relative to the MakerNote start and their own byte order; legacy "OLYMP\0" has its IFD at +8 relative to the
|
||||
/// Exif TIFF. Equipment (0x2010) gives serial and lens; CameraSettings (0x2020) gives the ORF preview and stabiliser.
|
||||
/// </summary>
|
||||
internal static class OlympusMakerNote
|
||||
{
|
||||
private const ushort Equipment = 0x2010;
|
||||
private const ushort CameraSettings = 0x2020;
|
||||
private const ushort EquipmentSerialNumber = 0x0101;
|
||||
private const ushort EquipmentLensModel = 0x0203;
|
||||
private const ushort PreviewImageValid = 0x0100;
|
||||
private const ushort PreviewImageStart = 0x0101;
|
||||
private const ushort PreviewImageLength = 0x0102;
|
||||
private const ushort ImageStabilization = 0x0604;
|
||||
|
||||
public static void Parse(TiffReader exif, long start, ReadOnlySpan<byte> header, MetadataBuilder m)
|
||||
{
|
||||
if (header.StartsWith("OLYMP\0"u8))
|
||||
{
|
||||
MakerNoteParser.Vendor(exif, (uint)(start - exif.Base + 8), m, ParseIfd);
|
||||
return;
|
||||
}
|
||||
var orderAt = header.StartsWith("OM SYSTEM\0"u8) ? 12 : 8;
|
||||
if (header.Length < orderAt + 4 || header[orderAt] != header[orderAt + 1] || header[orderAt] is not ((byte)'I' or (byte)'M'))
|
||||
{
|
||||
m.Warn("Olympus MakerNote header malformed");
|
||||
return;
|
||||
}
|
||||
var reader = TiffReader.ForEmbedded(m.Stream, start, header[orderAt] == 'I');
|
||||
MakerNoteParser.Vendor(reader, (uint)(orderAt + 4), m, ParseIfd);
|
||||
m.AddWarnings(reader.Warnings);
|
||||
}
|
||||
|
||||
private static void ParseIfd(TiffReader r, Ifd ifd, MetadataBuilder m)
|
||||
{
|
||||
var v = m.MakerNote;
|
||||
if (SubIfd(r, ifd, Equipment) is { } equipment)
|
||||
{
|
||||
v.BodySerial ??= IfdValue.String(r, equipment, EquipmentSerialNumber);
|
||||
v.LensModel ??= IfdValue.String(r, equipment, EquipmentLensModel);
|
||||
}
|
||||
if (SubIfd(r, ifd, CameraSettings) is not { } settings) return;
|
||||
v.ImageStabilization ??= IfdValue.UInt(r, settings, ImageStabilization) switch
|
||||
{
|
||||
0 => false,
|
||||
>= 1 and <= 4 => true,
|
||||
_ => null,
|
||||
};
|
||||
if (IfdValue.UInt(r, settings, PreviewImageValid) != 0
|
||||
&& IfdValue.UInt(r, settings, PreviewImageStart) is { } offset and > 0
|
||||
&& IfdValue.UInt(r, settings, PreviewImageLength) is { } length and > 0)
|
||||
{
|
||||
JpegParser.AddPreview(m, r.Base + offset, length);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Sub-IFD stored either as an IFD/LONG pointer or as an UNDEFINED block; both resolve to the value offset.</summary>
|
||||
private static Ifd? SubIfd(TiffReader r, Ifd ifd, ushort tag) =>
|
||||
ifd.Entries.TryGetValue(tag, out var e) && !(e.IsInline && e.Type == TiffType.Undefined) ? r.ReadIfd(e.ValueOffset) : null;
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Metadata.MakerNotes;
|
||||
|
||||
/// <summary>Panasonic MakerNote: "Panasonic\0\0\0" then an IFD whose offsets are relative to the Exif TIFF.</summary>
|
||||
internal static class PanasonicMakerNote
|
||||
{
|
||||
private const ushort ImageStabilization = 0x001A;
|
||||
private const ushort InternalSerialNumber = 0x0025;
|
||||
private const ushort ColorTempKelvin = 0x0044;
|
||||
private const ushort LensType = 0x0051;
|
||||
|
||||
public static void Parse(TiffReader r, Ifd ifd, MetadataBuilder m)
|
||||
{
|
||||
var v = m.MakerNote;
|
||||
v.BodySerial ??= IfdValue.String(r, ifd, InternalSerialNumber);
|
||||
v.LensModel ??= IfdValue.String(r, ifd, LensType);
|
||||
v.ColorTemperature ??= IfdValue.Int(r, ifd, ColorTempKelvin) is { } kelvin and > 0 and < 65535 ? kelvin : null;
|
||||
// 3 = off; 2, 4–7, 9–12 = optical/body/dual IS modes.
|
||||
v.ImageStabilization ??= IfdValue.UInt(r, ifd, ImageStabilization) switch
|
||||
{
|
||||
3 => false,
|
||||
2 or (>= 4 and <= 7) or (>= 9 and <= 12) => true,
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
using Titano.Core.Metadata.Tiff;
|
||||
|
||||
namespace Titano.Core.Metadata.MakerNotes;
|
||||
|
||||
/// <summary>Sony MakerNote ("SONY DSC/CAM" 12-byte header or headerless; offsets relative to the Exif TIFF).
|
||||
/// Lens: the unencrypted LensSpec (BCD focal/aperture range); numeric LensType tables are not shipped.</summary>
|
||||
internal static class SonyMakerNote
|
||||
{
|
||||
private const ushort ColorTemperature = 0xB021;
|
||||
private const ushort ImageStabilization = 0xB026;
|
||||
private const ushort LensSpec = 0xB02A;
|
||||
|
||||
public static void Parse(TiffReader r, Ifd ifd, MetadataBuilder m)
|
||||
{
|
||||
var v = m.MakerNote;
|
||||
if (ifd.Entries.TryGetValue(LensSpec, out var spec) && spec.Count == 8 && r.ReadBytes(spec) is { } bytes)
|
||||
v.LensModel ??= DecodeLensSpec(bytes);
|
||||
v.ColorTemperature ??= IfdValue.UInt(r, ifd, ColorTemperature) is { } kelvin and > 0 and < 65535 ? (int)kelvin : null;
|
||||
v.ImageStabilization ??= IfdValue.UInt(r, ifd, ImageStabilization) switch
|
||||
{
|
||||
0 => false,
|
||||
1 => true,
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>Bytes 1–2 short focal, 3–4 long focal (BCD mm), 5–6 apertures (BCD ×10); flags 0 and 7 are not decoded.</summary>
|
||||
private static string? DecodeLensSpec(ReadOnlySpan<byte> s)
|
||||
{
|
||||
if (!TryBcd(s.Slice(1, 2), out var minFocal) || !TryBcd(s.Slice(3, 2), out var maxFocal)
|
||||
|| !TryBcd(s.Slice(5, 1), out var minAperture) || !TryBcd(s.Slice(6, 1), out var maxAperture) || minFocal == 0)
|
||||
return null;
|
||||
return MakerNoteParser.FormatLens(minFocal, maxFocal, minAperture / 10.0, maxAperture / 10.0, "F");
|
||||
}
|
||||
|
||||
private static bool TryBcd(ReadOnlySpan<byte> bytes, out int value)
|
||||
{
|
||||
value = 0;
|
||||
foreach (var b in bytes)
|
||||
{
|
||||
if (b >> 4 > 9 || (b & 0xF) > 9) return false;
|
||||
value = value * 100 + (b >> 4) * 10 + (b & 0xF);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,247 @@
|
||||
using System.Buffers.Binary;
|
||||
using Titano.Core.Imaging;
|
||||
using Titano.Core.Metadata.Jpeg;
|
||||
using Titano.Core.Metadata.MakerNotes;
|
||||
using Titano.Core.Metadata.Xmp;
|
||||
|
||||
namespace Titano.Core.Metadata.Tiff;
|
||||
|
||||
/// <summary>
|
||||
/// Maps TIFF/Exif structures onto a <see cref="MetadataBuilder"/>: IFD0, Exif IFD, GPS IFD, MakerNote, the 0x02BC XMP
|
||||
/// packet, raster IFDs (main-image selection across the IFD chain and SubIFDs) and embedded JPEG previews.
|
||||
/// </summary>
|
||||
internal static class ExifParser
|
||||
{
|
||||
private const int MaxImageIfds = 64;
|
||||
private const int MaxSubIfdDepth = 4;
|
||||
private const uint MaxSubIfdsPerIfd = 16;
|
||||
private const uint PhotometricCfa = 32803;
|
||||
private const uint PhotometricLinearRaw = 34892;
|
||||
|
||||
// Panasonic RW2/RWL IFD0 (PanasonicRaw) tags.
|
||||
private const ushort PanasonicSensorWidth = 0x0002;
|
||||
private const ushort PanasonicSensorHeight = 0x0003;
|
||||
private const ushort PanasonicSensorTop = 0x0004;
|
||||
private const ushort PanasonicSensorLeft = 0x0005;
|
||||
private const ushort PanasonicSensorBottom = 0x0006;
|
||||
private const ushort PanasonicSensorRight = 0x0007;
|
||||
private const ushort PanasonicBitsPerSample = 0x000A;
|
||||
private const ushort PanasonicIso = 0x0017;
|
||||
private const ushort PanasonicJpgFromRaw = 0x002E;
|
||||
|
||||
/// <summary>Parses a TIFF-based file (TIFF, DNG, TIFF-like RAWs) whose header is at offset 0.</summary>
|
||||
public static void ParseFile(MetadataBuilder m) => Walk(m, 0, isFile: true);
|
||||
|
||||
/// <summary>Parses an Exif TIFF block embedded in another container (JPEG APP1, PNG eXIf, WebP EXIF, HEIF item…).
|
||||
/// Its IFD1 thumbnail is reported as a preview; raster IFDs do not compete for the main image size.</summary>
|
||||
public static void ParseEmbedded(MetadataBuilder m, long tiffBase) => Walk(m, tiffBase, isFile: false);
|
||||
|
||||
/// <summary>Exif data prefixed by a 4-byte big-endian TIFF-header offset (HEIF Exif item, JPEG XL Exif box).
|
||||
/// Falls back to searching the first bytes for a TIFF header when the offset is wrong.</summary>
|
||||
public static void ParseOffsetPrefixed(MetadataBuilder m, long start, long length)
|
||||
{
|
||||
Span<byte> head = stackalloc byte[40];
|
||||
var n = m.Stream.ReadUpTo(start, head[..(int)Math.Min(head.Length, Math.Max(0, length))]);
|
||||
if (n < 12)
|
||||
{
|
||||
m.Warn("Exif item too short");
|
||||
return;
|
||||
}
|
||||
var declared = BinaryPrimitives.ReadUInt32BigEndian(head);
|
||||
if (declared < length - 12 && TiffReader.Open(m.Stream, start + 4 + declared) is not null)
|
||||
{
|
||||
ParseEmbedded(m, start + 4 + declared);
|
||||
return;
|
||||
}
|
||||
for (var i = 4; i + 4 <= n; i++)
|
||||
{
|
||||
if (head[i..].StartsWith("II*\0"u8) || head[i..].StartsWith("MM\0*"u8))
|
||||
{
|
||||
ParseEmbedded(m, start + i);
|
||||
return;
|
||||
}
|
||||
}
|
||||
m.Warn("Exif item has no TIFF header");
|
||||
}
|
||||
|
||||
/// <summary>IFD0 fields plus the Exif and GPS sub-IFDs it points to.</summary>
|
||||
public static void ReadTree(TiffReader r, Ifd ifd0, MetadataBuilder m, HashSet<long> visited)
|
||||
{
|
||||
ReadIfd0(r, ifd0, m);
|
||||
if (Pointer(r, ifd0, TiffTags.ExifIfd, visited) is { } exif) ReadExif(r, exif, m);
|
||||
if (Pointer(r, ifd0, TiffTags.GpsIfd, visited) is { } gps) ReadGps(r, gps, m);
|
||||
}
|
||||
|
||||
/// <summary>Camera identity, authorship, orientation, rating and XMP from IFD0.</summary>
|
||||
public static void ReadIfd0(TiffReader r, Ifd ifd, MetadataBuilder m)
|
||||
{
|
||||
m.Make ??= IfdValue.String(r, ifd, TiffTags.Make);
|
||||
m.Model ??= IfdValue.String(r, ifd, TiffTags.Model);
|
||||
m.Software ??= IfdValue.String(r, ifd, TiffTags.Software);
|
||||
m.Artist ??= IfdValue.String(r, ifd, TiffTags.Artist);
|
||||
m.Copyright ??= IfdValue.String(r, ifd, TiffTags.Copyright);
|
||||
m.ExifOrientation ??= IfdValue.Int(r, ifd, TiffTags.Orientation);
|
||||
m.ExifRating ??= IfdValue.Int(r, ifd, TiffTags.Rating);
|
||||
if (ifd.Entries.TryGetValue(TiffTags.Xmp, out var xmp)) m.AddXmp(r.ReadBytes(xmp, XmpParser.MaxPacketBytes));
|
||||
}
|
||||
|
||||
/// <summary>Exposure, capture time, lens/body identity and the MakerNote from an Exif IFD.</summary>
|
||||
public static void ReadExif(TiffReader r, Ifd ifd, MetadataBuilder m)
|
||||
{
|
||||
m.ExposureTime ??= Positive(IfdValue.Double(r, ifd, TiffTags.ExposureTime))
|
||||
?? (IfdValue.Double(r, ifd, TiffTags.ShutterSpeedValue) is { } tv and > -32 and < 32 ? Math.Pow(2, -tv) : (double?)null);
|
||||
m.FNumber ??= Positive(IfdValue.Double(r, ifd, TiffTags.FNumber))
|
||||
?? (IfdValue.Double(r, ifd, TiffTags.ApertureValue) is { } av and >= 0 and < 64 ? Math.Pow(2, av / 2) : (double?)null);
|
||||
m.IsoSpeedRatings ??= IfdValue.Int(r, ifd, TiffTags.IsoSpeedRatings);
|
||||
m.IsoFallback ??= IfdValue.Int(r, ifd, TiffTags.RecommendedExposureIndex)
|
||||
?? IfdValue.Int(r, ifd, TiffTags.StandardOutputSensitivity)
|
||||
?? IfdValue.Int(r, ifd, TiffTags.IsoSpeed);
|
||||
var commonOffset = IfdValue.String(r, ifd, TiffTags.OffsetTime);
|
||||
m.DateTimeOriginal ??= Stamp(r, ifd, TiffTags.DateTimeOriginal, TiffTags.SubSecTimeOriginal, TiffTags.OffsetTimeOriginal, commonOffset);
|
||||
m.DateTimeDigitized ??= Stamp(r, ifd, TiffTags.DateTimeDigitized, TiffTags.SubSecTimeDigitized, TiffTags.OffsetTimeDigitized, commonOffset);
|
||||
m.FocalLength ??= Positive(IfdValue.Double(r, ifd, TiffTags.FocalLength));
|
||||
m.FocalLength35 ??= Positive(IfdValue.Double(r, ifd, TiffTags.FocalLengthIn35mmFilm));
|
||||
m.ExposureBias ??= IfdValue.Double(r, ifd, TiffTags.ExposureBiasValue) is { } bias and > -64 and < 64 ? bias : (double?)null;
|
||||
m.ExposureProgram ??= IfdValue.Int(r, ifd, TiffTags.ExposureProgram);
|
||||
m.MeteringMode ??= IfdValue.Int(r, ifd, TiffTags.MeteringMode);
|
||||
m.WhiteBalanceMode ??= IfdValue.Int(r, ifd, TiffTags.WhiteBalance);
|
||||
m.Flash ??= IfdValue.Int(r, ifd, TiffTags.Flash);
|
||||
m.PixelXDimension ??= IfdValue.Int(r, ifd, TiffTags.PixelXDimension);
|
||||
m.PixelYDimension ??= IfdValue.Int(r, ifd, TiffTags.PixelYDimension);
|
||||
m.BodySerial ??= IfdValue.String(r, ifd, TiffTags.BodySerialNumber);
|
||||
m.LensModel ??= IfdValue.String(r, ifd, TiffTags.LensModel);
|
||||
if (ifd.Entries.TryGetValue(TiffTags.MakerNote, out var makerNote)) MakerNoteParser.Parse(r, makerNote, m);
|
||||
}
|
||||
|
||||
/// <summary>Position (status "V" = void is ignored), altitude and the UTC date/time stamp from a GPS IFD.</summary>
|
||||
public static void ReadGps(TiffReader r, Ifd ifd, MetadataBuilder m)
|
||||
{
|
||||
if (m.Gps is null && IfdValue.String(r, ifd, TiffTags.GpsStatus) != "V"
|
||||
&& Degrees(r, ifd, TiffTags.GpsLatitude, TiffTags.GpsLatitudeRef, 'S', 90) is { } lat
|
||||
&& Degrees(r, ifd, TiffTags.GpsLongitude, TiffTags.GpsLongitudeRef, 'W', 180) is { } lon)
|
||||
{
|
||||
var altitude = IfdValue.Double(r, ifd, TiffTags.GpsAltitude) is { } alt and >= 0 and < 1e6
|
||||
? IfdValue.Int(r, ifd, TiffTags.GpsAltitudeRef) == 1 ? -alt : alt
|
||||
: (double?)null;
|
||||
m.Gps = new GpsPosition(lat, lon, altitude, null);
|
||||
}
|
||||
if (m.GpsUtc is null
|
||||
&& MetadataDates.ParseDate(IfdValue.String(r, ifd, TiffTags.GpsDateStamp)) is { } date
|
||||
&& IfdValue.Doubles(r, ifd, TiffTags.GpsTimeStamp, 3) is [var h, var min, var sec, ..]
|
||||
&& h is >= 0 and < 24 && min is >= 0 and < 60 && sec is >= 0 and < 61)
|
||||
{
|
||||
m.GpsUtc = DateTime.SpecifyKind(date.AddSeconds(h * 3600 + min * 60 + sec), DateTimeKind.Utc);
|
||||
}
|
||||
}
|
||||
|
||||
private static void Walk(MetadataBuilder m, long tiffBase, bool isFile)
|
||||
{
|
||||
var r = TiffReader.Open(m.Stream, tiffBase);
|
||||
if (r is null)
|
||||
{
|
||||
m.Warn(isFile ? "TIFF header not found" : "Exif TIFF header not found");
|
||||
return;
|
||||
}
|
||||
var chain = r.ReadChain();
|
||||
if (chain.Count == 0)
|
||||
{
|
||||
m.Warn("No readable IFD");
|
||||
}
|
||||
else
|
||||
{
|
||||
var visited = new HashSet<long>();
|
||||
foreach (var ifd in chain) visited.Add(ifd.Position);
|
||||
ReadTree(r, chain[0], m, visited);
|
||||
if (isFile && m.Format is ImageFileFormat.Rw2 or ImageFileFormat.Rwl or ImageFileFormat.Raw) ReadPanasonicRaw(r, chain[0], m);
|
||||
var budget = MaxImageIfds;
|
||||
foreach (var ifd in chain) VisitImage(r, ifd, m, visited, 0, isFile, ref budget);
|
||||
// DNG CameraSerialNumber ranks after Exif BodySerialNumber and before the MakerNote.
|
||||
if (isFile) m.BodySerial ??= IfdValue.String(r, chain[0], TiffTags.CameraSerialNumber);
|
||||
}
|
||||
m.AddWarnings(r.Warnings);
|
||||
}
|
||||
|
||||
/// <summary>Raster candidate, embedded previews and SubIFDs (depth- and count-capped) of one image IFD.</summary>
|
||||
private static void VisitImage(TiffReader r, Ifd ifd, MetadataBuilder m, HashSet<long> visited, int depth, bool isFile, ref int budget)
|
||||
{
|
||||
if (--budget < 0) return;
|
||||
m.ThrowIfCancelled();
|
||||
if (isFile)
|
||||
{
|
||||
var width = IfdValue.Int(r, ifd, TiffTags.ImageWidth) ?? 0;
|
||||
var height = IfdValue.Int(r, ifd, TiffTags.ImageLength) ?? 0;
|
||||
var primary = ((IfdValue.UInt(r, ifd, TiffTags.NewSubfileType) ?? 0) & 1) == 0;
|
||||
m.AddRaster(width, height, IfdValue.Int(r, ifd, TiffTags.BitsPerSample), primary);
|
||||
}
|
||||
AddPreviews(r, ifd, m, isFile);
|
||||
if (depth >= MaxSubIfdDepth || !ifd.Entries.TryGetValue(TiffTags.SubIfds, out var sub) || sub.Count > MaxSubIfdsPerIfd) return;
|
||||
foreach (var offset in r.GetUInts(sub) ?? [])
|
||||
{
|
||||
if (r.ReadIfd(offset, visited) is { } child) VisitImage(r, child, m, visited, depth + 1, isFile, ref budget);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>JPEGInterchangeFormat thumbnails/previews and single-strip/tile JPEG images (Compression 6/7, not CFA).</summary>
|
||||
private static void AddPreviews(TiffReader r, Ifd ifd, MetadataBuilder m, bool isFile)
|
||||
{
|
||||
if (IfdValue.UInt(r, ifd, TiffTags.JpegInterchangeFormat) is { } offset and > 0
|
||||
&& IfdValue.UInt(r, ifd, TiffTags.JpegInterchangeFormatLength) is { } length and > 0)
|
||||
{
|
||||
JpegParser.AddPreview(m, r.Base + offset, length);
|
||||
}
|
||||
if (IfdValue.UInt(r, ifd, TiffTags.Compression) is not (6 or 7)
|
||||
|| IfdValue.UInt(r, ifd, TiffTags.PhotometricInterpretation) is PhotometricCfa or PhotometricLinearRaw)
|
||||
return;
|
||||
var (offsetTag, countTag) = ifd.Has(TiffTags.StripOffsets)
|
||||
? (TiffTags.StripOffsets, TiffTags.StripByteCounts)
|
||||
: (TiffTags.TileOffsets, TiffTags.TileByteCounts);
|
||||
if (ifd.Entries.TryGetValue(offsetTag, out var e) && e.Count == 1
|
||||
&& IfdValue.UInt(r, ifd, offsetTag) is { } dataOffset
|
||||
&& IfdValue.UInt(r, ifd, countTag) is { } dataLength and > 0
|
||||
&& JpegParser.AddPreview(m, r.Base + dataOffset, dataLength) is { Lossless: true } raw
|
||||
&& isFile)
|
||||
{
|
||||
m.CodedBitsPerSample ??= raw.Precision;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Panasonic RW2 header: sensor crop size, bit depth, ISO and the JpgFromRaw that carries the Exif block.</summary>
|
||||
private static void ReadPanasonicRaw(TiffReader r, Ifd ifd0, MetadataBuilder m)
|
||||
{
|
||||
var top = IfdValue.Int(r, ifd0, PanasonicSensorTop) ?? 0;
|
||||
var left = IfdValue.Int(r, ifd0, PanasonicSensorLeft) ?? 0;
|
||||
var bottom = IfdValue.Int(r, ifd0, PanasonicSensorBottom) ?? 0;
|
||||
var right = IfdValue.Int(r, ifd0, PanasonicSensorRight) ?? 0;
|
||||
var (width, height) = right > left && bottom > top
|
||||
? (right - left, bottom - top)
|
||||
: (IfdValue.Int(r, ifd0, PanasonicSensorWidth) ?? 0, IfdValue.Int(r, ifd0, PanasonicSensorHeight) ?? 0);
|
||||
m.SetContainerSize(width, height, IfdValue.Int(r, ifd0, PanasonicBitsPerSample));
|
||||
m.IsoFallback ??= IfdValue.Int(r, ifd0, PanasonicIso);
|
||||
if (ifd0.Entries.TryGetValue(PanasonicJpgFromRaw, out var jpeg) && !jpeg.IsInline)
|
||||
{
|
||||
var start = jpeg.ValuePosition(r.Base);
|
||||
JpegParser.Parse(m, start, start + jpeg.ByteLength, primary: false);
|
||||
}
|
||||
}
|
||||
|
||||
private static Ifd? Pointer(TiffReader r, Ifd ifd, ushort tag, HashSet<long> visited) =>
|
||||
IfdValue.UInt(r, ifd, tag) is { } offset and > 0 ? r.ReadIfd(offset, visited) : null;
|
||||
|
||||
private static CaptureStamp? Stamp(TiffReader r, Ifd ifd, ushort dateTag, ushort subSecTag, ushort offsetTag, string? fallbackOffset)
|
||||
{
|
||||
if (MetadataDates.ParseExif(IfdValue.String(r, ifd, dateTag)) is not { } value) return null;
|
||||
var ticks = MetadataDates.SubSecondTicks(IfdValue.String(r, ifd, subSecTag));
|
||||
var offset = MetadataDates.ParseOffset(IfdValue.String(r, ifd, offsetTag)) ?? MetadataDates.ParseOffset(fallbackOffset);
|
||||
return new CaptureStamp(value.AddTicks(ticks), offset);
|
||||
}
|
||||
|
||||
private static double? Degrees(TiffReader r, Ifd ifd, ushort tag, ushort refTag, char negative, double limit)
|
||||
{
|
||||
if (IfdValue.Doubles(r, ifd, tag, 3) is not [var d, var min, var sec, ..]) return null;
|
||||
var value = d + min / 60 + sec / 3600;
|
||||
if (!(value >= 0 && value <= limit)) return null;
|
||||
return IfdValue.String(r, ifd, refTag) is { Length: > 0 } reference && char.ToUpperInvariant(reference[0]) == negative ? -value : value;
|
||||
}
|
||||
|
||||
private static double? Positive(double? value) => value is > 0 ? value : null;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
namespace Titano.Core.Metadata.Tiff;
|
||||
|
||||
/// <summary>Single-value accessors over <see cref="TiffReader"/> that refuse oversized counts, so a corrupt
|
||||
/// count can never trigger a large read when only the first value is needed.</summary>
|
||||
internal static class IfdValue
|
||||
{
|
||||
/// <summary>Largest value count read for scalar/array tags (GPS triples, lens info, Canon camera settings…).</summary>
|
||||
public const uint MaxCount = 256;
|
||||
|
||||
public static uint? UInt(TiffReader r, Ifd ifd, ushort tag) =>
|
||||
ifd.Entries.TryGetValue(tag, out var e) && e.Count is > 0 and <= MaxCount && r.GetUInts(e) is [var v, ..] ? v : null;
|
||||
|
||||
public static int? Int(TiffReader r, Ifd ifd, ushort tag) => UInt(r, ifd, tag) is { } v && v <= int.MaxValue ? (int)v : null;
|
||||
|
||||
public static uint[]? UInts(TiffReader r, Ifd ifd, ushort tag) =>
|
||||
ifd.Entries.TryGetValue(tag, out var e) && e.Count is > 0 and <= MaxCount ? r.GetUInts(e) : null;
|
||||
|
||||
/// <summary>First value as a finite double (rationals divided).</summary>
|
||||
public static double? Double(TiffReader r, Ifd ifd, ushort tag) => Doubles(r, ifd, tag, 1) is [var v, ..] ? v : null;
|
||||
|
||||
/// <summary>All values when at least <paramref name="minCount"/> are present and every one is finite.</summary>
|
||||
public static double[]? Doubles(TiffReader r, Ifd ifd, ushort tag, int minCount)
|
||||
{
|
||||
if (!ifd.Entries.TryGetValue(tag, out var e) || e.Count < minCount || e.Count > MaxCount) return null;
|
||||
var values = r.GetDoubles(e);
|
||||
if (values is null) return null;
|
||||
foreach (var v in values)
|
||||
{
|
||||
if (!double.IsFinite(v)) return null;
|
||||
}
|
||||
return values;
|
||||
}
|
||||
|
||||
/// <summary>Text value with control characters removed; null when empty.</summary>
|
||||
public static string? String(TiffReader r, Ifd ifd, ushort tag)
|
||||
{
|
||||
var s = r.GetString(ifd, tag);
|
||||
if (s is null) return null;
|
||||
if (s.AsSpan().IndexOfAnyInRange('\0', '\u001F') >= 0)
|
||||
{
|
||||
s = string.Concat(s.Where(c => !char.IsControl(c))).Trim();
|
||||
}
|
||||
return s.Length == 0 ? null : s;
|
||||
}
|
||||
}
|
||||
@@ -37,6 +37,7 @@ public static class TiffTags
|
||||
public const ushort JpegInterchangeFormat = 0x0201;
|
||||
public const ushort JpegInterchangeFormatLength = 0x0202;
|
||||
public const ushort YCbCrSubSampling = 0x0212;
|
||||
public const ushort YCbCrPositioning = 0x0213;
|
||||
public const ushort Rating = 0x4746;
|
||||
public const ushort Xmp = 0x02BC;
|
||||
public const ushort Copyright = 0x8298;
|
||||
@@ -50,7 +51,9 @@ public static class TiffTags
|
||||
public const ushort ExposureProgram = 0x8822;
|
||||
public const ushort IsoSpeedRatings = 0x8827;
|
||||
public const ushort SensitivityType = 0x8830;
|
||||
public const ushort StandardOutputSensitivity = 0x8831;
|
||||
public const ushort RecommendedExposureIndex = 0x8832;
|
||||
public const ushort IsoSpeed = 0x8833;
|
||||
public const ushort ExifVersion = 0x9000;
|
||||
public const ushort DateTimeOriginal = 0x9003;
|
||||
public const ushort DateTimeDigitized = 0x9004;
|
||||
@@ -78,6 +81,7 @@ public static class TiffTags
|
||||
public const ushort LensModel = 0xA434;
|
||||
|
||||
// GPS
|
||||
public const ushort GpsVersionId = 0x0000;
|
||||
public const ushort GpsLatitudeRef = 0x0001;
|
||||
public const ushort GpsLatitude = 0x0002;
|
||||
public const ushort GpsLongitudeRef = 0x0003;
|
||||
@@ -85,6 +89,7 @@ public static class TiffTags
|
||||
public const ushort GpsAltitudeRef = 0x0005;
|
||||
public const ushort GpsAltitude = 0x0006;
|
||||
public const ushort GpsTimeStamp = 0x0007;
|
||||
public const ushort GpsStatus = 0x0009;
|
||||
public const ushort GpsDateStamp = 0x001D;
|
||||
|
||||
// DNG
|
||||
|
||||
Reference in new issue
Block a user