/******************************************************************************

 *

 * Project:  GDAL

 * Purpose:  Implements a EXIF directory reader

 * Author:   Frank Warmerdam, warmerdam@pobox.com

 *

 ******************************************************************************

 * Copyright (c) 2000, Frank Warmerdam

 * Copyright (c) 2012,2017, Even Rouault <even dot rouault at spatialys.com>

 *

 * Portions Copyright (c) Her majesty the Queen in right of Canada as

 * represented by the Minister of National Defence, 2006.

 *

 * SPDX-License-Identifier: MIT

 ****************************************************************************/

#include "cpl_port.h"

#include "gdal_priv.h"

#include "gdalexif.h"

#include <climits>

#include <cmath>

#include <cstddef>

#include <cstdio>

#include <cstring>

#if HAVE_FCNTL_H

#include <fcntl.h>

#endif

#include <algorithm>

#include <limits>

#include <vector>

#include "cpl_conv.h"

#include "cpl_error.h"

#include "cpl_string.h"

#include "cpl_vsi.h"

using std::vector;

constexpr int MAXSTRINGLENGTH = 65535;

constexpr int EXIFOFFSETTAG = 0x8769;

constexpr int INTEROPERABILITYOFFSET = 0xA005;

constexpr int GPSOFFSETTAG = 0x8825;

constexpr GUInt16 TAG_SIZE = 12;

constexpr GUInt16 EXIF_HEADER_SIZE = 6;

constexpr char COND_MANDATORY = 'M';

constexpr char COND_RECOMMENDED = 'R';

constexpr char COND_OPTIONAL = 'O';

constexpr char COND_NOT_ALLOWED = 'N';

constexpr char COND_NOT_ALLOWED_EVEN_IN_JPEG_MARKER = 'J';

struct EXIFTagDesc

{

    GUInt16 tag;

    GDALEXIFTIFFDataType datatype;

    GUInt32 length;

    const char *name;

    // comprCond is only used when DUMP_EXIF_ITEMS is defined

    // cppcheck-suppress unusedStructMember

    char comprCond;

};

static const EXIFTagDesc gpstags[] = {

    {0x00, TIFF_BYTE, 4, "EXIF_GPSVersionID", COND_OPTIONAL},

    {0x01, TIFF_ASCII, 2, "EXIF_GPSLatitudeRef", COND_OPTIONAL},

    {0x02, TIFF_RATIONAL, 3, "EXIF_GPSLatitude", COND_OPTIONAL},

    {0x03, TIFF_ASCII, 2, "EXIF_GPSLongitudeRef", COND_OPTIONAL},

    {0x04, TIFF_RATIONAL, 3, "EXIF_GPSLongitude", COND_OPTIONAL},

    {0x05, TIFF_BYTE, 1, "EXIF_GPSAltitudeRef", COND_OPTIONAL},

    {0x06, TIFF_RATIONAL, 1, "EXIF_GPSAltitude", COND_OPTIONAL},

    {0x07, TIFF_RATIONAL, 3, "EXIF_GPSTimeStamp", COND_OPTIONAL},

    {0x08, TIFF_ASCII, 0, "EXIF_GPSSatellites", COND_OPTIONAL},

    {0x09, TIFF_ASCII, 2, "EXIF_GPSStatus", COND_OPTIONAL},

    {0x0a, TIFF_ASCII, 2, "EXIF_GPSMeasureMode", COND_OPTIONAL},

    {0x0b, TIFF_RATIONAL, 1, "EXIF_GPSDOP", COND_OPTIONAL},

    {0x0c, TIFF_ASCII, 2, "EXIF_GPSSpeedRef", COND_OPTIONAL},

    {0x0d, TIFF_RATIONAL, 1, "EXIF_GPSSpeed", COND_OPTIONAL},

    {0x0e, TIFF_ASCII, 2, "EXIF_GPSTrackRef", COND_OPTIONAL},

    {0x0f, TIFF_RATIONAL, 1, "EXIF_GPSTrack", COND_OPTIONAL},

    {0x10, TIFF_ASCII, 2, "EXIF_GPSImgDirectionRef", COND_OPTIONAL},

    {0x11, TIFF_RATIONAL, 1, "EXIF_GPSImgDirection", COND_OPTIONAL},

    {0x12, TIFF_ASCII, 0, "EXIF_GPSMapDatum", COND_OPTIONAL},

    {0x13, TIFF_ASCII, 2, "EXIF_GPSDestLatitudeRef", COND_OPTIONAL},

    {0x14, TIFF_RATIONAL, 3, "EXIF_GPSDestLatitude", COND_OPTIONAL},

    {0x15, TIFF_ASCII, 2, "EXIF_GPSDestLongitudeRef", COND_OPTIONAL},

    {0x16, TIFF_RATIONAL, 3, "EXIF_GPSDestLongitude", COND_OPTIONAL},

    {0x17, TIFF_ASCII, 2, "EXIF_GPSDestBearingRef", COND_OPTIONAL},

    {0x18, TIFF_RATIONAL, 1, "EXIF_GPSDestBearing", COND_OPTIONAL},

    {0x19, TIFF_ASCII, 2, "EXIF_GPSDestDistanceRef", COND_OPTIONAL},

    {0x1a, TIFF_RATIONAL, 1, "EXIF_GPSDestDistance", COND_OPTIONAL},

    {0x1b, TIFF_UNDEFINED, 0, "EXIF_GPSProcessingMethod", COND_OPTIONAL},

    {0x1c, TIFF_UNDEFINED, 0, "EXIF_GPSAreaInformation", COND_OPTIONAL},

    {0x1d, TIFF_ASCII, 11, "EXIF_GPSDateStamp", COND_OPTIONAL},

    {0x1e, TIFF_SHORT, 1, "EXIF_GPSDifferential", COND_OPTIONAL},

    {0x1f, TIFF_RATIONAL, 1, "EXIF_GPSHPositioningError", COND_OPTIONAL},

    {0xffff, TIFF_NOTYPE, 0, "", COND_NOT_ALLOWED}};

static const EXIFTagDesc exiftags[] = {

    //{ 0x100, "EXIF_Image_Width"},

    //  { 0x101, "EXIF_Image_Length"},

    {0x102, TIFF_NOTYPE, 0, "EXIF_BitsPerSample",

     COND_NOT_ALLOWED_EVEN_IN_JPEG_MARKER},

    {0x103, TIFF_NOTYPE, 0, "EXIF_Compression",

     COND_NOT_ALLOWED_EVEN_IN_JPEG_MARKER},

    {0x106, TIFF_NOTYPE, 0, "EXIF_PhotometricInterpretation", COND_NOT_ALLOWED},

    {0x10A, TIFF_NOTYPE, 0, "EXIF_Fill_Order",

     COND_NOT_ALLOWED_EVEN_IN_JPEG_MARKER},  // not sure of cond

    {0x10D, TIFF_ASCII, 0, "EXIF_Document_Name",

     COND_OPTIONAL},  // not sure of cond

    {0x10E, TIFF_ASCII, 0, "EXIF_ImageDescription", COND_RECOMMENDED},

    {0x10F, TIFF_ASCII, 0, "EXIF_Make", COND_RECOMMENDED},

    {0x110, TIFF_ASCII, 0, "EXIF_Model", COND_RECOMMENDED},

    {0x111, TIFF_NOTYPE, 0, "EXIF_StripOffsets", COND_NOT_ALLOWED},

    {0x112, TIFF_SHORT, 1, "EXIF_Orientation", COND_RECOMMENDED},

    {0x115, TIFF_NOTYPE, 0, "EXIF_SamplesPerPixel",

     COND_NOT_ALLOWED_EVEN_IN_JPEG_MARKER},

    {0x116, TIFF_NOTYPE, 0, "EXIF_RowsPerStrip", COND_NOT_ALLOWED},

    {0x117, TIFF_NOTYPE, 0, "EXIF_StripByteCounts", COND_NOT_ALLOWED},

    {0x11A, TIFF_RATIONAL, 1, "EXIF_XResolution", COND_MANDATORY},

    {0x11B, TIFF_RATIONAL, 1, "EXIF_YResolution", COND_MANDATORY},

    {0x11C, TIFF_NOTYPE, 0, "EXIF_PlanarConfiguration",

     COND_NOT_ALLOWED_EVEN_IN_JPEG_MARKER},

    {0x128, TIFF_SHORT, 1, "EXIF_ResolutionUnit", COND_MANDATORY},

    {0x12D, TIFF_SHORT, 768, "EXIF_TransferFunction", COND_OPTIONAL},

    {0x131, TIFF_ASCII, 0, "EXIF_Software", COND_OPTIONAL},

    {0x132, TIFF_ASCII, 20, "EXIF_DateTime", COND_RECOMMENDED},

    {0x13B, TIFF_ASCII, 0, "EXIF_Artist", COND_OPTIONAL},

    {0x13E, TIFF_RATIONAL, 2, "EXIF_WhitePoint", COND_OPTIONAL},

    {0x13F, TIFF_RATIONAL, 6, "EXIF_PrimaryChromaticities", COND_OPTIONAL},

    {0x156, TIFF_NOTYPE, 0, "EXIF_Transfer_Range",

     COND_NOT_ALLOWED},  // not sure of cond

    {0x200, TIFF_NOTYPE, 0, "EXIF_JPEG_Proc",

     COND_NOT_ALLOWED},  // not sure of cond

    {0x201, TIFF_NOTYPE, 0, "EXIF_JPEGInterchangeFormat", COND_NOT_ALLOWED},

    {0x202, TIFF_NOTYPE, 0, "EXIF_JPEGInterchangeFormatLength",

     COND_NOT_ALLOWED},

    {0x211, TIFF_RATIONAL, 3, "EXIF_YCbCrCoefficients", COND_OPTIONAL},

    {0x212, TIFF_NOTYPE, 0, "EXIF_YCbCrSubSampling",

     COND_NOT_ALLOWED_EVEN_IN_JPEG_MARKER},

    {0x213, TIFF_SHORT, 1, "EXIF_YCbCrPositioning", COND_MANDATORY},

    {0x214, TIFF_RATIONAL, 6, "EXIF_ReferenceBlackWhite", COND_OPTIONAL},

    {0x2BC, TIFF_ASCII, 0, "EXIF_XmlPacket",

     COND_OPTIONAL},  // not in the EXIF standard. But found in some images

    {0x828D, TIFF_NOTYPE, 0, "EXIF_CFA_Repeat_Pattern_Dim", COND_OPTIONAL},

    {0x828E, TIFF_NOTYPE, 0, "EXIF_CFA_Pattern", COND_OPTIONAL},

    {0x828F, TIFF_NOTYPE, 0, "EXIF_Battery_Level", COND_OPTIONAL},

    {0x8298, TIFF_ASCII, 0, "EXIF_Copyright",

     COND_OPTIONAL},  // that one is an exception: high tag number, but should

                      // go to main IFD

    {0x829A, TIFF_RATIONAL, 1, "EXIF_ExposureTime", COND_RECOMMENDED},

    {0x829D, TIFF_RATIONAL, 1, "EXIF_FNumber", COND_OPTIONAL},

    {0x83BB, TIFF_NOTYPE, 0, "EXIF_IPTC/NAA", COND_OPTIONAL},

    // { 0x8769, "EXIF_Offset"},

    {0x8773, TIFF_NOTYPE, 0, "EXIF_Inter_Color_Profile", COND_OPTIONAL},

    {0x8822, TIFF_SHORT, 1, "EXIF_ExposureProgram", COND_OPTIONAL},

    {0x8824, TIFF_ASCII, 0, "EXIF_SpectralSensitivity", COND_OPTIONAL},

    // { 0x8825, "EXIF_GPSOffset"},

    {0x8827, TIFF_SHORT, 0, "EXIF_ISOSpeedRatings", COND_OPTIONAL},

    {0x8828, TIFF_UNDEFINED, 0, "EXIF_OECF", COND_OPTIONAL},

    {0x8830, TIFF_SHORT, 1, "EXIF_SensitivityType", COND_OPTIONAL},

    {0x8831, TIFF_LONG, 1, "EXIF_StandardOutputSensitivity", COND_OPTIONAL},

    {0x8832, TIFF_LONG, 1, "EXIF_RecommendedExposureIndex", COND_OPTIONAL},

    {0x8833, TIFF_LONG, 1, "EXIF_ISOSpeed", COND_OPTIONAL},

    {0x8834, TIFF_LONG, 1, "EXIF_ISOSpeedLatitudeyyy", COND_OPTIONAL},

    {0x8835, TIFF_LONG, 1, "EXIF_ISOSpeedLatitudezzz", COND_OPTIONAL},

    {0x9000, TIFF_UNDEFINED, 4, "EXIF_ExifVersion", COND_MANDATORY},

    {0x9003, TIFF_ASCII, 20, "EXIF_DateTimeOriginal", COND_OPTIONAL},

    {0x9004, TIFF_ASCII, 20, "EXIF_DateTimeDigitized", COND_OPTIONAL},

    {0x9010, TIFF_ASCII, 7, "EXIF_OffsetTime", COND_OPTIONAL},

    {0x9011, TIFF_ASCII, 7, "EXIF_OffsetTimeOriginal", COND_OPTIONAL},

    {0x9012, TIFF_ASCII, 7, "EXIF_OffsetTimeDigitized", COND_OPTIONAL},

    {0x9101, TIFF_UNDEFINED, 4, "EXIF_ComponentsConfiguration", COND_MANDATORY},

    {0x9102, TIFF_RATIONAL, 1, "EXIF_CompressedBitsPerPixel", COND_OPTIONAL},

    {0x9201, TIFF_SRATIONAL, 1, "EXIF_ShutterSpeedValue", COND_OPTIONAL},

    {0x9202, TIFF_RATIONAL, 1, "EXIF_ApertureValue", COND_OPTIONAL},

    {0x9203, TIFF_SRATIONAL, 1, "EXIF_BrightnessValue", COND_OPTIONAL},

    {0x9204, TIFF_SRATIONAL, 1, "EXIF_ExposureBiasValue", COND_OPTIONAL},

    {0x9205, TIFF_RATIONAL, 1, "EXIF_MaxApertureValue", COND_OPTIONAL},

    {0x9206, TIFF_RATIONAL, 1, "EXIF_SubjectDistance", COND_OPTIONAL},

    {0x9207, TIFF_SHORT, 1, "EXIF_MeteringMode", COND_OPTIONAL},

    {0x9208, TIFF_SHORT, 1, "EXIF_LightSource", COND_OPTIONAL},

    {0x9209, TIFF_SHORT, 1, "EXIF_Flash", COND_RECOMMENDED},

    {0x920A, TIFF_RATIONAL, 1, "EXIF_FocalLength", COND_OPTIONAL},

    {0x9214, TIFF_SHORT, 0, "EXIF_SubjectArea",

     COND_OPTIONAL},  // count = 2, 3 or 4

    {0x927C, TIFF_UNDEFINED, 0, "EXIF_MakerNote", COND_OPTIONAL},

    {0x9286, TIFF_UNDEFINED, 0, "EXIF_UserComment", COND_OPTIONAL},

    {0x9290, TIFF_ASCII, 0, "EXIF_SubSecTime", COND_OPTIONAL},

    {0x9291, TIFF_ASCII, 0, "EXIF_SubSecTime_Original", COND_OPTIONAL},

    {0x9292, TIFF_ASCII, 0, "EXIF_SubSecTime_Digitized", COND_OPTIONAL},

    {0xA000, TIFF_UNDEFINED, 4, "EXIF_FlashpixVersion", COND_MANDATORY},

    {0xA001, TIFF_SHORT, 1, "EXIF_ColorSpace", COND_MANDATORY},

    {0xA002, TIFF_LONG, 1, "EXIF_PixelXDimension",

     COND_MANDATORY},  // SHORT also OK

    {0xA003, TIFF_LONG, 1, "EXIF_PixelYDimension",

     COND_MANDATORY},  // SHORT also OK

    {0xA004, TIFF_ASCII, 13, "EXIF_RelatedSoundFile", COND_OPTIONAL},

    // { 0xA005, "EXIF_InteroperabilityOffset"},

    {0xA20B, TIFF_RATIONAL, 1, "EXIF_FlashEnergy",

     COND_OPTIONAL},  // 0x920B in TIFF/EP

    {0xA20C, TIFF_UNDEFINED, 0, "EXIF_SpatialFrequencyResponse",

     COND_OPTIONAL},  // 0x920C    -  -

    {0xA20E, TIFF_RATIONAL, 1, "EXIF_FocalPlaneXResolution",

     COND_OPTIONAL},  // 0x920E    -  -

    {0xA20F, TIFF_RATIONAL, 1, "EXIF_FocalPlaneYResolution",

     COND_OPTIONAL},  // 0x920F    -  -

    {0xA210, TIFF_SHORT, 1, "EXIF_FocalPlaneResolutionUnit",

     COND_OPTIONAL},  // 0x9210    -  -

    {0xA214, TIFF_SHORT, 2, "EXIF_SubjectLocation",

     COND_OPTIONAL},  // 0x9214    -  -

    {0xA215, TIFF_RATIONAL, 1, "EXIF_ExposureIndex",

     COND_OPTIONAL},  // 0x9215    -  -

    {0xA217, TIFF_SHORT, 1, "EXIF_SensingMethod", COND_OPTIONAL},  // 0x9217 - -

    {0xA300, TIFF_UNDEFINED, 1, "EXIF_FileSource", COND_OPTIONAL},

    {0xA301, TIFF_UNDEFINED, 1, "EXIF_SceneType", COND_OPTIONAL},

    {0xA302, TIFF_UNDEFINED, 0, "EXIF_CFAPattern", COND_OPTIONAL},

    {0xA401, TIFF_SHORT, 1, "EXIF_CustomRendered", COND_OPTIONAL},

    {0xA402, TIFF_SHORT, 1, "EXIF_ExposureMode", COND_RECOMMENDED},

    {0XA403, TIFF_SHORT, 1, "EXIF_WhiteBalance", COND_RECOMMENDED},

    {0xA404, TIFF_RATIONAL, 1, "EXIF_DigitalZoomRatio", COND_OPTIONAL},

    {0xA405, TIFF_SHORT, 1, "EXIF_FocalLengthIn35mmFilm", COND_OPTIONAL},

    {0xA406, TIFF_SHORT, 1, "EXIF_SceneCaptureType", COND_RECOMMENDED},

    {0xA407, TIFF_RATIONAL, 1, "EXIF_GainControl", COND_OPTIONAL},

    {0xA408, TIFF_SHORT, 1, "EXIF_Contrast", COND_OPTIONAL},

    {0xA409, TIFF_SHORT, 1, "EXIF_Saturation", COND_OPTIONAL},

    {0xA40A, TIFF_SHORT, 1, "EXIF_Sharpness", COND_OPTIONAL},

    {0xA40B, TIFF_UNDEFINED, 0, "EXIF_DeviceSettingDescription", COND_OPTIONAL},

    {0xA40C, TIFF_SHORT, 1, "EXIF_SubjectDistanceRange", COND_OPTIONAL},

    {0xA420, TIFF_ASCII, 33, "EXIF_ImageUniqueID", COND_OPTIONAL},

    {0xA430, TIFF_ASCII, 0, "EXIF_CameraOwnerName", COND_OPTIONAL},

    {0xA431, TIFF_ASCII, 0, "EXIF_BodySerialNumber", COND_OPTIONAL},

    {0xA432, TIFF_RATIONAL, 4, "EXIF_LensSpecification", COND_OPTIONAL},

    {0xA433, TIFF_ASCII, 0, "EXIF_LensMake", COND_OPTIONAL},

    {0xA434, TIFF_ASCII, 0, "EXIF_LensModel", COND_OPTIONAL},

    {0xA435, TIFF_ASCII, 0, "EXIF_LensSerialNumber", COND_OPTIONAL},

    {0x0000, TIFF_NOTYPE, 0, "", COND_NOT_ALLOWED}};

static const struct intr_tag

{

    GInt16 tag;

    const char *name;

} intr_tags[] = {

    {0x1, "EXIF_Interoperability_Index"},

    {0x2, "EXIF_Interoperability_Version"},

    {0x1000, "EXIF_Related_Image_File_Format"},

    {0x1001, "EXIF_Related_Image_Width"},

    {0x1002, "EXIF_Related_Image_Length"},

    {0x0000, ""}};

static const EXIFTagDesc IFD0Tags[] = {

    {0xC614, TIFF_ASCII, 0, "DNG_UniqueCameraModel", COND_OPTIONAL},

    {0xC62F, TIFF_ASCII, 0, "DNG_CameraSerialNumber", COND_OPTIONAL},

    {0x0000, TIFF_NOTYPE, 0, "", COND_NOT_ALLOWED}};

/************************************************************************/

/*                         EXIFPrintData()                              */

/************************************************************************/

static void EXIFPrintData(char *pszData, GUInt16 type, GUInt32 count,

                          const unsigned char *data)

{

    const char *sep = "";

    char szTemp[128];

    char *pszDataEnd = pszData;

    pszData[0] = '\0';

    switch (type)

    {

        case TIFF_UNDEFINED:

        case TIFF_BYTE:

            for (; count > 0; count--)

            {

                snprintf(szTemp, sizeof(szTemp), "%s0x%02x", sep, *data);

                data++;

                sep = " ";

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        case TIFF_SBYTE:

            for (; count > 0; count--)

            {

                snprintf(szTemp, sizeof(szTemp), "%s%d", sep,

                         *reinterpret_cast<const char *>(data));

                data++;

                sep = " ";

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        case TIFF_ASCII:

            memcpy(pszData, data, count);

            // Strip trailing spaces or nul characters

            while (count > 0 &&

                   (pszData[count - 1] == ' ' || pszData[count - 1] == 0))

                --count;

            pszData[count] = '\0';

            break;

        case TIFF_SHORT:

        {

            const GUInt16 *wp = reinterpret_cast<const GUInt16 *>(data);

            for (; count > 0; count--)

            {

                snprintf(szTemp, sizeof(szTemp), "%s%u", sep, *wp);

                wp++;

                sep = " ";

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        }

        case TIFF_SSHORT:

        {

            const GInt16 *wp = reinterpret_cast<const GInt16 *>(data);

            for (; count > 0; count--)

            {

                snprintf(szTemp, sizeof(szTemp), "%s%d", sep, *wp);

                wp++;

                sep = " ";

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        }

        case TIFF_LONG:

        {

            const GUInt32 *lp = reinterpret_cast<const GUInt32 *>(data);

            for (; count > 0; count--)

            {

                snprintf(szTemp, sizeof(szTemp), "%s%u", sep, *lp);

                lp++;

                sep = " ";

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        }

        case TIFF_SLONG:

        {

            const GInt32 *lp = reinterpret_cast<const GInt32 *>(data);

            for (; count > 0; count--)

            {

                snprintf(szTemp, sizeof(szTemp), "%s%d", sep, *lp);

                lp++;

                sep = " ";

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        }

        case TIFF_RATIONAL:

        {

            const GUInt32 *lp = reinterpret_cast<const GUInt32 *>(data);

            //      if(bSwabflag)

            //      TIFFSwabArrayOfLong((GUInt32*) data, 2*count);

            for (; count > 0; count--)

            {

                if ((lp[0] == 0) || (lp[1] == 0))

                {

                    snprintf(szTemp, sizeof(szTemp), "%s(0)", sep);

                }

                else

                {

                    CPLsnprintf(szTemp, sizeof(szTemp), "%s(%g)", sep,

                                static_cast<double>(lp[0]) /

                                    static_cast<double>(lp[1]));

                }

                sep = " ";

                lp += 2;

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        }

        case TIFF_SRATIONAL:

        {

            const GInt32 *lp = reinterpret_cast<const GInt32 *>(data);

            for (; count > 0; count--)

            {

                if ((lp[0] == 0) || (lp[1] == 0))

                {

                    snprintf(szTemp, sizeof(szTemp), "%s(0)", sep);

                }

                else

                {

                    CPLsnprintf(szTemp, sizeof(szTemp), "%s(%g)", sep,

                                static_cast<double>(lp[0]) /

                                    static_cast<double>(lp[1]));

                }

                sep = " ";

                lp += 2;

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        }

        case TIFF_FLOAT:

        {

            const float *fp = reinterpret_cast<const float *>(data);

            for (; count > 0; count--)

            {

                CPLsnprintf(szTemp, sizeof(szTemp), "%s%g", sep, *fp);

                fp++;

                sep = " ";

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        }

        case TIFF_DOUBLE:

        {

            const double *dp = reinterpret_cast<const double *>(data);

            for (; count > 0; count--)

            {

                CPLsnprintf(szTemp, sizeof(szTemp), "%s%g", sep, *dp);

                dp++;

                sep = " ";

                if (strlen(szTemp) + pszDataEnd - pszData >= MAXSTRINGLENGTH)

                    break;

                strcat(pszDataEnd, szTemp);

                pszDataEnd += strlen(pszDataEnd);

            }

            break;

        }

        default:

            return;

    }

    if (type != TIFF_ASCII && count != 0)

    {

        CPLError(CE_Warning, CPLE_AppDefined, "EXIF metadata truncated");

    }

}

/*

 * Return size of TIFFDataType in bytes

 */

static int EXIF_TIFFDataWidth(int /* GDALEXIFTIFFDataType */ type)

{

    switch (type)

    {

        case 0: /* nothing */

        case TIFF_BYTE:

        case TIFF_ASCII:

        case TIFF_SBYTE:

        case TIFF_UNDEFINED:

            return 1;

        case TIFF_SHORT:

        case TIFF_SSHORT:

            return 2;

        case TIFF_LONG:

        case TIFF_SLONG:

        case TIFF_FLOAT:

        case TIFF_IFD:

            return 4;

        case TIFF_RATIONAL:

        case TIFF_SRATIONAL:

        case TIFF_DOUBLE:

            // case TIFF_LONG8:

            // case TIFF_SLONG8:

            // case TIFF_IFD8:

            return 8;

        default:

            return 0; /* will return 0 for unknown types */

    }

}

/************************************************************************/

/*                        EXIFExtractMetadata()                         */

/*                                                                      */

/*      Extract all entry from a IFD                                    */

/************************************************************************/

CPLErr EXIFExtractMetadata(char **&papszMetadata, void *fpInL, int nOffset,

                           int bSwabflag, int nTIFFHEADER, int &nExifOffset,

                           int &nInterOffset, int &nGPSOffset)

{

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

    /*      Read number of entry in directory                               */

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

    GUInt16 nEntryCount;

    VSILFILE *const fp = static_cast<VSILFILE *>(fpInL);

    if (nOffset > INT_MAX - nTIFFHEADER ||

        VSIFSeekL(fp, nOffset + nTIFFHEADER, SEEK_SET) != 0 ||

        VSIFReadL(&nEntryCount, 1, sizeof(GUInt16), fp) != sizeof(GUInt16))

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "Error reading EXIF Directory count at " CPL_FRMT_GUIB,

                 static_cast<vsi_l_offset>(nOffset) + nTIFFHEADER);

        return CE_Failure;

    }

    if (bSwabflag)

        CPL_SWAP16PTR(&nEntryCount);

    // Some apps write empty directories - see bug 1523.

    if (nEntryCount == 0)

        return CE_None;

    // Some files are corrupt, a large entry count is a sign of this.

    if (nEntryCount > 125)

    {

        CPLError(CE_Warning, CPLE_AppDefined,

                 "Ignoring EXIF directory with unlikely entry count (%d).",

                 nEntryCount);

        return CE_Warning;

    }

    GDALEXIFTIFFDirEntry *poTIFFDir = static_cast<GDALEXIFTIFFDirEntry *>(

        CPLMalloc(nEntryCount * sizeof(GDALEXIFTIFFDirEntry)));

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

    /*      Read all directory entries                                      */

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

    {

        const unsigned int n = static_cast<int>(VSIFReadL(

            poTIFFDir, 1, nEntryCount * sizeof(GDALEXIFTIFFDirEntry), fp));

        if (n != nEntryCount * sizeof(GDALEXIFTIFFDirEntry))

        {

            CPLError(CE_Failure, CPLE_AppDefined,

                     "Could not read all directories");

            CPLFree(poTIFFDir);

            return CE_Failure;

        }

    }

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

    /*      Parse all entry information in this directory                   */

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

    vector<char> oTempStorage(MAXSTRINGLENGTH + 1, 0);

    char *const szTemp = &oTempStorage[0];

    char szName[128];

    GDALEXIFTIFFDirEntry *poTIFFDirEntry = poTIFFDir;

    for (unsigned int i = nEntryCount; i > 0; i--, poTIFFDirEntry++)

    {

        if (bSwabflag)

        {

            CPL_SWAP16PTR(&poTIFFDirEntry->tdir_tag);

            CPL_SWAP16PTR(&poTIFFDirEntry->tdir_type);

            CPL_SWAP32PTR(&poTIFFDirEntry->tdir_count);

            CPL_SWAP32PTR(&poTIFFDirEntry->tdir_offset);

        }

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

         */

        /*      Find Tag name in table */

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

         */

        szName[0] = '\0';

        szTemp[0] = '\0';

        for (const EXIFTagDesc *poExifTags = exiftags; poExifTags->tag;

             poExifTags++)

        {

            if (poExifTags->tag == poTIFFDirEntry->tdir_tag)

            {

                CPLAssert(nullptr != poExifTags->name);

                CPLStrlcpy(szName, poExifTags->name, sizeof(szName));

                break;

            }

        }

        if (szName[0] == 0)

        {

            for (const EXIFTagDesc *poTag = IFD0Tags; poTag->tag; poTag++)

            {

                if (poTag->tag == poTIFFDirEntry->tdir_tag)

                {

                    CPLAssert(nullptr != poTag->name);

                    CPLStrlcpy(szName, poTag->name, sizeof(szName));

                    break;

                }

            }

        }

        if (nOffset == nGPSOffset)

        {

            for (const EXIFTagDesc *poGPSTags = gpstags;

                 poGPSTags->tag != 0xffff; poGPSTags++)

            {

                if (poGPSTags->tag == poTIFFDirEntry->tdir_tag)

                {

                    CPLAssert(nullptr != poGPSTags->name);

                    CPLStrlcpy(szName, poGPSTags->name, sizeof(szName));

                    break;

                }

            }

        }

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

         */

        /*      If the tag was not found, look into the interoperability table

         */

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

         */

        if (nOffset == nInterOffset)

        {

            const struct intr_tag *poInterTags = intr_tags;

            for (; poInterTags->tag; poInterTags++)

                if (poInterTags->tag == poTIFFDirEntry->tdir_tag)

                {

                    CPLAssert(nullptr != poInterTags->name);

                    CPLStrlcpy(szName, poInterTags->name, sizeof(szName));

                    break;

                }

        }

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

         */

        /*      Save important directory tag offset */

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

         */

        // Our current API uses int32 and not uint32

        if (poTIFFDirEntry->tdir_offset < INT_MAX)

        {

            if (poTIFFDirEntry->tdir_tag == EXIFOFFSETTAG)

            {

                nExifOffset = poTIFFDirEntry->tdir_offset;

                continue;

            }

            else if (poTIFFDirEntry->tdir_tag == INTEROPERABILITYOFFSET)

            {

                nInterOffset = poTIFFDirEntry->tdir_offset;

                continue;

            }

            else if (poTIFFDirEntry->tdir_tag == GPSOFFSETTAG)

            {

                nGPSOffset = poTIFFDirEntry->tdir_offset;

                continue;

            }

        }

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

        /*      If we didn't recognise the tag, report it as CPLDebug()      */

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

        bool bUnknownTag = false;

        if (szName[0] == '\0')

        {

            snprintf(szName, sizeof(szName), "EXIF_%u",

                     poTIFFDirEntry->tdir_tag);

            bUnknownTag = true;

        }

        vsi_l_offset nTagValueOffset = poTIFFDirEntry->tdir_offset;

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

         */

        /*      For UserComment we need to ignore the language binding and */

        /*      just return the actual contents. */

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

         */

        if (EQUAL(szName, "EXIF_UserComment"))

        {

            poTIFFDirEntry->tdir_type = TIFF_ASCII;

            if (poTIFFDirEntry->tdir_count >= 8)

            {

                poTIFFDirEntry->tdir_count -= 8;

                nTagValueOffset += 8;

            }

        }

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

         */

        /*      Make some UNDEFINED or BYTE fields ASCII for readability. */

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

         */

        if (EQUAL(szName, "EXIF_ExifVersion") ||

            EQUAL(szName, "EXIF_FlashPixVersion") ||

            EQUAL(szName, "EXIF_MakerNote") ||

            EQUAL(szName, "GPSProcessingMethod") ||

            EQUAL(szName, "EXIF_XmlPacket"))

            poTIFFDirEntry->tdir_type = TIFF_ASCII;

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

         */

        /*      Print tags */

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

         */

        if (poTIFFDirEntry->tdir_count > static_cast<GUInt32>(MAXSTRINGLENGTH))

        {

            CPLError(CE_Warning, CPLE_AppDefined,

                     "Too many bytes in tag: %u, ignoring tag.",

                     poTIFFDirEntry->tdir_count);

            continue;

        }

        const int nDataWidth = EXIF_TIFFDataWidth(poTIFFDirEntry->tdir_type);

        if (nDataWidth == 0 || poTIFFDirEntry->tdir_type >= TIFF_IFD)

        {

            CPLError(CE_Warning, CPLE_AppDefined,

                     "Invalid or unhandled EXIF data type: %d, ignoring tag.",

                     poTIFFDirEntry->tdir_type);

            continue;

        }

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

         */

        /*      This is at most 4 byte data so we can read it from tdir_offset

         */

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

         */

        const int space = poTIFFDirEntry->tdir_count * nDataWidth;

        if (space >= 0 && space <= 4)

        {

            unsigned char data[4];

            memcpy(data, &poTIFFDirEntry->tdir_offset, 4);

            if (bSwabflag)

            {

                GUInt32 nValUInt32;

                // Unswab 32bit value, and reswab per data type.

                memcpy(&nValUInt32, data, 4);

                CPL_SWAP32PTR(&nValUInt32);

                memcpy(data, &nValUInt32, 4);

                switch (poTIFFDirEntry->tdir_type)

                {

                    case TIFF_LONG:

                    case TIFF_SLONG:

                    case TIFF_FLOAT:

                        memcpy(&nValUInt32, data, 4);

                        CPL_SWAP32PTR(&nValUInt32);

                        memcpy(data, &nValUInt32, 4);

                        break;

                    case TIFF_SSHORT:

                    case TIFF_SHORT:

                        for (unsigned j = 0; j < poTIFFDirEntry->tdir_count;

                             j++)

                        {

                            CPL_SWAP16PTR(reinterpret_cast<GUInt16 *>(data) +

                                          j);

                        }

                        break;

                    default:

                        break;

                }

            }

            EXIFPrintData(szTemp, poTIFFDirEntry->tdir_type,

                          poTIFFDirEntry->tdir_count, data);

        }

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

         */

        /*      The data is being read where tdir_offset point to in the file */

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

         */

        else if (space > 0 && space < MAXSTRINGLENGTH)

        {

            unsigned char *data =

                static_cast<unsigned char *>(VSIMalloc(space));

            if (data)

            {

                CPL_IGNORE_RET_VAL(

                    VSIFSeekL(fp, nTagValueOffset + nTIFFHEADER, SEEK_SET));

                CPL_IGNORE_RET_VAL(VSIFReadL(data, 1, space, fp));

                if (bSwabflag)

                {

                    switch (poTIFFDirEntry->tdir_type)

                    {

                        case TIFF_SHORT:

                        case TIFF_SSHORT:

                        {

                            for (unsigned j = 0; j < poTIFFDirEntry->tdir_count;

                                 j++)

                            {

                                CPL_SWAP16PTR(

                                    reinterpret_cast<GUInt16 *>(data) + j);

                            }

                            break;

                        }

                        case TIFF_LONG:

                        case TIFF_SLONG:

                        case TIFF_FLOAT:

                        {

                            for (unsigned j = 0; j < poTIFFDirEntry->tdir_count;

                                 j++)

                            {

                                CPL_SWAP32PTR(

                                    reinterpret_cast<GUInt32 *>(data) + j);

                            }

                            break;

                        }

                        case TIFF_RATIONAL:

                        case TIFF_SRATIONAL:

                        {

                            for (unsigned j = 0;

                                 j < 2 * poTIFFDirEntry->tdir_count; j++)

                            {

                                CPL_SWAP32PTR(

                                    reinterpret_cast<GUInt32 *>(data) + j);

                            }

                            break;

                        }

                        case TIFF_DOUBLE:

                        {

                            for (unsigned j = 0; j < poTIFFDirEntry->tdir_count;

                                 j++)

                            {

                                CPL_SWAPDOUBLE(

                                    reinterpret_cast<double *>(data) + j);

                            }

                            break;

                        }

                        default:

                            break;

                    }

                }

                EXIFPrintData(szTemp, poTIFFDirEntry->tdir_type,

                              poTIFFDirEntry->tdir_count, data);

                CPLFree(data);

            }

        }

        else

        {

            CPLError(CE_Warning, CPLE_AppDefined,

                     "Invalid EXIF header size: %ld, ignoring tag.",

                     static_cast<long>(space));

        }

        if (bUnknownTag)

            CPLDebug("EXIF", "Ignoring %s=%s", szName, szTemp);

        else

            papszMetadata = CSLSetNameValue(papszMetadata, szName, szTemp);

    }

    CPLFree(poTIFFDir);

    return CE_None;

}

/************************************************************************/

/*                        WriteLEUInt16()                               */

/************************************************************************/

static void WriteLEUInt16(GByte *pabyData, GUInt32 &nBufferOff, GUInt16 nVal)

{

    pabyData[nBufferOff] = static_cast<GByte>(nVal & 0xff);

    pabyData[nBufferOff + 1] = static_cast<GByte>(nVal >> 8);

    nBufferOff += 2;

}

/************************************************************************/

/*                        WriteLEUInt32()                               */

/************************************************************************/

static void WriteLEUInt32(GByte *pabyData, GUInt32 &nBufferOff, GUInt32 nVal)

{

    pabyData[nBufferOff] = static_cast<GByte>(nVal & 0xff);

    pabyData[nBufferOff + 1] = static_cast<GByte>((nVal >> 8) & 0xff);

    pabyData[nBufferOff + 2] = static_cast<GByte>((nVal >> 16) & 0xff);

    pabyData[nBufferOff + 3] = static_cast<GByte>(nVal >> 24);

    nBufferOff += 4;

}

/************************************************************************/

/*                          GetHexValue()                               */

/************************************************************************/

static int GetHexValue(char ch)

{

    const char chDEC_ZERO = '0';

    if (ch >= chDEC_ZERO && ch <= '9')

        return ch - chDEC_ZERO;

    if (ch >= 'a' && ch <= 'f')

        return ch - 'a' + 10;

    if (ch >= 'A' && ch <= 'F')

        return ch - 'A' + 10;

    return -1;

}

/************************************************************************/

/*                         ParseUndefined()                             */

/************************************************************************/

static GByte *ParseUndefined(const char *pszVal, GUInt32 *pnLength)

{

    GUInt32 nSize = 0;

    bool bIsHexExcaped = true;

    const char chDEC_ZERO = '0';

    GByte *pabyData = reinterpret_cast<GByte *>(CPLMalloc(strlen(pszVal) + 1));

    // Is it a hexadecimal string like "0xA 0x1E 00 0xDF..." ?

    for (size_t i = 0; pszVal[i] != '\0';)

    {

        // 0xA

        if (pszVal[i] == chDEC_ZERO && pszVal[i + 1] == 'x' &&

            GetHexValue(pszVal[i + 2]) >= 0 &&

            (pszVal[i + 3] == ' ' || pszVal[i + 3] == '\0'))

        {