/*-------------------------------------------------------------

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></iostream>

#include <string.h></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;

#ifdef ReadAllTags

  int a;

#endif

  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, static_cast<int64_t>(NumDirEntries));</int64_t>

    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, static_cast<int64_t>(de));</int64_t>

    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]))) {</unsigned>

        // 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: