p
/
fiv
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
fiv/tools/info.h

1268 lines
34 KiB
C
Raw Blame History

//
// info.h: metadata extraction utilities
//
// Copyright (c) 2021, Přemysl Eric Janouch <p@janouch.name>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
#include <jv.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
// --- Utilities ---------------------------------------------------------------
static char *
binhex(const uint8_t *data, size_t len)
{
static const char *alphabet = "0123456789abcdef";
char *buf = calloc(1, len * 2 + 1), *p = buf;
for (size_t i = 0; i < len; i++) {
*p++ = alphabet[data[i] >> 4];
*p++ = alphabet[data[i] & 0xF];
}
return buf;
}
static uint32_t
u32be(const uint8_t *p)
{
return (uint32_t) p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
}
static uint16_t
u16be(const uint8_t *p)
{
return (uint16_t) p[0] << 8 | p[1];
}
static uint32_t
u32le(const uint8_t *p)
{
return (uint32_t) p[3] << 24 | p[2] << 16 | p[1] << 8 | p[0];
}
static uint16_t
u16le(const uint8_t *p)
{
return (uint16_t) p[1] << 8 | p[0];
}
// --- TIFF --------------------------------------------------------------------
// TIFF Revision 6.0 (1992)
// https://www.adobe.io/content/dam/udp/en/open/standards/tiff/TIFF6.pdf
//
// TIFF Technical Note 1: TIFF Trees (1993)
// https://download.osgeo.org/libtiff/old/TTN1.ps
//
// DRAFT TIFF Technical Note 2 (1995)
// https://www.awaresystems.be/imaging/tiff/specification/TIFFTechNote2.txt
//
// Adobe PageMaker 6.0 TIFF Technical Notes (1995) [includes TTN1]
// https://www.adobe.io/content/dam/udp/en/open/standards/tiff/TIFFPM6.pdf
//
// Adobe Photoshop TIFF Technical Notes (2002)
// https://www.adobe.io/content/dam/udp/en/open/standards/tiff/TIFFphotoshop.pdf
// - Note that ImageSourceData 8BIM frames are specified differently
// from how Adobe XMP Specification Part 3 defines them.
// - The document places a condition on SubIFDs, without further explanation.
//
// Adobe Photoshop TIFF Technical Note 3 (2005)
// http://chriscox.org/TIFFTN3d1.pdf
//
// Exif Version 2.3 (2012)
// https://www.cipa.jp/std/documents/e/DC-008-2012_E.pdf
//
// Exif Version 2.32 (2019)
// https://www.cipa.jp/e/std/std-sec.html
//
// libtiff is a mess, and the format is not particularly complicated.
// Exiv2 is senselessly copylefted, and cannot do much.
// libexif is only marginally better.
// ExifTool is too user-oriented.
static struct un {
uint32_t (*u32) (const uint8_t *);
uint16_t (*u16) (const uint8_t *);
} unbe = {u32be, u16be}, unle = {u32le, u16le};
struct tiffer {
struct un *un;
const uint8_t *begin, *p, *end;
uint16_t remaining_fields;
};
static bool
tiffer_u32(struct tiffer *self, uint32_t *u)
{
if (self->p + 4 > self->end)
return false;
*u = self->un->u32(self->p);
self->p += 4;
return true;
}
static bool
tiffer_u16(struct tiffer *self, uint16_t *u)
{
if (self->p + 2 > self->end)
return false;
*u = self->un->u16(self->p);
self->p += 2;
return true;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
static bool
tiffer_init(struct tiffer *self, const uint8_t *tiff, size_t len)
{
self->un = NULL;
self->begin = self->p = tiff;
self->end = tiff + len;
self->remaining_fields = 0;
const uint8_t
le[4] = {'I', 'I', 42, 0},
be[4] = {'M', 'M', 0, 42};
if (tiff + 8 > self->end)
return false;
else if (!memcmp(tiff, le, sizeof le))
self->un = &unle;
else if (!memcmp(tiff, be, sizeof be))
self->un = &unbe;
else
return false;
self->p = tiff + 4;
// The first IFD needs to be read by caller explicitly,
// even though it's required to be present by TIFF 6.0.
return true;
}
/// Read the next IFD in a sequence.
static bool
tiffer_next_ifd(struct tiffer *self)
{
// All fields from any previous IFD need to be read first.
if (self->remaining_fields)
return false;
uint32_t ifd_offset = 0;
if (!tiffer_u32(self, &ifd_offset))
return false;
// There is nothing more to read, this chain has terminated.
if (!ifd_offset)
return false;
// Note that TIFF 6.0 requires there to be at least one entry,
// but there is no need for us to check it.
self->p = self->begin + ifd_offset;
return tiffer_u16(self, &self->remaining_fields);
}
/// Initialize a derived TIFF reader for a subIFD at the given location.
static bool
tiffer_subifd(struct tiffer *self, uint32_t offset, struct tiffer *subreader)
{
*subreader = *self;
subreader->p = subreader->begin + offset;
return tiffer_u16(subreader, &subreader->remaining_fields);
}
enum tiffer_type {
BYTE = 1, ASCII, SHORT, LONG, RATIONAL,
SBYTE, UNDEFINED, SSHORT, SLONG, SRATIONAL, FLOAT, DOUBLE,
IFD // This last type from TIFF Technical Note 1 isn't really used much.
};
static size_t
tiffer_value_size(enum tiffer_type type)
{
switch (type) {
case BYTE:
case SBYTE:
case ASCII:
case UNDEFINED:
return 1;
case SHORT:
case SSHORT:
return 2;
case LONG:
case SLONG:
case FLOAT:
case IFD:
return 4;
case RATIONAL:
case SRATIONAL:
case DOUBLE:
return 8;
default:
return 0;
}
}
/// A lean iterator for values within entries.
struct tiffer_entry {
uint16_t tag;
enum tiffer_type type;
// For {S,}BYTE, ASCII, UNDEFINED, use these fields directly.
const uint8_t *p;
uint32_t remaining_count;
};
static bool
tiffer_next_value(struct tiffer_entry *entry)
{
if (!entry->remaining_count)
return false;
entry->p += tiffer_value_size(entry->type);
entry->remaining_count--;
return true;
}
static bool
tiffer_integer(
const struct tiffer *self, const struct tiffer_entry *entry, int64_t *out)
{
if (!entry->remaining_count)
return false;
// Somewhat excessively lenient, intended for display.
// TIFF 6.0 only directly suggests that a reader is should accept
// any of BYTE/SHORT/LONG for unsigned integers.
switch (entry->type) {
case BYTE:
case ASCII:
case UNDEFINED:
*out = *entry->p;
return true;
case SBYTE:
*out = (int8_t) *entry->p;
return true;
case SHORT:
*out = self->un->u16(entry->p);
return true;
case SSHORT:
*out = (int16_t) self->un->u16(entry->p);
return true;
case LONG:
case IFD:
*out = self->un->u32(entry->p);
return true;
case SLONG:
*out = (int32_t) self->un->u32(entry->p);
return true;
default:
return false;
}
}
static bool
tiffer_rational(const struct tiffer *self, const struct tiffer_entry *entry,
int64_t *numerator, int64_t *denominator)
{
if (!entry->remaining_count)
return false;
// Somewhat excessively lenient, intended for display.
switch (entry->type) {
case RATIONAL:
*numerator = self->un->u32(entry->p);
*denominator = self->un->u32(entry->p + 4);
return true;
case SRATIONAL:
*numerator = (int32_t) self->un->u32(entry->p);
*denominator = (int32_t) self->un->u32(entry->p + 4);
return true;
default:
if (tiffer_integer(self, entry, numerator)) {
*denominator = 1;
return true;
}
return false;
}
}
static bool
tiffer_real(
const struct tiffer *self, const struct tiffer_entry *entry, double *out)
{
if (!entry->remaining_count)
return false;
// Somewhat excessively lenient, intended for display.
// Assuming the host architecture uses IEEE 754.
switch (entry->type) {
int64_t numerator, denominator;
case FLOAT:
*out = *(float *) entry->p;
return true;
case DOUBLE:
*out = *(double *) entry->p;
return true;
default:
if (tiffer_rational(self, entry, &numerator, &denominator)) {
*out = (double) numerator / denominator;
return true;
}
return false;
}
}
static bool
tiffer_next_entry(struct tiffer *self, struct tiffer_entry *entry)
{
if (!self->remaining_fields)
return false;
uint16_t type = entry->type = 0xFFFF;
if (!tiffer_u16(self, &entry->tag) || !tiffer_u16(self, &type) ||
!tiffer_u32(self, &entry->remaining_count))
return false;
// Short values may and will be inlined, rather than pointed to.
size_t values_size = tiffer_value_size(type) * entry->remaining_count;
uint32_t offset = 0;
if (values_size <= sizeof offset) {
entry->p = self->p;
self->p += sizeof offset;
} else if (tiffer_u32(self, &offset)) {
entry->p = self->begin + offset;
} else {
return false;
}
// All entries are pre-checked not to overflow.
if (entry->p + values_size > self->end)
return false;
// Setting it at the end may provide an indication while debugging.
entry->type = type;
self->remaining_fields--;
return true;
}
// --- TIFF/Exif tags ----------------------------------------------------------
struct tiff_value {
const char *name;
uint16_t value;
};
struct tiff_entry {
const char *name;
uint16_t tag;
struct tiff_value *values;
};
static struct tiff_entry tiff_entries[] = {
{"NewSubfileType", 254, NULL},
{"SubfileType", 255, (struct tiff_value[]) {
{"Full-resolution image data", 1},
{"Reduced-resolution image data", 2},
{"Page of a multi-page image", 3},
{}
}},
{"ImageWidth", 256, NULL},
{"ImageLength", 257, NULL},
{"BitsPerSample", 258, NULL},
{"Compression", 259, (struct tiff_value[]) {
{"Uncompressed", 1},
{"CCITT 1D", 2},
{"Group 3 Fax", 3},
{"Group 4 Fax", 4},
{"LZW", 5},
{"JPEG", 6},
{"JPEG datastream", 7}, // DRAFT TIFF Technical Note 2 + TIFFphotoshop
{"Deflate/zlib", 8}, // Adobe Photoshop TIFF Technical Notes
{"PackBits", 32773},
{"Deflate/zlib", 32946}, // Adobe Photoshop TIFF Technical Notes
{}
}},
{"PhotometricInterpretation", 262, (struct tiff_value[]) {
{"WhiteIsZero", 0},
{"BlackIsZero", 1},
{"RGB", 2},
{"RGB Palette", 3},
{"Transparency mask", 4},
{"CMYK", 5},
{"YCbCr", 6},
{"CIELab", 8},
{"ICCLab", 9}, // Adobe PageMaker 6.0 TIFF Technical Notes
{}
}},
{"Threshholding", 263, (struct tiff_value[]) {
{"No dithering or halftoning", 1},
{"Ordered dither or halftoning", 2},
{"Randomized process", 3},
{}
}},
{"CellWidth", 264, NULL},
{"CellLength", 265, NULL},
{"FillOrder", 266, (struct tiff_value[]) {
{"MSB-first", 1},
{"LSB-first", 2},
{}
}},
{"DocumentName", 269, NULL},
{"ImageDescription", 270, NULL},
{"Make", 271, NULL},
{"Model", 272, NULL},
{"StripOffsets", 273, NULL},
{"Orientation", 274, (struct tiff_value[]) {
{"TopLeft", 1},
{"TopRight", 2},
{"BottomRight", 3},
{"BottomLeft", 4},
{"LeftTop", 5},
{"RightTop", 6},
{"RightBottom", 7},
{"LeftBottom", 8},
{}
}},
{"SamplesPerPixel", 277, NULL},
{"RowsPerStrip", 278, NULL},
{"StripByteCounts", 279, NULL},
{"MinSampleValue", 280, NULL},
{"MaxSampleValue", 281, NULL},
{"XResolution", 282, NULL},
{"YResolution", 283, NULL},
{"PlanarConfiguration", 284, (struct tiff_value[]) {
{"Chunky", 1},
{"Planar", 2},
{}
}},
{"PageName", 285, NULL},
{"XPosition", 286, NULL},
{"YPosition", 287, NULL},
{"FreeOffsets", 288, NULL},
{"FreeByteCounts", 289, NULL},
{"GrayResponseUnit", 290, (struct tiff_value[]) {
{"1/10", 1},
{"1/100", 2},
{"1/1000", 3},
{"1/10000", 4},
{"1/100000", 5},
{}
}},
{"GrayResponseCurve", 291, NULL},
{"T4Options", 292, NULL},
{"T6Options", 293, NULL},
{"ResolutionUnit", 296, (struct tiff_value[]) {
{"None", 1},
{"Inch", 2},
{"Centimeter", 3},
{}
}},
{"PageNumber", 297, NULL},
{"TransferFunction", 301, NULL},
{"Software", 305, NULL},
{"DateTime", 306, NULL},
{"Artist", 315, NULL},
{"HostComputer", 316, NULL},
{"Predictor", 317, (struct tiff_value[]) {
{"None", 1},
{"Horizontal", 2},
{"Floating point", 3}, // Adobe Photoshop TIFF Technical Note 3
{}
}},
{"WhitePoint", 318, NULL},
{"PrimaryChromaticities", 319, NULL},
{"ColorMap", 320, NULL},
{"HalftoneHints", 321, NULL},
{"TileWidth", 322, NULL},
{"TileLength", 323, NULL},
{"TileOffsets", 324, NULL},
{"TileByteCounts", 325, NULL},
{"SubIFDs", 330, NULL}, // TIFF Technical Note 1: TIFF Trees
{"InkSet", 332, (struct tiff_value[]) {
{"CMYK", 1},
{"Non-CMYK", 2},
{}
}},
{"InkNames", 333, NULL},
{"NumberOfInks", 334, NULL},
{"DotRange", 336, NULL},
{"TargetPrinter", 337, NULL},
{"ExtraSamples", 338, (struct tiff_value[]) {
{"Unspecified", 0},
{"Associated alpha", 1},
{"Unassociated alpha", 2},
{}
}},
{"SampleFormat", 339, (struct tiff_value[]) {
{"Unsigned integer", 1},
{"Two's complement signed integer", 2},
{"IEEE floating-point", 3},
{"Undefined", 4},
{}
}},
{"SMinSampleValue", 340, NULL},
{"SMaxSampleValue", 341, NULL},
{"TransferRange", 342, NULL},
{"ClipPath", 343, NULL}, // TIFF Technical Note 2: Clipping Path
{"XClipPathUnits", 344, NULL}, // TIFF Technical Note 2: Clipping Path
{"YClipPathUnits", 345, NULL}, // TIFF Technical Note 2: Clipping Path
{"Indexed", 346, NULL}, // TIFF Technical Note 3: Indexed Images
{"JPEGTables", 347, NULL}, // DRAFT TIFF Technical Note 2 + TIFFphotoshop
{"OPIProxy", 351, NULL}, // Adobe PageMaker 6.0 TIFF Technical Notes
{"JPEGProc", 512, (struct tiff_value[]) {
{"Baseline sequential", 1},
{"Lossless Huffman", 14},
{}
}},
{"JPEGInterchangeFormat", 513, NULL},
{"JPEGInterchangeFormatLength", 514, NULL},
{"JPEGRestartInterval", 515, NULL},
{"JPEGLosslessPredictors", 517, (struct tiff_value[]) {
{"A", 1},
{"B", 2},
{"C", 3},
{"A+B+C", 4},
{"A+((B-C)/2)", 5},
{"B+((A-C)/2)", 6},
{"(A+B)/2", 7},
{}
}},
{"JPEGPointTransforms", 518, NULL},
{"JPEGQTables", 519, NULL},
{"JPEGDCTables", 520, NULL},
{"JPEGACTables", 521, NULL},
{"YCbCrCoefficients", 529, NULL},
{"YCbCrSubSampling", 530, NULL},
{"YCbCrPositioning", 531, (struct tiff_value[]) {
{"Centered", 1},
{"Co-sited", 2},
{}
}},
{"ReferenceBlackWhite", 532, NULL},
{"XMP", 700, NULL}, // Adobe XMP Specification Part 3 Table 12/13/39
{"ImageID", 32781, NULL}, // Adobe PageMaker 6.0 TIFF Technical Notes
{"Copyright", 33432, NULL},
// TODO(p): Extract IPTC DataSets, like we do directly with PSIRs.
{"IPTC", 33723, NULL}, // Adobe XMP Specification Part 3 Table 12/39
// TODO(p): Extract PSIRs, like we do directly with the JPEG segment.
{"Photoshop", 34377, NULL}, // Adobe XMP Specification Part 3 Table 12/39
{"Exif IFD Pointer", 34665, NULL}, // Exif 2.3
{"GPS Info IFD Pointer", 34853, NULL}, // Exif 2.3
{"ImageSourceData", 37724, NULL}, // Adobe Photoshop TIFF Technical Notes
{}
};
// Exif 2.3 4.6.5
static struct tiff_entry exif_entries[] = {
{"ExposureTime", 33434, NULL},
{"FNumber", 33437, NULL},
{"ExposureProgram", 34850, (struct tiff_value[]) {
{"Not defined", 0},
{"Manual", 1},
{"Normal program", 2},
{"Aperture priority", 3},
{"Shutter priority", 4},
{"Creative program", 5},
{"Action program", 6},
{"Portrait mode", 7},
{"Landscape mode", 8},
{}
}},
{"SpectralSensitivity", 34852, NULL},
{"PhotographicSensitivity", 34855, NULL},
{"OECF", 34856, NULL},
{"SensitivityType", 34864, (struct tiff_value[]) {
{"Unknown", 0},
{"Standard output sensitivity", 1},
{"Recommended exposure index", 2},
{"ISO speed", 3},
{"SOS and REI", 4},
{"SOS and ISO speed", 5},
{"REI and ISO speed", 6},
{"SOS and REI and ISO speed", 7},
{}
}},
{"StandardOutputSensitivity", 34865, NULL},
{"RecommendedExposureIndex", 34866, NULL},
{"ISOSpeed", 34867, NULL},
{"ISOSpeedLatitudeyyy", 34868, NULL},
{"ISOSpeedLatitudezzz", 34869, NULL},
{"ExifVersion", 36864, NULL},
{"DateTimeOriginal", 36867, NULL},
{"DateTimeDigitized", 36868, NULL},
{"OffsetTime", 36880, NULL}, // 2.31
{"OffsetTimeOriginal", 36881, NULL}, // 2.31
{"OffsetTimeDigitized", 36882, NULL}, // 2.31
{"ComponentsConfiguration", 37121, (struct tiff_value[]) {
{"Does not exist", 0},
{"Y", 1},
{"Cb", 2},
{"Cr", 3},
{"R", 4},
{"G", 5},
{"B", 6},
{}
}},
{"CompressedBitsPerPixel", 37122, NULL},
{"ShutterSpeedValue", 37377, NULL},
{"ApertureValue", 37378, NULL},
{"BrightnessValue", 37379, NULL},
{"ExposureBiasValue", 37380, NULL},
{"MaxApertureValue", 37381, NULL},
{"SubjectDistance", 37382, NULL},
{"MeteringMode", 37383, (struct tiff_value[]) {
{"Unknown", 0},
{"Average", 1},
{"CenterWeightedAverage", 2},
{"Spot", 3},
{"MultiSpot", 4},
{"Pattern", 5},
{"Partial", 6},
{"Other", 255},
{}
}},
{"LightSource", 37384, (struct tiff_value[]) {
{"Unknown", 0},
{"Daylight", 1},
{"Fluorescent", 2},
{"Tungsten (incandescent light)", 3},
{"Flash", 4},
{"Fine weather", 9},
{"Cloudy weather", 10},
{"Shade", 11},
{"Daylight fluorescent (D 5700 - 7100K)", 12},
{"Day white fluorescent (N 4600 - 5500K)", 13},
{"Cool white fluorescent (W 3800 - 4500K)", 14},
{"White fluorescent (WW 3250 - 3800K)", 15},
{"Warm white fluorescent (L 2600 - 3250K)", 16},
{"Standard light A", 17},
{"Standard light B", 18},
{"Standard light C", 19},
{"D55", 20},
{"D65", 21},
{"D75", 22},
{"D50", 23},
{"ISO studio tungsten", 24},
{"Other light source", 255},
{}
}},
{"Flash", 37385, NULL},
{"FocalLength", 37386, NULL},
{"SubjectArea", 37396, NULL},
{"MakerNote", 37500, NULL},
// TODO(p): Decode.
{"UserComment", 37510, NULL},
{"SubSecTime", 37520, NULL},
{"SubSecTimeOriginal", 37521, NULL},
{"SubSecTimeDigitized", 37522, NULL},
{"Temperature", 37888, NULL}, // 2.31
{"Humidity", 37889, NULL}, // 2.31
{"Pressure", 37890, NULL}, // 2.31
{"WaterDepth", 37891, NULL}, // 2.31
{"Acceleration", 37892, NULL}, // 2.31
{"CameraElevationAngle", 37893, NULL}, // 2.31
{"FlashpixVersion", 40960, NULL},
{"ColorSpace", 40961, (struct tiff_value[]) {
{"sRGB", 1},
{"Uncalibrated", 0xFFFF},
{}
}},
{"PixelXDimension", 40962, NULL},
{"PixelYDimension", 40963, NULL},
{"RelatedSoundFile", 40964, NULL},
{"Interoperability IFD Pointer", 40965, NULL},
{"FlashEnergy", 41483, NULL},
{"SpatialFrequencyResponse", 41484, NULL},
{"FocalPlaneXResolution", 41486, NULL},
{"FocalPlaneYResolution", 41487, NULL},
{"FocalPlaneResolutionUnit", 41488, NULL},
{"SubjectLocation", 41492, NULL},
{"ExposureIndex", 41493, NULL},
{"SensingMethod", 41495, (struct tiff_value[]) {
{"Not defined", 1},
{"One-chip color area sensor", 2},
{"Two-chip color area sensor", 3},
{"Three-chip color area sensor", 4},
{"Color sequential area sensor", 5},
{"Trilinear sensor", 7},
{"Color sequential linear sensor", 8},
{}
}},
{"FileSource", 41728, (struct tiff_value[]) {
{"Others", 0},
{"Scanner of transparent type", 1},
{"Scanner of reflex type", 2},
{"DSC", 3},
{}
}},
{"SceneType", 41729, (struct tiff_value[]) {
{"Directly-photographed image", 1},
{}
}},
{"CFAPattern", 41730, NULL},
{"CustomRendered", 41985, (struct tiff_value[]) {
{"Normal process", 0},
{"Custom process", 1},
{}
}},
{"ExposureMode", 41986, (struct tiff_value[]) {
{"Auto exposure", 0},
{"Manual exposure", 1},
{"Auto bracket", 2},
{}
}},
{"WhiteBalance", 41987, (struct tiff_value[]) {
{"Auto white balance", 0},
{"Manual white balance", 1},
{}
}},
{"DigitalZoomRatio", 41988, NULL},
{"FocalLengthIn35mmFilm", 41989, NULL},
{"SceneCaptureType", 41990, (struct tiff_value[]) {
{"Standard", 0},
{"Landscape", 1},
{"Portrait", 2},
{"Night scene", 3},
{}
}},
{"GainControl", 41991, (struct tiff_value[]) {
{"None", 0},
{"Low gain up", 1},
{"High gain up", 2},
{"Low gain down", 3},
{"High gain down", 4},
{}
}},
{"Contrast", 41992, (struct tiff_value[]) {
{"Normal", 0},
{"Soft", 1},
{"Hard", 2},
{}
}},
{"Saturation", 41993, (struct tiff_value[]) {
{"Normal", 0},
{"Low", 1},
{"High", 2},
{}
}},
{"Sharpness", 41994, (struct tiff_value[]) {
{"Normal", 0},
{"Soft", 1},
{"Hard", 2},
{}
}},
{"DeviceSettingDescription", 41995, NULL},
{"SubjectDistanceRange", 41996, (struct tiff_value[]) {
{"Unknown", 0},
{"Macro", 1},
{"Close view", 2},
{"Distant view", 3},
{}
}},
{"ImageUniqueID", 42016, NULL},
{"CameraOwnerName", 42032, NULL},
{"BodySerialNumber", 42033, NULL},
{"LensSpecification", 42034, NULL},
{"LensMake", 42035, NULL},
{"LensModel", 42036, NULL},
{"LensSerialNumber", 42037, NULL},
{"CompositeImage", 42080, NULL}, // 2.32
{"SourceImageNumberOfCompositeImage", 42081, NULL}, // 2.32
{"SourceExposureTimesOfCompositeImage", 42082, NULL}, // 2.32
{"Gamma", 42240, NULL},
{}
};
// Exif 2.3 4.6.6 (Notice it starts at 0.)
static struct tiff_entry exif_gps_entries[] = {
{"GPSVersionID", 0, NULL},
{"GPSLatitudeRef", 1, NULL},
{"GPSLatitude", 2, NULL},
{"GPSLongitudeRef", 3, NULL},
{"GPSLongitude", 4, NULL},
{"GPSAltitudeRef", 5, (struct tiff_value[]) {
{"Sea level", 0},
{"Sea level reference (negative value)", 1},
{}
}},
{"GPSAltitude", 6, NULL},
{"GPSTimeStamp", 7, NULL},
{"GPSSatellites", 8, NULL},
{"GPSStatus", 9, NULL},
{"GPSMeasureMode", 10, NULL},
{"GPSDOP", 11, NULL},
{"GPSSpeedRef", 12, NULL},
{"GPSSpeed", 13, NULL},
{"GPSTrackRef", 14, NULL},
{"GPSTrack", 15, NULL},
{"GPSImgDirectionRef", 16, NULL},
{"GPSImgDirection", 17, NULL},
{"GPSMapDatum", 18, NULL},
{"GPSDestLatitudeRef", 19, NULL},
{"GPSDestLatitude", 20, NULL},
{"GPSDestLongitudeRef", 21, NULL},
{"GPSDestLongitude", 22, NULL},
{"GPSDestBearingRef", 23, NULL},
{"GPSDestBearing", 24, NULL},
{"GPSDestDistanceRef", 25, NULL},
{"GPSDestDistance", 26, NULL},
{"GPSProcessingMethod", 27, NULL},
{"GPSAreaInformation", 28, NULL},
{"GPSDateStamp", 29, NULL},
{"GPSDifferential", 30, (struct tiff_value[]) {
{"Measurement without differential correction", 0},
{"Differential correction applied", 1},
{}
}},
{"GPSHPositioningError", 31, NULL},
{}
};
// Exif 2.3 4.6.7 (Notice it starts at 1, and collides with GPS.)
static struct tiff_entry exif_interop_entries[] = {
{"InteroperabilityIndex", 1, NULL},
{}
};
// TODO(p): Consider if these can't be inlined into `tiff_entries`.
static struct {
uint16_t tag;
struct tiff_entry *entries;
} tiff_subifds[] = {
{330, tiff_entries}, // SubIFDs
{34665, exif_entries}, // Exif IFD Pointer
{34853, exif_gps_entries}, // GPS Info IFD Pointer
{40965, exif_interop_entries}, // Interoperability IFD Pointer
{}
};
// --- Analysis ----------------------------------------------------------------
static jv
add_to_subarray(jv o, const char *key, jv value)
{
// Invalid values are not allocated, and we use up any valid one.
// Beware that jv_get() returns jv_null() rather than jv_invalid().
// Also, the header comment is lying, jv_is_valid() doesn't unreference.
jv a = jv_object_get(jv_copy(o), jv_string(key));
return jv_set(o, jv_string(key),
jv_is_valid(a) ? jv_array_append(a, value) : JV_ARRAY(value));
}
static jv
add_warning(jv o, const char *message)
{
return add_to_subarray(o, "warnings", jv_string(message));
}
static jv
add_error(jv o, const char *message)
{
return jv_object_set(o, jv_string("error"), jv_string(message));
}
// --- Exif --------------------------------------------------------------------
static jv parse_exif_ifd(struct tiffer *T, const struct tiff_entry *info);
static jv
parse_exif_subifds(struct tiffer *T, const struct tiffer_entry *entry,
struct tiff_entry *info)
{
int64_t offset = 0;
struct tiffer subT = {};
if (!tiffer_integer(T, entry, &offset) ||
offset < 0 || offset > UINT32_MAX || !tiffer_subifd(T, offset, &subT))
return jv_null();
// The chain should correspond to the values in the entry
// (TIFF Technical Note 1), we are not going to verify it.
// Note that Nikon NEFs do not follow this rule.
jv a = jv_array();
do a = jv_array_append(a, parse_exif_ifd(&subT, info));
while (tiffer_next_ifd(&subT));
return a;
}
static jv
parse_exif_ascii(struct tiffer_entry *entry)
{
// Adobe XMP Specification Part 3: Storage in Files, 2020/1, 2.4.2
// The text may in practice contain any 8-bit encoding, but likely UTF-8.
// TODO(p): Validate UTF-8, and assume Latin 1 if unsuccessful.
jv a = jv_array();
uint8_t *nul = 0;
while ((nul = memchr(entry->p, 0, entry->remaining_count))) {
size_t len = nul - entry->p;
a = jv_array_append(a, jv_string_sized((const char *) entry->p, len));
entry->remaining_count -= len + 1;
entry->p += len + 1;
}
// Trailing NULs are required, but let's extract everything.
if (entry->remaining_count) {
a = jv_array_append(a,
jv_string_sized((const char *) entry->p, entry->remaining_count));
}
return a;
}
static jv
parse_exif_undefined(struct tiffer_entry *entry)
{
// Sometimes, it can be ASCII, but the safe bet is to hex-encode it.
char *buf = binhex(entry->p, entry->remaining_count);
jv s = jv_string(buf);
free(buf);
return s;
}
static jv
parse_exif_value(const struct tiff_value *values, double real)
{
if (values) {
for (; values->name; values++)
if (values->value == real)
return jv_string(values->name);
}
return jv_number(real);
}
static jv
parse_exif_extract_sole_array_element(jv a)
{
return jv_array_length(jv_copy(a)) == 1 ? jv_array_get(a, 0) : a;
}
static jv
parse_exif_entry(jv o, struct tiffer *T, struct tiffer_entry *entry,
const struct tiff_entry *info)
{
if (!info)
info = (struct tiff_entry[]) {{}};
for (; info->name; info++)
if (info->tag == entry->tag)
break;
struct tiff_entry *subentries = NULL;
for (size_t i = 0; tiff_subifds[i].tag; i++)
if (tiff_subifds[i].tag == entry->tag)
subentries = tiff_subifds[i].entries;
jv v = jv_true();
double real = 0;
if (!entry->remaining_count) {
v = jv_null();
} else if (entry->type == IFD || subentries) {
v = parse_exif_subifds(T, entry, subentries);
} else if (entry->type == ASCII) {
v = parse_exif_extract_sole_array_element(parse_exif_ascii(entry));
} else if (entry->type == UNDEFINED && !info->values) {
// Several Exif entries of UNDEFINED type contain single-byte numbers.
v = parse_exif_undefined(entry);
} else if (tiffer_real(T, entry, &real)) {
v = jv_array();
do v = jv_array_append(v, parse_exif_value(info->values, real));
while (tiffer_next_value(entry) && tiffer_real(T, entry, &real));
v = parse_exif_extract_sole_array_element(v);
}
if (info->name)
return jv_set(o, jv_string(info->name), v);
return jv_set(o, jv_string_fmt("%u", entry->tag), v);
}
static jv
parse_exif_ifd(struct tiffer *T, const struct tiff_entry *info)
{
jv ifd = jv_object();
struct tiffer_entry entry = {};
while (tiffer_next_entry(T, &entry))
ifd = parse_exif_entry(ifd, T, &entry, info);
return ifd;
}
static jv
parse_exif(jv o, const uint8_t *p, size_t len)
{
struct tiffer T = {};
if (!tiffer_init(&T, p, len))
return add_warning(o, "invalid Exif");
while (tiffer_next_ifd(&T))
o = add_to_subarray(o, "Exif", parse_exif_ifd(&T, tiff_entries));
return o;
}
// --- Photoshop Image Resources -----------------------------------------------
// Adobe XMP Specification Part 3: Storage in Files, 2020/1, 1.1.3 + 3.1.3
// https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/
// Unless otherwise noted, the descriptions are derived from the above document.
static struct {
uint16_t id;
const char *description;
} psir_descriptions[] = {
{1000, "Number of channels, rows, columns, depth, mode"},
{1001, "Macintosh print manager print info record"},
{1002, "Macintosh page format information"},
{1003, "Indexed color table"},
{1005, "Resolution information"},
{1006, "Names of alpha channels (Pascal strings)"},
{1007, "Display information"},
{1008, "Caption (Pascal string)"}, // XMP Part 3 3.3.3
{1009, "Border information"},
{1010, "Background color"},
{1011, "Print flags"},
{1012, "Grayscale and multichannel halftoning information"},
{1013, "Color halftoning information"},
{1014, "Duotone halftoning information"},
{1015, "Grayscale and multichannel transfer function"},
{1016, "Color transfer functions"},
{1017, "Duotone transfer functions"},
{1018, "Duotone image information"},
{1019, "Effective B/W values for the dot range"},
{1020, "Caption"}, // XMP Part 3 3.3.3
{1021, "EPS options"},
{1022, "Quick Mask information"},
{1023, "(Obsolete)"},
{1024, "Layer state information"},
{1025, "Working path (not saved)"},
{1026, "Layers group information"},
{1027, "(Obsolete)"},
{1028, "IPTC DataSets"}, // XMP Part 3 3.3.3
{1029, "Image mode for raw format files"},
{1030, "JPEG quality"},
{1032, "Grid and guides information"},
{1033, "Thumbnail resource"},
{1034, "Copyright flag"},
{1035, "Copyright information URL"}, // XMP Part 3 3.3.3
{1036, "Thumbnail resource"},
{1037, "Global lighting angle for effects layer"},
{1038, "Color samplers information"},
{1039, "ICC profile"},
{1040, "Watermark"},
{1041, "ICC untagged profile flag"},
{1042, "Effects visible flag"},
{1043, "Spot halftone"},
{1044, "Document-specific IDs seed number"},
{1045, "Unicode alpha names"},
{1046, "Indexed color table count"},
{1047, "Transparent color index"},
{1049, "Global altitude"},
{1050, "Slices"},
{1051, "Workflow URL"},
{1052, "Jump To XPEP"},
{1053, "Alpha identifiers"},
{1054, "URL list"},
{1057, "Version info"},
{1058, "Exif metadata 1"},
{1059, "Exif metadata 3"},
{1060, "XMP metadata"},
{1061, "MD5 digest of IPTC data"}, // XMP Part 3 3.3.3
{1062, "Print scale"},
{1064, "Pixel aspect ratio"},
{1065, "Layer comps"},
{1066, "Alternate duotone colors"},
{1067, "Alternate spot colors"},
{1069, "Layer selection IDs"},
{1070, "HDR toning information"},
{1071, "Print info"},
{1072, "Layer group(s) enabled ID"},
{1073, "Color samplers"},
{1074, "Measurement scale"},
{1075, "Timeline information"},
{1076, "Sheet disclosure"},
{1077, "Display information to support floating point colors"},
{1078, "Onion skins"},
{1080, "Count information"},
{1082, "Print information"},
{1083, "Print style"},
{1084, "Macintosh NSPrintInfo"},
{1085, "Windows DEVMODE"},
{1086, "Autosave file path"},
{1087, "Autosave format"},
{1088, "Path selection state"},
// {2000-2997, "Saved paths"},
{2999, "Name of clipping path"},
{3000, "Origin path information"},
// {4000-4999, "Plug-in resource"},
{7000, "Image Ready variables"},
{7001, "Image Ready data sets"},
{7002, "Image Ready default selected state"},
{7003, "Image Ready 7 rollover expanded state"},
{7004, "Image Ready rollover expanded state"},
{7005, "Image Ready save layer settings"},
{7006, "Image Ready version"},
{8000, "Lightroom workflow"},
{10000, "Print flags"},
{}
};
static jv
process_psir_thumbnail(jv res, const uint8_t *data, size_t len)
{
uint32_t format_number = u32be(data + 0);
uint32_t compressed_size = u32be(data + 20);
// TODO(p): Recurse into the thumbnail if it's a JPEG.
jv format = jv_number(format_number);
switch (format_number) {
break; case 0: format = jv_string("kJpegRGB");
break; case 1: format = jv_string("kRawRGB");
}
res = jv_object_merge(res, JV_OBJECT(
jv_string("Format"), format,
jv_string("Width"), jv_number(u32be(data + 4)),
jv_string("Height"), jv_number(u32be(data + 8)),
jv_string("Stride"), jv_number(u32be(data + 12)),
jv_string("TotalSize"), jv_number(u32be(data + 16)),
jv_string("CompressedSize"), jv_number(compressed_size),
jv_string("BitsPerPixel"), jv_number(u16be(data + 24)),
jv_string("Planes"), jv_number(u16be(data + 26))
));
if (28 + compressed_size <= len) {
char *buf = binhex(data + 28, compressed_size);
res = jv_set(res, jv_string("Data"), jv_string(buf));
free(buf);
}
return res;
}
static const char *
process_iptc_dataset(jv *a, const uint8_t **p, size_t len)
{
const uint8_t *header = *p;
if (len < 5)
return "unexpected end of IPTC data";
if (*header != 0x1c)
return "invalid tag marker";
uint8_t record = header[1];
uint8_t dataset = header[2];
uint16_t byte_count = header[3] << 8 | header[4];
// TODO(p): Although highly unlikely to appear, we could decode it.
if (byte_count & 0x8000)
return "unsupported extended DataSet";
if (len - 5 < byte_count)
return "data overrun";
char *buf = binhex(header + 5, byte_count);
*p += 5 + byte_count;
*a = jv_array_append(*a, JV_OBJECT(
jv_string("DataSet"), jv_string_fmt("%u:%u", record, dataset),
jv_string("Data"), jv_string(buf)
));
free(buf);
return NULL;
}
static jv
process_psir_iptc(jv res, const uint8_t *data, size_t len)
{
// https://iptc.org/standards/iim/
// https://iptc.org/std/IIM/4.2/specification/IIMV4.2.pdf
jv a = jv_array();
const uint8_t *end = data + len;
while (data < end) {
const char *err = process_iptc_dataset(&a, &data, end - data);
if (err) {
a = jv_array_append(a, jv_string(err));
break;
}
}
return jv_set(res, jv_string("DataSets"), a);
}
static jv
process_psir(jv o, uint16_t resource_id, const char *name,
const uint8_t *data, size_t len)
{
const char *description = NULL;
if (resource_id >= 2000 && resource_id <= 2997)
description = "Saved paths";
if (resource_id >= 4000 && resource_id <= 4999)
description = "Plug-in resource";
for (size_t i = 0; psir_descriptions[i].id; i++)
if (psir_descriptions[i].id == resource_id)
description = psir_descriptions[i].description;
jv res = JV_OBJECT(
jv_string("name"), jv_string(name),
jv_string("id"), jv_number(resource_id),
jv_string("description"),
description ? jv_string(description) : jv_null(),
jv_string("size"), jv_number(len)
);
// Both are thumbnails, older is BGR, newer is RGB.
if ((resource_id == 1033 || resource_id == 1036) && len >= 28)
res = process_psir_thumbnail(res, data, len);
if (resource_id == 1028)
res = process_psir_iptc(res, data, len);
return add_to_subarray(o, "PSIR", res);
}
static jv
parse_psir_block(jv o, const uint8_t *p, size_t len, size_t *advance)
{
*advance = 0;
if (len < 8 || memcmp(p, "8BIM", 4))
return add_warning(o, "bad PSIR block header");
uint16_t resource_id = u16be(p + 4);
uint8_t name_len = p[6];
const uint8_t *name = &p[7];
// Add one byte for the Pascal-ish string length prefix,
// then another one for padding to make the length even.
size_t name_len_full = (name_len + 2) & ~1U;
size_t resource_len_offset = 6 + name_len_full,
header_len = resource_len_offset + 4;
if (len < header_len)
return add_warning(o, "bad PSIR block header");
uint32_t resource_len = u32be(p + resource_len_offset);
size_t resource_len_padded = (resource_len + 1) & ~1U;
if (resource_len_padded < resource_len ||
len < header_len + resource_len_padded)
return add_warning(o, "runaway PSIR block");
char *cname = calloc(1, name_len_full);
strncpy(cname, (const char *) name, name_len);
o = process_psir(o, resource_id, cname, p + header_len, resource_len);
free(cname);
*advance = header_len + resource_len_padded;
return o;
}
static jv
parse_psir(jv o, const uint8_t *p, size_t len)
{
if (len == 0)
return add_warning(o, "empty PSIR data");
size_t advance = 0;
while (len && (o = parse_psir_block(o, p, len, &advance), advance)) {
p += advance;
len -= advance;
}
return o;
}
Reference in New Issue View Git Blame Copy Permalink