/*-------------------------------------------------------------
tiio_jpg_exif.cpp
Based on source code of a public domain software "Exif Jpeg header manipulation
tool (jhead)" by Matthias Wandel.
For now it is used only for obtaining resolution values.
http://www.sentex.net/~mwandel/jhead/
-------------------------------------------------------------*/
#include "tiio_jpg_exif.h"
#include <iostream>
#include <string.h>
// for debug
#define ShowTags 0
#define DumpExifMap 0
namespace {
typedef unsigned char uchar;
const int BytesPerFormat[] = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8};
//--------------------------------------------------------------------------
// Describes tag values
const int TAG_X_RESOLUTION = 0x011A;
const int TAG_Y_RESOLUTION = 0x011B;
const int TAG_RESOLUTION_UNIT = 0x0128;
#ifdef ReadAllTags
const int TAG_INTEROP_INDEX = 0x0001;
const int TAG_INTEROP_VERSION = 0x0002;
const int TAG_IMAGE_WIDTH = 0x0100;
const int TAG_IMAGE_LENGTH = 0x0101;
const int TAG_BITS_PER_SAMPLE = 0x0102;
const int TAG_COMPRESSION = 0x0103;
const int TAG_PHOTOMETRIC_INTERP = 0x0106;
const int TAG_FILL_ORDER = 0x010A;
const int TAG_DOCUMENT_NAME = 0x010D;
const int TAG_IMAGE_DESCRIPTION = 0x010E;
const int TAG_MAKE = 0x010F;
const int TAG_MODEL = 0x0110;
const int TAG_SRIP_OFFSET = 0x0111;
const int TAG_ORIENTATION = 0x0112;
const int TAG_SAMPLES_PER_PIXEL = 0x0115;
const int TAG_ROWS_PER_STRIP = 0x0116;
const int TAG_STRIP_BYTE_COUNTS = 0x0117;
const int TAG_PLANAR_CONFIGURATION = 0x011C;
const int TAG_TRANSFER_FUNCTION = 0x012D;
const int TAG_SOFTWARE = 0x0131;
const int TAG_DATETIME = 0x0132;
const int TAG_ARTIST = 0x013B;
const int TAG_WHITE_POINT = 0x013E;
const int TAG_PRIMARY_CHROMATICITIES = 0x013F;
const int TAG_TRANSFER_RANGE = 0x0156;
const int TAG_JPEG_PROC = 0x0200;
const int TAG_THUMBNAIL_OFFSET = 0x0201;
const int TAG_THUMBNAIL_LENGTH = 0x0202;
const int TAG_Y_CB_CR_COEFFICIENTS = 0x0211;
const int TAG_Y_CB_CR_SUB_SAMPLING = 0x0212;
const int TAG_Y_CB_CR_POSITIONING = 0x0213;
const int TAG_REFERENCE_BLACK_WHITE = 0x0214;
const int TAG_RELATED_IMAGE_WIDTH = 0x1001;
const int TAG_RELATED_IMAGE_LENGTH = 0x1002;
const int TAG_CFA_REPEAT_PATTERN_DIM = 0x828D;
const int TAG_CFA_PATTERN1 = 0x828E;
const int TAG_BATTERY_LEVEL = 0x828F;
const int TAG_COPYRIGHT = 0x8298;
const int TAG_EXPOSURETIME = 0x829A;
const int TAG_FNUMBER = 0x829D;
const int TAG_IPTC_NAA = 0x83BB;
const int TAG_EXIF_OFFSET = 0x8769;
const int TAG_INTER_COLOR_PROFILE = 0x8773;
const int TAG_EXPOSURE_PROGRAM = 0x8822;
const int TAG_SPECTRAL_SENSITIVITY = 0x8824;
const int TAG_GPSINFO = 0x8825;
const int TAG_ISO_EQUIVALENT = 0x8827;
const int TAG_OECF = 0x8828;
const int TAG_EXIF_VERSION = 0x9000;
const int TAG_DATETIME_ORIGINAL = 0x9003;
const int TAG_DATETIME_DIGITIZED = 0x9004;
const int TAG_COMPONENTS_CONFIG = 0x9101;
const int TAG_CPRS_BITS_PER_PIXEL = 0x9102;
const int TAG_SHUTTERSPEED = 0x9201;
const int TAG_APERTURE = 0x9202;
const int TAG_BRIGHTNESS_VALUE = 0x9203;
const int TAG_EXPOSURE_BIAS = 0x9204;
const int TAG_MAXAPERTURE = 0x9205;
const int TAG_SUBJECT_DISTANCE = 0x9206;
const int TAG_METERING_MODE = 0x9207;
const int TAG_LIGHT_SOURCE = 0x9208;
const int TAG_FLASH = 0x9209;
const int TAG_FOCALLENGTH = 0x920A;
const int TAG_SUBJECTAREA = 0x9214;
const int TAG_MAKER_NOTE = 0x927C;
const int TAG_USERCOMMENT = 0x9286;
const int TAG_SUBSEC_TIME = 0x9290;
const int TAG_SUBSEC_TIME_ORIG = 0x9291;
const int TAG_SUBSEC_TIME_DIG = 0x9292;
const int TAG_WINXP_TITLE = 0x9c9b; // Windows XP - not part of exif standard.
const int TAG_WINXP_COMMENT =
0x9c9c; // Windows XP - not part of exif standard.
const int TAG_WINXP_AUTHOR = 0x9c9d; // Windows XP - not part of exif standard.
const int TAG_WINXP_KEYWORDS =
0x9c9e; // Windows XP - not part of exif standard.
const int TAG_WINXP_SUBJECT =
0x9c9f; // Windows XP - not part of exif standard.
const int TAG_FLASH_PIX_VERSION = 0xA000;
const int TAG_COLOR_SPACE = 0xA001;
const int TAG_PIXEL_X_DIMENSION = 0xA002;
const int TAG_PIXEL_Y_DIMENSION = 0xA003;
const int TAG_RELATED_AUDIO_FILE = 0xA004;
const int TAG_INTEROP_OFFSET = 0xA005;
const int TAG_FLASH_ENERGY = 0xA20B;
const int TAG_SPATIAL_FREQ_RESP = 0xA20C;
const int TAG_FOCAL_PLANE_XRES = 0xA20E;
const int TAG_FOCAL_PLANE_YRES = 0xA20F;
const int TAG_FOCAL_PLANE_UNITS = 0xA210;
const int TAG_SUBJECT_LOCATION = 0xA214;
const int TAG_EXPOSURE_INDEX = 0xA215;
const int TAG_SENSING_METHOD = 0xA217;
const int TAG_FILE_SOURCE = 0xA300;
const int TAG_SCENE_TYPE = 0xA301;
const int TAG_CFA_PATTERN = 0xA302;
const int TAG_CUSTOM_RENDERED = 0xA401;
const int TAG_EXPOSURE_MODE = 0xA402;
const int TAG_WHITEBALANCE = 0xA403;
const int TAG_DIGITALZOOMRATIO = 0xA404;
const int TAG_FOCALLENGTH_35MM = 0xA405;
const int TAG_SCENE_CAPTURE_TYPE = 0xA406;
const int TAG_GAIN_CONTROL = 0xA407;
const int TAG_CONTRAST = 0xA408;
const int TAG_SATURATION = 0xA409;
const int TAG_SHARPNESS = 0xA40A;
const int TAG_DISTANCE_RANGE = 0xA40C;
const int TAG_IMAGE_UNIQUE_ID = 0xA420;
#endif
typedef struct {
unsigned short Tag;
const char *Desc;
} TagTable_t;
const TagTable_t TagTable[] = {
{TAG_X_RESOLUTION, "XResolution"},
{TAG_Y_RESOLUTION, "YResolution"},
{TAG_RESOLUTION_UNIT, "ResolutionUnit"},
#ifdef ReadAllTags
{TAG_INTEROP_INDEX, "InteropIndex"},
{TAG_INTEROP_VERSION, "InteropVersion"},
{TAG_IMAGE_WIDTH, "ImageWidth"},
{TAG_IMAGE_LENGTH, "ImageLength"},
{TAG_BITS_PER_SAMPLE, "BitsPerSample"},
{TAG_COMPRESSION, "Compression"},
{TAG_PHOTOMETRIC_INTERP, "PhotometricInterpretation"},
{TAG_FILL_ORDER, "FillOrder"},
{TAG_DOCUMENT_NAME, "DocumentName"},
{TAG_IMAGE_DESCRIPTION, "ImageDescription"},
{TAG_MAKE, "Make"},
{TAG_MODEL, "Model"},
{TAG_SRIP_OFFSET, "StripOffsets"},
{TAG_ORIENTATION, "Orientation"},
{TAG_SAMPLES_PER_PIXEL, "SamplesPerPixel"},
{TAG_ROWS_PER_STRIP, "RowsPerStrip"},
{TAG_STRIP_BYTE_COUNTS, "StripByteCounts"},
{TAG_PLANAR_CONFIGURATION, "PlanarConfiguration"},
{TAG_TRANSFER_FUNCTION, "TransferFunction"},
{TAG_SOFTWARE, "Software"},
{TAG_DATETIME, "DateTime"},
{TAG_ARTIST, "Artist"},
{TAG_WHITE_POINT, "WhitePoint"},
{TAG_PRIMARY_CHROMATICITIES, "PrimaryChromaticities"},
{TAG_TRANSFER_RANGE, "TransferRange"},
{TAG_JPEG_PROC, "JPEGProc"},
{TAG_THUMBNAIL_OFFSET, "ThumbnailOffset"},
{TAG_THUMBNAIL_LENGTH, "ThumbnailLength"},
{TAG_Y_CB_CR_COEFFICIENTS, "YCbCrCoefficients"},
{TAG_Y_CB_CR_SUB_SAMPLING, "YCbCrSubSampling"},
{TAG_Y_CB_CR_POSITIONING, "YCbCrPositioning"},
{TAG_REFERENCE_BLACK_WHITE, "ReferenceBlackWhite"},
{TAG_RELATED_IMAGE_WIDTH, "RelatedImageWidth"},
{TAG_RELATED_IMAGE_LENGTH, "RelatedImageLength"},
{TAG_CFA_REPEAT_PATTERN_DIM, "CFARepeatPatternDim"},
{TAG_CFA_PATTERN1, "CFAPattern"},
{TAG_BATTERY_LEVEL, "BatteryLevel"},
{TAG_COPYRIGHT, "Copyright"},
{TAG_EXPOSURETIME, "ExposureTime"},
{TAG_FNUMBER, "FNumber"},
{TAG_IPTC_NAA, "IPTC/NAA"},
{TAG_EXIF_OFFSET, "ExifOffset"},
{TAG_INTER_COLOR_PROFILE, "InterColorProfile"},
{TAG_EXPOSURE_PROGRAM, "ExposureProgram"},
{TAG_SPECTRAL_SENSITIVITY, "SpectralSensitivity"},
{TAG_GPSINFO, "GPS Dir offset"},
{TAG_ISO_EQUIVALENT, "ISOSpeedRatings"},
{TAG_OECF, "OECF"},
{TAG_EXIF_VERSION, "ExifVersion"},
{TAG_DATETIME_ORIGINAL, "DateTimeOriginal"},
{TAG_DATETIME_DIGITIZED, "DateTimeDigitized"},
{TAG_COMPONENTS_CONFIG, "ComponentsConfiguration"},
{TAG_CPRS_BITS_PER_PIXEL, "CompressedBitsPerPixel"},
{TAG_SHUTTERSPEED, "ShutterSpeedValue"},
{TAG_APERTURE, "ApertureValue"},
{TAG_BRIGHTNESS_VALUE, "BrightnessValue"},
{TAG_EXPOSURE_BIAS, "ExposureBiasValue"},
{TAG_MAXAPERTURE, "MaxApertureValue"},
{TAG_SUBJECT_DISTANCE, "SubjectDistance"},
{TAG_METERING_MODE, "MeteringMode"},
{TAG_LIGHT_SOURCE, "LightSource"},
{TAG_FLASH, "Flash"},
{TAG_FOCALLENGTH, "FocalLength"},
{TAG_MAKER_NOTE, "MakerNote"},
{TAG_USERCOMMENT, "UserComment"},
{TAG_SUBSEC_TIME, "SubSecTime"},
{TAG_SUBSEC_TIME_ORIG, "SubSecTimeOriginal"},
{TAG_SUBSEC_TIME_DIG, "SubSecTimeDigitized"},
{TAG_WINXP_TITLE, "Windows-XP Title"},
{TAG_WINXP_COMMENT, "Windows-XP comment"},
{TAG_WINXP_AUTHOR, "Windows-XP author"},
{TAG_WINXP_KEYWORDS, "Windows-XP keywords"},
{TAG_WINXP_SUBJECT, "Windows-XP subject"},
{TAG_FLASH_PIX_VERSION, "FlashPixVersion"},
{TAG_COLOR_SPACE, "ColorSpace"},
{TAG_PIXEL_X_DIMENSION, "ExifImageWidth"},
{TAG_PIXEL_Y_DIMENSION, "ExifImageLength"},
{TAG_RELATED_AUDIO_FILE, "RelatedAudioFile"},
{TAG_INTEROP_OFFSET, "InteroperabilityOffset"},
{TAG_FLASH_ENERGY, "FlashEnergy"},
{TAG_SPATIAL_FREQ_RESP, "SpatialFrequencyResponse"},
{TAG_FOCAL_PLANE_XRES, "FocalPlaneXResolution"},
{TAG_FOCAL_PLANE_YRES, "FocalPlaneYResolution"},
{TAG_FOCAL_PLANE_UNITS, "FocalPlaneResolutionUnit"},
{TAG_SUBJECT_LOCATION, "SubjectLocation"},
{TAG_EXPOSURE_INDEX, "ExposureIndex"},
{TAG_SENSING_METHOD, "SensingMethod"},
{TAG_FILE_SOURCE, "FileSource"},
{TAG_SCENE_TYPE, "SceneType"},
{TAG_CFA_PATTERN, "CFA Pattern"},
{TAG_CUSTOM_RENDERED, "CustomRendered"},
{TAG_EXPOSURE_MODE, "ExposureMode"},
{TAG_WHITEBALANCE, "WhiteBalance"},
{TAG_DIGITALZOOMRATIO, "DigitalZoomRatio"},
{TAG_FOCALLENGTH_35MM, "FocalLengthIn35mmFilm"},
{TAG_SUBJECTAREA, "SubjectArea"},
{TAG_SCENE_CAPTURE_TYPE, "SceneCaptureType"},
{TAG_GAIN_CONTROL, "GainControl"},
{TAG_CONTRAST, "Contrast"},
{TAG_SATURATION, "Saturation"},
{TAG_SHARPNESS, "Sharpness"},
{TAG_DISTANCE_RANGE, "SubjectDistanceRange"},
{TAG_IMAGE_UNIQUE_ID, "ImageUniqueId"},
#endif
};
const int TAG_TABLE_SIZE = (sizeof(TagTable) / sizeof(TagTable_t));
const int TRUE = 1;
const int FALSE = 0;
} // namespace
//--------------------------------------------------------------------------
// Convert a 16 bit unsigned value from file's native byte order
//--------------------------------------------------------------------------
int JpgExifReader::Get16u(void *Short) {
if (MotorolaOrder) {
return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
} else {
return (((uchar *)Short)[1] << 8) | ((uchar *)Short)[0];
}
}
//--------------------------------------------------------------------------
// Convert a 32 bit signed value from file's native byte order
//--------------------------------------------------------------------------
int JpgExifReader::Get32s(void *Long) {
if (MotorolaOrder) {
return (((char *)Long)[0] << 24) | (((uchar *)Long)[1] << 16) |
(((uchar *)Long)[2] << 8) | (((uchar *)Long)[3] << 0);
} else {
return (((char *)Long)[3] << 24) | (((uchar *)Long)[2] << 16) |
(((uchar *)Long)[1] << 8) | (((uchar *)Long)[0] << 0);
}
}
//--------------------------------------------------------------------------
// Convert a 32 bit unsigned value from file's native byte order
//--------------------------------------------------------------------------
unsigned JpgExifReader::Get32u(void *Long) {
return (unsigned)Get32s(Long) & 0xffffffff;
}
//--------------------------------------------------------------------------
// Display a number as one of its many formats
//--------------------------------------------------------------------------
void JpgExifReader::PrintFormatNumber(void *ValuePtr, int Format,
int ByteCount) {
int s, n;
for (n = 0; n < 16; n++) {
switch (Format) {
case FMT_SBYTE:
case FMT_BYTE:
printf("%02x", *(uchar *)ValuePtr);
s = 1;
break;
case FMT_USHORT:
printf("%d", Get16u(ValuePtr));
s = 2;
break;
case FMT_ULONG:
case FMT_SLONG:
printf("%d", Get32s(ValuePtr));
s = 4;
break;
case FMT_SSHORT:
printf("%hd", (signed short)Get16u(ValuePtr));
s = 2;
break;
case FMT_URATIONAL:
printf("%u/%u", Get32s(ValuePtr), Get32s(4 + (char *)ValuePtr));
s = 8;
break;
case FMT_SRATIONAL:
printf("%d/%d", Get32s(ValuePtr), Get32s(4 + (char *)ValuePtr));
s = 8;
break;
case FMT_SINGLE:
printf("%f", (double)*(float *)ValuePtr);
s = 8;
break;
case FMT_DOUBLE:
printf("%f", *(double *)ValuePtr);
s = 8;
break;
default:
printf("Unknown format %d:", Format);
return;
}
ByteCount -= s;
if (ByteCount <= 0) break;
printf(", ");
ValuePtr = (void *)((char *)ValuePtr + s);
}
if (n >= 16) printf("...");
}
//--------------------------------------------------------------------------
// Evaluate number, be it int, rational, or float from directory.
//--------------------------------------------------------------------------
double JpgExifReader::ConvertAnyFormat(void *ValuePtr, int Format) {
double Value;
Value = 0;
switch (Format) {
case FMT_SBYTE:
Value = *(signed char *)ValuePtr;
break;
case FMT_BYTE:
Value = *(uchar *)ValuePtr;
break;
case FMT_USHORT:
Value = Get16u(ValuePtr);
break;
case FMT_ULONG:
Value = Get32u(ValuePtr);
break;
case FMT_URATIONAL:
case FMT_SRATIONAL: {
int Num, Den;
Num = Get32s(ValuePtr);
Den = Get32s(4 + (char *)ValuePtr);
if (Den == 0) {
Value = 0;
} else {
if (Format == FMT_SRATIONAL) {
Value = (double)Num / Den;
} else {
Value = (double)(unsigned)Num / (double)(unsigned)Den;
}
}
break;
}
case FMT_SSHORT:
Value = (signed short)Get16u(ValuePtr);
break;
case FMT_SLONG:
Value = Get32s(ValuePtr);
break;
// Not sure if this is correct (never seen float used in Exif format)
case FMT_SINGLE:
Value = (double)*(float *)ValuePtr;
break;
case FMT_DOUBLE:
Value = *(double *)ValuePtr;
break;
default:
std::cout << "Illegal format code " << Format << " in Exif header"
<< std::endl;
}
return Value;
}
//--------------------------------------------------------------------------
void JpgExifReader::process_EXIF(unsigned char *ExifSection,
unsigned int length) {
unsigned int FirstOffset;
#ifdef ReadAllTags
FocalplaneXRes = 0;
FocalplaneUnits = 0;
ExifImageWidth = 0;
NumOrientations = 0;
DirWithThumbnailPtrs = NULL;
#endif
if (ShowTags) printf("Exif header %u bytes long\n", length);
{ // Check the EXIF header component
static uchar ExifHeader[] = "Exif\0\0";
if (memcmp(ExifSection + 2, ExifHeader, 6)) {
std::cout << "Incorrect Exif header" << std::endl;
return;
}
}
if (memcmp(ExifSection + 8, "II", 2) == 0) {
if (ShowTags) printf("Exif section in Intel order\n");
MotorolaOrder = 0;
} else {
if (memcmp(ExifSection + 8, "MM", 2) == 0) {
if (ShowTags) printf("Exif section in Motorola order\n");
MotorolaOrder = 1;
} else {
std::cout << "Invalid Exif alignment marker." << std::endl;
return;
}
}
// Check the next value for correctness.
if (Get16u(ExifSection + 10) != 0x2a) {
std::cout << "Invalid Exif start (1)" << std::endl;
return;
}
FirstOffset = Get32u(ExifSection + 12);
if (FirstOffset < 8 || FirstOffset > 16) {
if (FirstOffset < 16 || FirstOffset > length - 16) {
std::cout << "invalid offset for first Exif IFD value" << std::endl;
return;
}
// Usually set to 8, but other values valid too.
std::cout << "Suspicious offset of first Exif IFD value" << std::endl;
}
// First directory starts 16 bytes in. All offset are relative to 8 bytes in.
ProcessExifDir(ExifSection + 8 + FirstOffset, ExifSection + 8, length - 8, 0);
#ifdef ReadAllTags
ImageInfo.ThumbnailAtEnd =
ImageInfo.ThumbnailOffset >= ImageInfo.LargestExifOffset ? TRUE : FALSE;
if (DumpExifMap) {
unsigned a, b;
printf("Map: %05d- End of exif\n", length - 8);
for (a = 0; a < length - 8; a += 10) {
printf("Map: %05d ", a);
for (b = 0; b < 10; b++) printf(" %02x", *(ExifSection + 8 + a + b));
printf("\n");
}
}
// Compute the CCD width, in millimeters.
if (FocalplaneXRes != 0 && ExifImageWidth != 0) {
// Note: With some cameras, its not possible to compute this correctly
// because
// they don't adjust the indicated focal plane resolution units when using
// less
// than maximum resolution, so the CCDWidth value comes out too small.
// Nothing
// that Jhad can do about it - its a camera problem.
ImageInfo.CCDWidth =
(float)(ExifImageWidth * FocalplaneUnits / FocalplaneXRes);
if (ImageInfo.FocalLength && ImageInfo.FocalLength35mmEquiv == 0) {
// Compute 35 mm equivalent focal length based on sensor geometry if we
// haven't
// already got it explicitly from a tag.
ImageInfo.FocalLength35mmEquiv =
(int)(ImageInfo.FocalLength / ImageInfo.CCDWidth * 36 + 0.5);
}
}
#endif
}
//--------------------------------------------------------------------------
// Process one of the nested EXIF directories.
//--------------------------------------------------------------------------
void JpgExifReader::ProcessExifDir(unsigned char *DirStart,
unsigned char *OffsetBase,
unsigned ExifLength, int NestingLevel) {
int de;
int a;
int NumDirEntries;
unsigned ThumbnailOffset = 0;
unsigned ThumbnailSize = 0;
char IndentString[25];
if (NestingLevel > 4) {
std::cout << "Maximum Exif directory nesting exceeded (corrupt Exif header)"
<< std::endl;
return;
}
memset(IndentString, ' ', 25);
IndentString[NestingLevel * 4] = '\0';
NumDirEntries = Get16u(DirStart);
#define DIR_ENTRY_ADDR(Start, Entry) (Start + 2 + 12 * (Entry))
{
unsigned char *DirEnd;
DirEnd = DIR_ENTRY_ADDR(DirStart, NumDirEntries);
if (DirEnd + 4 > (OffsetBase + ExifLength)) {
if (DirEnd + 2 == OffsetBase + ExifLength ||
DirEnd == OffsetBase + ExifLength) {
// Version 1.3 of jhead would truncate a bit too much.
// This also caught later on as well.
} else {
std::cout << "Illegally sized Exif subdirectory (" << NumDirEntries
<< "entries)" << std::endl;
return;
}
}
if (DumpExifMap) {
printf("Map: %05u-%05u: Directory\n", (int)(DirStart - OffsetBase),
(int)(DirEnd + 4 - OffsetBase));
}
}
if (ShowTags) {
printf("(dir has %d entries)\n", NumDirEntries);
}
for (de = 0; de < NumDirEntries; de++) {
int Tag, Format, Components;
unsigned char *ValuePtr;
int ByteCount;
unsigned char *DirEntry;
DirEntry = DIR_ENTRY_ADDR(DirStart, de);
Tag = Get16u(DirEntry);
Format = Get16u(DirEntry + 2);
Components = Get32u(DirEntry + 4);
if ((Format - 1) >= NUM_FORMATS) {
// (-1) catches illegal zero case as unsigned underflows to positive
// large.
std::cout << "Illegal number format " << Format << " for tag " << Tag
<< " in Exif" << std::endl;
continue;
}
if ((unsigned)Components > 0x10000) {
std::cout << "Too many components " << Components << " for tag " << Tag
<< " in Exif";
continue;
}
ByteCount = Components * BytesPerFormat[Format];
if (ByteCount > 4) {
unsigned OffsetVal;
OffsetVal = Get32u(DirEntry + 8);
// If its bigger than 4 bytes, the dir entry contains an offset.
if (OffsetVal + ByteCount > ExifLength) {
// Bogus pointer offset and / or bytecount value
std::cout << "Illegal value pointer for tag " << Tag << " in Exif";
continue;
}
ValuePtr = OffsetBase + OffsetVal;
#ifdef ReadAllTags
if (OffsetVal > ImageInfo.LargestExifOffset) {
ImageInfo.LargestExifOffset = OffsetVal;
}
#endif
if (DumpExifMap) {
printf("Map: %05u-%05u: Data for tag %04x\n", OffsetVal,
OffsetVal + ByteCount, Tag);
}
} else {
// 4 bytes or less and value is in the dir entry itself
ValuePtr = DirEntry + 8;
}
#ifdef ReadAllTags
if (Tag == TAG_MAKER_NOTE) {
if (ShowTags) {
printf("%s Maker note: ", IndentString);
}
// ProcessMakerNote(ValuePtr, ByteCount, OffsetBase, ExifLength);
continue;
}
if (ShowTags) {
// Show tag name
for (a = 0;; a++) {
if (a >= TAG_TABLE_SIZE) {
printf("%s Unknown Tag %04x Value = ", IndentString, Tag);
break;
}
if (TagTable[a].Tag == Tag) {
printf("%s %s = ", IndentString, TagTable[a].Desc);
break;
}
}
// Show tag value.
switch (Format) {
case FMT_BYTE:
if (ByteCount > 1) {
printf("%.*ls\n", ByteCount / 2, (wchar_t *)ValuePtr);
} else {
PrintFormatNumber(ValuePtr, Format, ByteCount);
printf("\n");
}
break;
case FMT_UNDEFINED:
// Undefined is typically an ascii string.
case FMT_STRING:
// String arrays printed without function call (different from int
// arrays)
{
int NoPrint = 0;
printf("\"");
for (a = 0; a < ByteCount; a++) {
if (ValuePtr[a] >= 32) {
putchar(ValuePtr[a]);
NoPrint = 0;
} else {
// Avoiding indicating too many unprintable characters of
// proprietary
// bits of binary information this program may not know how to
// parse.
if (!NoPrint && a != ByteCount - 1) {
putchar('?');
NoPrint = 1;
}
}
}
printf("\"\n");
}
break;
default:
// Handle arrays of numbers later (will there ever be?)
PrintFormatNumber(ValuePtr, Format, ByteCount);
printf("\n");
}
}
#endif
// Extract useful components of tag
switch (Tag) {
#ifdef ReadAllTags
case TAG_MAKE:
strncpy(ImageInfo.CameraMake, (char *)ValuePtr,
ByteCount < 31 ? ByteCount : 31);
break;
case TAG_MODEL:
strncpy(ImageInfo.CameraModel, (char *)ValuePtr,
ByteCount < 39 ? ByteCount : 39);
break;
case TAG_DATETIME_ORIGINAL:
// If we get a DATETIME_ORIGINAL, we use that one.
strncpy(ImageInfo.DateTime, (char *)ValuePtr, 19);
// Fallthru...
case TAG_DATETIME_DIGITIZED:
case TAG_DATETIME:
if (!isdigit(static_cast<unsigned char>(ImageInfo.DateTime[0]))) {
// If we don't already have a DATETIME_ORIGINAL, use whatever
// time fields we may have.
strncpy(ImageInfo.DateTime, (char *)ValuePtr, 19);
}
if (ImageInfo.numDateTimeTags >= MAX_DATE_COPIES) {
std::cout << "More than " << MAX_DATE_COPIES
<< " date fields in Exif. This is nuts" << std::endl;
break;
}
ImageInfo.DateTimeOffsets[ImageInfo.numDateTimeTags++] =
(char *)ValuePtr - (char *)OffsetBase;
break;
case TAG_WINXP_COMMENT:
if (ImageInfo.Comments[0]) { // We already have a jpeg comment.
// Already have a comment (probably windows comment), skip this one.
if (ShowTags)
printf("Windows XP comment and other comment in header\n");
break; // Already have a windows comment, skip this one.
}
if (ByteCount > 1) {
if (ByteCount > MAX_COMMENT_SIZE) ByteCount = MAX_COMMENT_SIZE;
memcpy(ImageInfo.Comments, ValuePtr, ByteCount);
ImageInfo.CommentWidthchars = ByteCount / 2;
}
break;
case TAG_USERCOMMENT:
if (ImageInfo.Comments[0]) { // We already have a jpeg comment.
// Already have a comment (probably windows comment), skip this one.
if (ShowTags) printf("Multiple comments in exif header\n");
break; // Already have a windows comment, skip this one.
}
// Comment is often padded with trailing spaces. Remove these first.
for (a = ByteCount;;) {
a--;
if ((ValuePtr)[a] == ' ') {
(ValuePtr)[a] = '\0';
} else {
break;
}
if (a == 0) break;
}
// Copy the comment
{
int msiz = ExifLength - (ValuePtr - OffsetBase);
if (msiz > ByteCount) msiz = ByteCount;
if (msiz > MAX_COMMENT_SIZE - 1) msiz = MAX_COMMENT_SIZE - 1;
if (msiz > 5 && memcmp(ValuePtr, "ASCII", 5) == 0) {
for (a = 5; a < 10 && a < msiz; a++) {
int c = (ValuePtr)[a];
if (c != '\0' && c != ' ') {
strncpy(ImageInfo.Comments, (char *)ValuePtr + a, msiz - a);
break;
}
}
} else {
strncpy(ImageInfo.Comments, (char *)ValuePtr, msiz);
}
}
break;
case TAG_FNUMBER:
// Simplest way of expressing aperture, so I trust it the most.
// (overwrite previously computd value if there is one)
ImageInfo.ApertureFNumber = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_APERTURE:
case TAG_MAXAPERTURE:
// More relevant info always comes earlier, so only use this field if we
// don't
// have appropriate aperture information yet.
if (ImageInfo.ApertureFNumber == 0) {
ImageInfo.ApertureFNumber =
(float)exp(ConvertAnyFormat(ValuePtr, Format) * log(2) * 0.5);
}
break;
case TAG_FOCALLENGTH:
// Nice digital cameras actually save the focal length as a function
// of how farthey are zoomed in.
ImageInfo.FocalLength = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_SUBJECT_DISTANCE:
// Inidcates the distacne the autofocus camera is focused to.
// Tends to be less accurate as distance increases.
ImageInfo.Distance = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_EXPOSURETIME:
// Simplest way of expressing exposure time, so I trust it most.
// (overwrite previously computd value if there is one)
ImageInfo.ExposureTime = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_SHUTTERSPEED:
// More complicated way of expressing exposure time, so only use
// this value if we don't already have it from somewhere else.
if (ImageInfo.ExposureTime == 0) {
ImageInfo.ExposureTime =
(float)(1 / exp(ConvertAnyFormat(ValuePtr, Format) * log(2)));
}
break;
case TAG_FLASH:
ImageInfo.FlashUsed = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_ORIENTATION:
if (NumOrientations >= 2) {
// Can have another orientation tag for the thumbnail, but if there's
// a third one, things are strange.
std::cout << "More than two orientation in Exif" << std::endl;
break;
}
OrientationPtr[NumOrientations] = ValuePtr;
OrientationNumFormat[NumOrientations] = Format;
if (NumOrientations == 0) {
ImageInfo.Orientation = (int)ConvertAnyFormat(ValuePtr, Format);
}
if (ImageInfo.Orientation < 0 || ImageInfo.Orientation > 8) {
std::cout << "Undefined rotation value " << ImageInfo.Orientation
<< " in Exif" << std::endl;
}
NumOrientations += 1;
break;
case TAG_PIXEL_Y_DIMENSION:
case TAG_PIXEL_X_DIMENSION:
// Use largest of height and width to deal with images that have been
// rotated to portrait format.
a = (int)ConvertAnyFormat(ValuePtr, Format);
if (ExifImageWidth < a) ExifImageWidth = a;
break;
case TAG_FOCAL_PLANE_XRES:
FocalplaneXRes = ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_FOCAL_PLANE_UNITS:
switch ((int)ConvertAnyFormat(ValuePtr, Format)) {
case 1:
FocalplaneUnits = 25.4;
break; // inch
case 2:
// According to the information I was using, 2 means meters.
// But looking at the Cannon powershot's files, inches is the only
// sensible value.
FocalplaneUnits = 25.4;
break;
case 3:
FocalplaneUnits = 10;
break; // centimeter
case 4:
FocalplaneUnits = 1;
break; // millimeter
case 5:
FocalplaneUnits = .001;
break; // micrometer
}
break;
case TAG_EXPOSURE_BIAS:
ImageInfo.ExposureBias = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_WHITEBALANCE:
ImageInfo.Whitebalance = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_LIGHT_SOURCE:
ImageInfo.LightSource = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_METERING_MODE:
ImageInfo.MeteringMode = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_EXPOSURE_PROGRAM:
ImageInfo.ExposureProgram = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_EXPOSURE_INDEX:
if (ImageInfo.ISOequivalent == 0) {
// Exposure index and ISO equivalent are often used interchangeably,
// so we will do the same in jhead.
// http://photography.about.com/library/glossary/bldef_ei.htm
ImageInfo.ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);
}
break;
case TAG_EXPOSURE_MODE:
ImageInfo.ExposureMode = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_ISO_EQUIVALENT:
ImageInfo.ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_DIGITALZOOMRATIO:
ImageInfo.DigitalZoomRatio = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_THUMBNAIL_OFFSET:
ThumbnailOffset = (unsigned)ConvertAnyFormat(ValuePtr, Format);
DirWithThumbnailPtrs = DirStart;
break;
case TAG_THUMBNAIL_LENGTH:
ThumbnailSize = (unsigned)ConvertAnyFormat(ValuePtr, Format);
ImageInfo.ThumbnailSizeOffset = ValuePtr - OffsetBase;
break;
case TAG_EXIF_OFFSET:
if (ShowTags) printf("%s Exif Dir:", IndentString);
case TAG_INTEROP_OFFSET:
if (Tag == TAG_INTEROP_OFFSET && ShowTags)
printf("%s Interop Dir:", IndentString);
{
unsigned char *SubdirStart;
SubdirStart = OffsetBase + Get32u(ValuePtr);
if (SubdirStart < OffsetBase || SubdirStart > OffsetBase + ExifLength) {
std::cout << "Illegal Exif or interop ofset directory link"
<< std::endl;
} else {
ProcessExifDir(SubdirStart, OffsetBase, ExifLength, NestingLevel + 1);
}
continue;
}
break;
case TAG_GPSINFO:
if (ShowTags) printf("%s GPS info dir:", IndentString);
{
unsigned char *SubdirStart;
SubdirStart = OffsetBase + Get32u(ValuePtr);
if (SubdirStart < OffsetBase || SubdirStart > OffsetBase + ExifLength) {
std::cout << "Illegal GPS directory link in Exif" << std::endl;
} else {
// ProcessGpsInfo(SubdirStart, OffsetBase, ExifLength);
}
continue;
}
break;
case TAG_FOCALLENGTH_35MM:
// The focal length equivalent 35 mm is a 2.2 tag (defined as of April
// 2002)
// if its present, use it to compute equivalent focal length instead of
// computing it from sensor geometry and actual focal length.
ImageInfo.FocalLength35mmEquiv =
(unsigned)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_DISTANCE_RANGE:
// Three possible standard values:
// 1 = macro, 2 = close, 3 = distant
ImageInfo.DistanceRange = (int)ConvertAnyFormat(ValuePtr, Format);
break;
#endif
case TAG_X_RESOLUTION:
if (NestingLevel ==
0) { // Only use the values from the top level directory
ImageInfo.xResolution = (float)ConvertAnyFormat(ValuePtr, Format);
// if yResolution has not been set, use the value of xResolution
if (ImageInfo.yResolution == 0.0)
ImageInfo.yResolution = ImageInfo.xResolution;
}
break;
case TAG_Y_RESOLUTION:
if (NestingLevel ==
0) { // Only use the values from the top level directory
ImageInfo.yResolution = (float)ConvertAnyFormat(ValuePtr, Format);
// if xResolution has not been set, use the value of yResolution
if (ImageInfo.xResolution == 0.0)
ImageInfo.xResolution = ImageInfo.yResolution;
}
break;
case TAG_RESOLUTION_UNIT:
if (NestingLevel ==
0) { // Only use the values from the top level directory
ImageInfo.ResolutionUnit = (int)ConvertAnyFormat(ValuePtr, Format);
}
break;
}
}
#ifdef ReadAllTags
{
// In addition to linking to subdirectories via exif tags,
// there's also a potential link to another directory at the end of each
// directory. this has got to be the result of a committee!
unsigned char *SubdirStart;
unsigned Offset;
if (DIR_ENTRY_ADDR(DirStart, NumDirEntries) + 4 <=
OffsetBase + ExifLength) {
Offset = Get32u(DirStart + 2 + 12 * NumDirEntries);
if (Offset) {
SubdirStart = OffsetBase + Offset;
if (SubdirStart > OffsetBase + ExifLength || SubdirStart < OffsetBase) {
if (SubdirStart > OffsetBase &&
SubdirStart < OffsetBase + ExifLength + 20) {
// Jhead 1.3 or earlier would crop the whole directory!
// As Jhead produces this form of format incorrectness,
// I'll just let it pass silently
if (ShowTags)
printf("Thumbnail removed with Jhead 1.3 or earlier\n");
} else {
std::cout << "Illegal subdirectory link in Exif header"
<< std::endl;
}
} else {
if (SubdirStart <= OffsetBase + ExifLength) {
if (ShowTags) printf("%s Continued directory ", IndentString);
ProcessExifDir(SubdirStart, OffsetBase, ExifLength,
NestingLevel + 1);
}
}
if (Offset > ImageInfo.LargestExifOffset) {
ImageInfo.LargestExifOffset = Offset;
}
}
} else {
// The exif header ends before the last next directory pointer.
}
}
if (ThumbnailOffset) {
ImageInfo.ThumbnailAtEnd = FALSE;
if (DumpExifMap) {
printf("Map: %05d-%05d: Thumbnail\n", ThumbnailOffset,
ThumbnailOffset + ThumbnailSize);
}
if (ThumbnailOffset <= ExifLength) {
if (ThumbnailSize > ExifLength - ThumbnailOffset) {
// If thumbnail extends past exif header, only save the part that
// actually exists. Canon's EOS viewer utility will do this - the
// thumbnail extracts ok with this hack.
ThumbnailSize = ExifLength - ThumbnailOffset;
if (ShowTags) printf("Thumbnail incorrectly placed in header\n");
}
// The thumbnail pointer appears to be valid. Store it.
ImageInfo.ThumbnailOffset = ThumbnailOffset;
ImageInfo.ThumbnailSize = ThumbnailSize;
if (ShowTags) {
printf("Thumbnail size: %u bytes\n", ThumbnailSize);
}
}
}
#endif
}