// ***************************************************************** -*- C++ -*-

/*

 * Copyright (C) 2004-2018 Exiv2 authors

 * This program is part of the Exiv2 distribution.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.

 */

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

// included header files

#include "tags_int.hpp"

#include "convert.hpp"

#include "error.hpp"

#include "i18n.h"                // NLS support.

#include "canonmn_int.hpp"

#include "casiomn_int.hpp"

#include "fujimn_int.hpp"

#include "minoltamn_int.hpp"

#include "nikonmn_int.hpp"

#include "olympusmn_int.hpp"

#include "panasonicmn_int.hpp"

#include "pentaxmn_int.hpp"

#include "samsungmn_int.hpp"

#include "sigmamn_int.hpp"

#include "sonymn_int.hpp"

#include <cmath>

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

// local declarations

namespace {

    // Print version string from an intermediate string

    std::ostream& printVersion(std::ostream& os, const std::string& str)

    {

        if (str.size() != 4) {

            return os << "(" << str << ")";

        }

        if (str[0] != '0') os << str[0];

        return os << str[1] << "." << str[2] << str[3];

    }

}

namespace Exiv2 {

    namespace Internal {

    //! List of all known Exif groups. Important: Group name (3rd column) must be unique!

    extern const GroupInfo groupInfo[] = {

        { ifdIdNotSet,     "Unknown IFD", "Unknown", 0 },

        { ifd0Id,          "IFD0",      "Image",        ifdTagList                     },

        { ifd1Id,          "IFD1",      "Thumbnail",    ifdTagList                     },

        { ifd2Id,          "IFD2",      "Image2",       ifdTagList                     },

        { ifd3Id,          "IFD3",      "Image3",       ifdTagList                     },

        { exifId,          "Exif",      "Photo",        exifTagList                    },

        { gpsId,           "GPSInfo",   "GPSInfo",      gpsTagList                     },

        { iopId,           "Iop",       "Iop",          iopTagList                     },

        { mpfId,           "MPF",       "MpfInfo",      mpfTagList                     },

        { subImage1Id,     "SubImage1", "SubImage1",    ifdTagList                     },

        { subImage2Id,     "SubImage2", "SubImage2",    ifdTagList                     },

        { subImage3Id,     "SubImage3", "SubImage3",    ifdTagList                     },

        { subImage4Id,     "SubImage4", "SubImage4",    ifdTagList                     },

        { subImage5Id,     "SubImage5", "SubImage5",    ifdTagList                     },

        { subImage6Id,     "SubImage6", "SubImage6",    ifdTagList                     },

        { subImage7Id,     "SubImage7", "SubImage7",    ifdTagList                     },

        { subImage8Id,     "SubImage8", "SubImage8",    ifdTagList                     },

        { subImage9Id,     "SubImage9", "SubImage9",    ifdTagList                     },

        { subThumb1Id,     "SubThumb1", "SubThumb1",    ifdTagList                     },

        { panaRawId,       "PanaRaw",   "PanasonicRaw", PanasonicMakerNote::tagListRaw },

        { mnId,            "Makernote", "MakerNote",    mnTagList                      },

        { canonId,         "Makernote", "Canon",        CanonMakerNote::tagList        },

        { canonCsId,       "Makernote", "CanonCs",      CanonMakerNote::tagListCs      },

        { canonSiId,       "Makernote", "CanonSi",      CanonMakerNote::tagListSi      },

        { canonCfId,       "Makernote", "CanonCf",      CanonMakerNote::tagListCf      },

        { canonPiId,       "Makernote", "CanonPi",      CanonMakerNote::tagListPi      },

        { canonTiId,       "Makernote", "CanonTi",      CanonMakerNote::tagListTi      },

        { canonFiId,       "Makernote", "CanonFi",      CanonMakerNote::tagListFi      },

        { canonPaId,       "Makernote", "CanonPa",      CanonMakerNote::tagListPa      },

        { canonPrId,       "Makernote", "CanonPr",      CanonMakerNote::tagListPr      },

        { casioId,         "Makernote", "Casio",        CasioMakerNote::tagList        },

        { casio2Id,        "Makernote", "Casio2",       Casio2MakerNote::tagList       },

        { fujiId,          "Makernote", "Fujifilm",     FujiMakerNote::tagList         },

        { minoltaId,       "Makernote", "Minolta",      MinoltaMakerNote::tagList      },

        { minoltaCs5DId,   "Makernote", "MinoltaCs5D",  MinoltaMakerNote::tagListCs5D  },

        { minoltaCs7DId,   "Makernote", "MinoltaCs7D",  MinoltaMakerNote::tagListCs7D  },

        { minoltaCsOldId,  "Makernote", "MinoltaCsOld", MinoltaMakerNote::tagListCsStd },

        { minoltaCsNewId,  "Makernote", "MinoltaCsNew", MinoltaMakerNote::tagListCsStd },

        { nikon1Id,        "Makernote", "Nikon1",       Nikon1MakerNote::tagList       },

        { nikon2Id,        "Makernote", "Nikon2",       Nikon2MakerNote::tagList       },

        { nikon3Id,        "Makernote", "Nikon3",       Nikon3MakerNote::tagList       },

        { nikonPvId,       "Makernote", "NikonPreview", ifdTagList                     },

        { nikonVrId,       "Makernote", "NikonVr",      Nikon3MakerNote::tagListVr     },

        { nikonPcId,       "Makernote", "NikonPc",      Nikon3MakerNote::tagListPc     },

        { nikonWtId,       "Makernote", "NikonWt",      Nikon3MakerNote::tagListWt     },

        { nikonIiId,       "Makernote", "NikonIi",      Nikon3MakerNote::tagListIi     },

        { nikonAfId,       "Makernote", "NikonAf",      Nikon3MakerNote::tagListAf     },

        { nikonAf21Id,     "Makernote", "NikonAf2",     Nikon3MakerNote::tagListAf21   },

        { nikonAf22Id,     "Makernote", "NikonAf22",    Nikon3MakerNote::tagListAf22   },

        { nikonAFTId,      "Makernote", "NikonAFT",     Nikon3MakerNote::tagListAFT    },

        { nikonFiId,       "Makernote", "NikonFi",      Nikon3MakerNote::tagListFi     },

        { nikonMeId,       "Makernote", "NikonMe",      Nikon3MakerNote::tagListMe     },

        { nikonFl1Id,      "Makernote", "NikonFl1",     Nikon3MakerNote::tagListFl1    },

        { nikonFl2Id,      "Makernote", "NikonFl2",     Nikon3MakerNote::tagListFl2    },

        { nikonFl3Id,      "Makernote", "NikonFl3",     Nikon3MakerNote::tagListFl3    },

        { nikonSi1Id,      "Makernote", "NikonSiD80",   Nikon3MakerNote::tagListSi1    },

        { nikonSi2Id,      "Makernote", "NikonSiD40",   Nikon3MakerNote::tagListSi2    },

        { nikonSi3Id,      "Makernote", "NikonSiD300a", Nikon3MakerNote::tagListSi3    },

        { nikonSi4Id,      "Makernote", "NikonSiD300b", Nikon3MakerNote::tagListSi4    },

        { nikonSi5Id,      "Makernote", "NikonSi02xx",  Nikon3MakerNote::tagListSi5    },

        { nikonSi6Id,      "Makernote", "NikonSi01xx",  Nikon3MakerNote::tagListSi5    },

        { nikonCb1Id,      "Makernote", "NikonCb1",     Nikon3MakerNote::tagListCb1    },

        { nikonCb2Id,      "Makernote", "NikonCb2",     Nikon3MakerNote::tagListCb2    },

        { nikonCb2aId,     "Makernote", "NikonCb2a",    Nikon3MakerNote::tagListCb2a   },

        { nikonCb2bId,     "Makernote", "NikonCb2b",    Nikon3MakerNote::tagListCb2b   },

        { nikonCb3Id,      "Makernote", "NikonCb3",     Nikon3MakerNote::tagListCb3    },

        { nikonCb4Id,      "Makernote", "NikonCb4",     Nikon3MakerNote::tagListCb4    },

        { nikonLd1Id,      "Makernote", "NikonLd1",     Nikon3MakerNote::tagListLd1    },

        { nikonLd2Id,      "Makernote", "NikonLd2",     Nikon3MakerNote::tagListLd2    },

        { nikonLd3Id,      "Makernote", "NikonLd3",     Nikon3MakerNote::tagListLd3    },

        { olympusId,       "Makernote", "Olympus",      OlympusMakerNote::tagList      },

        { olympus2Id,      "Makernote", "Olympus2",     OlympusMakerNote::tagList      },

        { olympusCsId,     "Makernote", "OlympusCs",    OlympusMakerNote::tagListCs    },

        { olympusEqId,     "Makernote", "OlympusEq",    OlympusMakerNote::tagListEq    },

        { olympusRdId,     "Makernote", "OlympusRd",    OlympusMakerNote::tagListRd    },

        { olympusRd2Id,    "Makernote", "OlympusRd2",   OlympusMakerNote::tagListRd2   },

        { olympusIpId,     "Makernote", "OlympusIp",    OlympusMakerNote::tagListIp    },

        { olympusFiId,     "Makernote", "OlympusFi",    OlympusMakerNote::tagListFi    },

        { olympusFe1Id,    "Makernote", "OlympusFe1",   OlympusMakerNote::tagListFe    },

        { olympusFe2Id,    "Makernote", "OlympusFe2",   OlympusMakerNote::tagListFe    },

        { olympusFe3Id,    "Makernote", "OlympusFe3",   OlympusMakerNote::tagListFe    },

        { olympusFe4Id,    "Makernote", "OlympusFe4",   OlympusMakerNote::tagListFe    },

        { olympusFe5Id,    "Makernote", "OlympusFe5",   OlympusMakerNote::tagListFe    },

        { olympusFe6Id,    "Makernote", "OlympusFe6",   OlympusMakerNote::tagListFe    },

        { olympusFe7Id,    "Makernote", "OlympusFe7",   OlympusMakerNote::tagListFe    },

        { olympusFe8Id,    "Makernote", "OlympusFe8",   OlympusMakerNote::tagListFe    },

        { olympusFe9Id,    "Makernote", "OlympusFe9",   OlympusMakerNote::tagListFe    },

        { olympusRiId,     "Makernote", "OlympusRi",    OlympusMakerNote::tagListRi    },

        { panasonicId,     "Makernote", "Panasonic",    PanasonicMakerNote::tagList    },

        { pentaxDngId,     "Makernote", "PentaxDng",    PentaxMakerNote::tagList       },

        { pentaxId,        "Makernote", "Pentax",       PentaxMakerNote::tagList       },

        { samsung2Id,      "Makernote", "Samsung2",     Samsung2MakerNote::tagList     },

        { samsungPvId,     "Makernote", "SamsungPreview", ifdTagList                   },

        { samsungPwId,     "Makernote", "SamsungPictureWizard", Samsung2MakerNote::tagListPw },

        { sigmaId,         "Makernote", "Sigma",        SigmaMakerNote::tagList        },

        { sony1Id,         "Makernote", "Sony1",        SonyMakerNote::tagList         },

        { sony2Id,         "Makernote", "Sony2",        SonyMakerNote::tagList         },

        { sonyMltId,       "Makernote", "SonyMinolta",  MinoltaMakerNote::tagList      },

        { sony1CsId,       "Makernote", "Sony1Cs",      SonyMakerNote::tagListCs       },

        { sony1Cs2Id,      "Makernote", "Sony1Cs2",     SonyMakerNote::tagListCs2      },

        { sony1MltCs7DId,  "Makernote", "Sony1MltCs7D", MinoltaMakerNote::tagListCs7D  },

        { sony1MltCsOldId, "Makernote", "Sony1MltCsOld",MinoltaMakerNote::tagListCsStd },

        { sony1MltCsNewId, "Makernote", "Sony1MltCsNew",MinoltaMakerNote::tagListCsStd },

        { sony1MltCsA100Id,"Makernote", "Sony1MltCsA100",MinoltaMakerNote::tagListCsA100},

        { sony2CsId,       "Makernote", "Sony2Cs",      SonyMakerNote::tagListCs       },

        { sony2Cs2Id,      "Makernote", "Sony2Cs2",     SonyMakerNote::tagListCs2      },

        { sony2FpId,       "Makernote", "Sony2Fp",      SonyMakerNote::tagListFp       },

        { sony2010eId,     "Makernote", "Sony2010e",    SonyMakerNote::tagList2010e    },

        { lastId,          "(Last IFD info)", "(Last IFD item)", 0 }

    };

    //! Units for measuring X and Y resolution, tags 0x0128, 0xa210

    extern const TagDetails exifUnit[] = {

        { 1, N_("none") },

        { 2, N_("inch") },

        { 3, N_("cm")   }

    };

    //! GPS altitude reference, tag 0x0005

    extern const TagDetails exifGPSAltitudeRef[] = {

        { 0, N_("Above sea level") },

        { 1, N_("Below sea level") }

    };

    //! GPS status, tag 0x0009

    extern const TagDetails exifGPSStatus[] = {

        { 'A', N_("Measurement in progress")      },

        { 'V', N_("Measurement Interoperability") }

    };

    //! GPS measurement mode, tag 0x000a

    extern const TagDetails exifGPSMeasureMode[] = {

        { '2', N_("Two-dimensional measurement")   },

        { '3', N_("Three-dimensional measurement") }

    };

    //! GPS speed reference, tag 0x000c

    extern const TagDetails exifGPSSpeedRef[] = {

        { 'K', N_("km/h")  },

        { 'M', N_("mph")   },

        { 'N', N_("knots") }

    };

    //! GPS Destination distance ref, tag 0x0019

    extern const TagDetails exifGPSDestDistanceRef[] = {

        { 'K', N_("Kilometers") },

        { 'M', N_("Miles")      },

        { 'N', N_("Knots")      }

    };

    //! GPS Differential, tag 0x001e

    extern const TagDetails exifGPSDifferential[] = {

        { 0, N_("Without correction") },

        { 1, N_("Correction applied") }

    };

    //! Orientation, tag 0x0112

    extern const TagDetails exifOrientation[] = {

        { 1, N_("top, left")     },

        { 2, N_("top, right")    },

        { 3, N_("bottom, right") },

        { 4, N_("bottom, left")  },

        { 5, N_("left, top")     },

        { 6, N_("right, top")    },

        { 7, N_("right, bottom") },

        { 8, N_("left, bottom")  },

        { 8, N_("left, bottom")  }              // To silence compiler warning

    };

    //! Predictor, tag 0x013d

    extern const TagDetails exifPredictor[] = {

        { 1, N_("No prediction scheme used") },

        { 2, N_("Horizontal differencing")   }

    };

    //! InkSet, tag 0x014c

    extern const TagDetails exifInkSet[] = {

        { 1, N_("CMYK")     },

        { 2, N_("not CMYK") }

    };

    //! NewSubfileType, TIFF tag 0x00fe - this is actually a bitmask

    extern const TagDetails exifNewSubfileType[] = {

        {  0, N_("Primary image")                                               },

        {  1, N_("Thumbnail/Preview image")                                     },

        {  2, N_("Primary image, Multi page file")                              },

        {  3, N_("Thumbnail/Preview image, Multi page file")                    },

        {  4, N_("Primary image, Transparency mask")                            },

        {  5, N_("Thumbnail/Preview image, Transparency mask")                  },

        {  6, N_("Primary image, Multi page file, Transparency mask")           },

        {  7, N_("Thumbnail/Preview image, Multi page file, Transparency mask") },

        {  7, N_("Thumbnail/Preview image, Multi page file, Transparency mask") }  // To silence compiler warning

    };

    //! SubfileType, TIFF tag 0x00ff

    extern const TagDetails exifSubfileType[] = {

        {  1, N_("Full-resolution image data")                                  },

        {  2, N_("Reduced-resolution image data")                               },

        {  3, N_("A single page of a multi-page image")                         }

    };

    //! Compression, tag 0x0103

    extern const TagDetails exifCompression[] = {

        {     1, N_("Uncompressed")             },

        {     2, N_("CCITT RLE")                },

        {     3, N_("T4/Group 3 Fax")           },

        {     4, N_("T6/Group 4 Fax")           },

        {     5, N_("LZW")                      },

        {     6, N_("JPEG (old-style)")         },

        {     7, N_("JPEG")                     },

        {     8, N_("Adobe Deflate")            },

        {     9, N_("JBIG B&W")                 },

        {    10, N_("JBIG Color")               },

        { 32766, N_("Next 2-bits RLE")          },

        { 32769, N_("Epson ERF Compressed")     },

        { 32770, N_("Samsung SRW Compressed")   },

        { 32771, N_("CCITT RLE 1-word")         },

        { 32773, N_("PackBits (Macintosh RLE)") },

        { 32809, N_("Thunderscan RLE")          },

        { 32895, N_("IT8 CT Padding")           },

        { 32896, N_("IT8 Linework RLE")         },

        { 32897, N_("IT8 Monochrome Picture")   },

        { 32898, N_("IT8 Binary Lineart")       },

        { 32908, N_("Pixar Film (10-bits LZW)") },

        { 32909, N_("Pixar Log (11-bits ZIP)")  },

        { 32946, N_("Pixar Deflate")            },

        { 32947, N_("Kodak DCS Encoding")       },

        { 34661, N_("ISO JBIG")                 },

        { 34676, N_("SGI Log Luminance RLE")    },

        { 34677, N_("SGI Log 24-bits packed")   },

        { 34712, N_("Leadtools JPEG 2000")      },

        { 34713, N_("Nikon NEF Compressed")     },

        { 65000, N_("Kodak DCR Compressed")     },

        { 65535, N_("Pentax PEF Compressed")    }

    };

    //! PhotometricInterpretation, tag 0x0106

    extern const TagDetails exifPhotometricInterpretation[] = {

        {     0, N_("White Is Zero")      },

        {     1, N_("Black Is Zero")      },

        {     2, N_("RGB")                },

        {     3, N_("RGB Palette")        },

        {     4, N_("Transparency Mask")  },

        {     5, N_("CMYK")               },

        {     6, N_("YCbCr")              },

        {     8, N_("CIELab")             },

        {     9, N_("ICCLab")             },

        {    10, N_("ITULab")             },

        { 32803, N_("Color Filter Array") },

        { 32844, N_("Pixar LogL")         },

        { 32845, N_("Pixar LogLuv")       },

        { 34892, N_("Linear Raw")         }

    };

    //! Thresholding, tag 0x0107

    extern const TagDetails exifThresholding[] = {

        { 1, N_("No dithering or halftoning")           },

        { 2, N_("Ordered dither or halftone technique") },

        { 3, N_("Randomized process")                   }

    };

    //! SampleFormat, tag 0x0153

    extern const TagDetails exifSampleFormat[] = {

        { 1, N_("Unsigned integer data")                },

        { 2, N_("Two's complement signed integer data") },

        { 3, N_("IEEE floating point data")             },

        { 4, N_("Undefined data format")                },

        { 4, N_("Undefined data format")                } // To silence compiler warning

    };

    //! Indexed, tag 0x015a

    extern const TagDetails exifIndexed[] = {

        { 0, N_("Not indexed") },

        { 1, N_("Indexed")     }

    };

    //! exifJpegLosslessPredictor, tag 0x0205

    extern const TagDetails exifJpegLosslessPredictor[] = {

        { 1, N_("A")           },

        { 2, N_("B")           },

        { 3, N_("C")           },

        { 4, N_("A+B-C")       },

        { 5, N_("A+((B-C)/2)") },

        { 6, N_("B+((A-C)/2)") },

        { 7, N_("(A+B)/2")     }

    };

    //! Flash, Exif tag 0x9209

    extern const TagDetails exifFlash[] = {

        { 0x00, N_("No flash")                                                      },

        { 0x01, N_("Fired")                                                         },

        { 0x05, N_("Fired, return light not detected")                              },

        { 0x07, N_("Fired, return light detected")                                  },

        { 0x08, N_("Yes, did not fire")                                             },

        { 0x09, N_("Yes, compulsory")                                               },

        { 0x0d, N_("Yes, compulsory, return light not detected")                    },

        { 0x0f, N_("Yes, compulsory, return light detected")                        },

        { 0x10, N_("No, compulsory")                                                },

        { 0x14, N_("No, did not fire, return light not detected")                   },

        { 0x18, N_("No, auto")                                                      },

        { 0x19, N_("Yes, auto")                                                     },

        { 0x1d, N_("Yes, auto, return light not detected")                          },

        { 0x1f, N_("Yes, auto, return light detected")                              },

        { 0x20, N_("No flash function")                                             },

        { 0x20, N_("No, no flash function")                                         },

        { 0x41, N_("Yes, red-eye reduction")                                        },

        { 0x45, N_("Yes, red-eye reduction, return light not detected")             },

        { 0x47, N_("Yes, red-eye reduction, return light detected")                 },

        { 0x49, N_("Yes, compulsory, red-eye reduction")                            },

        { 0x4d, N_("Yes, compulsory, red-eye reduction, return light not detected") },

        { 0x4f, N_("Yes, compulsory, red-eye reduction, return light detected")     },

        { 0x50, N_("No, red-eye reduction")                                         },

        { 0x58, N_("No, auto, red-eye reduction")                                   },

        { 0x59, N_("Yes, auto, red-eye reduction")                                  },

        { 0x5d, N_("Yes, auto, red-eye reduction, return light not detected")       },

        { 0x5f, N_("Yes, auto, red-eye reduction, return light detected")           }

    };

    //! CFALayout, tag 0xc617

    extern const TagDetails exifCfaLayout[] = {

        { 1, N_("Rectangular (or square) layout") },

        { 2, N_("Staggered layout A: even columns are offset down by 1/2 row")  },

        { 3, N_("Staggered layout B: even columns are offset up by 1/2 row")    },

        { 4, N_("Staggered layout C: even rows are offset right by 1/2 column") },

        { 5, N_("Staggered layout D: even rows are offset left by 1/2 column")  }

    };

    //! Base IFD Tags (IFD0 and IFD1)

    static const TagInfo ifdTagInfo[] = {

        TagInfo(0x000b, "ProcessingSoftware", N_("Processing Software"),

                N_("The name and version of the software used to post-process "

                   "the picture."), // ACD Systems Digital Imaging tag

                ifd0Id, otherTags, asciiString, 0, printValue),

        TagInfo(0x00fe, "NewSubfileType", N_("New Subfile Type"),

                N_("A general indication of the kind of data contained in this subfile."),

                ifd0Id, imgStruct, unsignedLong, 1, EXV_PRINT_TAG(exifNewSubfileType)), // TIFF tag

        TagInfo(0x00ff, "SubfileType", N_("Subfile Type"),

                N_("A general indication of the kind of data contained in this subfile. "

                   "This field is deprecated. The NewSubfileType field should be used instead."),

                ifd0Id, imgStruct, unsignedShort, 1, EXV_PRINT_TAG(exifSubfileType)), // TIFF tag

        TagInfo(0x0100, "ImageWidth", N_("Image Width"),

                N_("The number of columns of image data, equal to the number of "

                "pixels per row. In JPEG compressed data a JPEG marker is "

                "used instead of this tag."),

                ifd0Id, imgStruct, unsignedLong, 1, printValue),

        TagInfo(0x0101, "ImageLength", N_("Image Length"),

                N_("The number of rows of image data. In JPEG compressed data a "

                "JPEG marker is used instead of this tag."),

                ifd0Id, imgStruct, unsignedLong, 1, printValue),

        TagInfo(0x0102, "BitsPerSample", N_("Bits per Sample"),

                N_("The number of bits per image component. In this standard each "

                "component of the image is 8 bits, so the value for this "

                "tag is 8. See also <SamplesPerPixel>. In JPEG compressed data "

                "a JPEG marker is used instead of this tag."),

                ifd0Id, imgStruct, unsignedShort, 3, printValue),

        TagInfo(0x0103, "Compression", N_("Compression"),

                N_("The compression scheme used for the image data. When a "

                "primary image is JPEG compressed, this designation is "

                "not necessary and is omitted. When thumbnails use JPEG "

                "compression, this tag value is set to 6."),

                ifd0Id, imgStruct, unsignedShort, 1, EXV_PRINT_TAG(exifCompression)),

        TagInfo(0x0106, "PhotometricInterpretation", N_("Photometric Interpretation"),

                N_("The pixel composition. In JPEG compressed data a JPEG "

                "marker is used instead of this tag."),

                ifd0Id, imgStruct, unsignedShort, 1, EXV_PRINT_TAG(exifPhotometricInterpretation)),

        TagInfo(0x0107, "Thresholding", N_("Thresholding"),

                N_("For black and white TIFF files that represent shades of gray, "

                   "the technique used to convert from gray to black and white pixels."),

                ifd0Id, imgStruct, unsignedShort, 1, EXV_PRINT_TAG(exifThresholding)), // TIFF tag

        TagInfo(0x0108, "CellWidth", N_("Cell Width"),

                N_("The width of the dithering or halftoning matrix used to create a "

                   "dithered or halftoned bilevel file."),

                ifd0Id, imgStruct, unsignedShort, 1, printValue), // TIFF tag

        TagInfo(0x0109, "CellLength", N_("Cell Length"),

                N_("The length of the dithering or halftoning matrix used to create a "

                   "dithered or halftoned bilevel file."),

                ifd0Id, imgStruct, unsignedShort, 1, printValue), // TIFF tag

        TagInfo(0x010a, "FillOrder", N_("Fill Order"),

                N_("The logical order of bits within a byte"),

                ifd0Id, imgStruct, unsignedShort, 1, printValue), // TIFF tag

        TagInfo(0x010d, "DocumentName", N_("Document Name"),

                N_("The name of the document from which this image was scanned"),

                ifd0Id, imgStruct, asciiString, 0, printValue), // TIFF tag

        TagInfo(0x010e, "ImageDescription", N_("Image Description"),

                N_("A character string giving the title of the image. It may be "

                "a comment such as \"1988 company picnic\" or "

                "the like. Two-bytes character codes cannot be used. "

                "When a 2-bytes code is necessary, the Exif Private tag "

                "<UserComment> is to be used."),

                ifd0Id, otherTags, asciiString, 0, printValue),

        TagInfo(0x010f, "Make", N_("Manufacturer"),

                N_("The manufacturer of the recording "

                "equipment. This is the manufacturer of the DSC, scanner, "

                "video digitizer or other equipment that generated the "

                "image. When the field is left blank, it is treated as unknown."),

                ifd0Id, otherTags, asciiString, 0, printValue),

        TagInfo(0x0110, "Model", N_("Model"),

                N_("The model name or model number of the equipment. This is the "

                "model name or number of the DSC, scanner, video digitizer "

                "or other equipment that generated the image. When the field "

                "is left blank, it is treated as unknown."),

                ifd0Id, otherTags, asciiString, 0, printValue),

        TagInfo(0x0111, "StripOffsets", N_("Strip Offsets"),

                N_("For each strip, the byte offset of that strip. It is "

                "recommended that this be selected so the number of strip "

                "bytes does not exceed 64 Kbytes. With JPEG compressed "

                "data this designation is not needed and is omitted. See also "

                "<RowsPerStrip> and <StripByteCounts>."),

                ifd0Id, recOffset, unsignedLong, -1, printValue),

        TagInfo(0x0112, "Orientation", N_("Orientation"),

                N_("The image orientation viewed in terms of rows and columns."),

                ifd0Id, imgStruct, unsignedShort, 1, print0x0112),

        TagInfo(0x0115, "SamplesPerPixel", N_("Samples per Pixel"),

                N_("The number of components per pixel. Since this standard applies "

                "to RGB and YCbCr images, the value set for this tag is 3. "

                "In JPEG compressed data a JPEG marker is used instead of this tag."),

                ifd0Id, imgStruct, unsignedShort, 1, printValue),

        TagInfo(0x0116, "RowsPerStrip", N_("Rows per Strip"),

                N_("The number of rows per strip. This is the number of rows "

                "in the image of one strip when an image is divided into "

                "strips. With JPEG compressed data this designation is not "

                "needed and is omitted. See also <StripOffsets> and <StripByteCounts>."),

                ifd0Id, recOffset, unsignedLong, 1, printValue),

        TagInfo(0x0117, "StripByteCounts", N_("Strip Byte Count"),

                N_("The total number of bytes in each strip. With JPEG compressed "

                "data this designation is not needed and is omitted."),

                ifd0Id, recOffset, unsignedLong, -1, printValue),

        TagInfo(0x011a, "XResolution", N_("X-Resolution"),

                N_("The number of pixels per <ResolutionUnit> in the <ImageWidth> "

                "direction. When the image resolution is unknown, 72 [dpi] is designated."),

                ifd0Id, imgStruct, unsignedRational, 1, printLong),

        TagInfo(0x011b, "YResolution", N_("Y-Resolution"),

                N_("The number of pixels per <ResolutionUnit> in the <ImageLength> "

                "direction. The same value as <XResolution> is designated."),

                ifd0Id, imgStruct, unsignedRational, 1, printLong),

        TagInfo(0x011c, "PlanarConfiguration", N_("Planar Configuration"),

                N_("Indicates whether pixel components are recorded in a chunky "

                "or planar format. In JPEG compressed files a JPEG marker "

                "is used instead of this tag. If this field does not exist, "

                "the TIFF default of 1 (chunky) is assumed."),

                ifd0Id, imgStruct, unsignedShort, 1, printValue),

        TagInfo(0x0122, "GrayResponseUnit", N_("Gray Response Unit"),

                N_("The precision of the information contained in the GrayResponseCurve."),

                ifd0Id, imgStruct, unsignedShort, 1, printValue), // TIFF tag

        TagInfo(0x0123, "GrayResponseCurve", N_("Gray Response Curve"),

                N_("For grayscale data, the optical density of each possible pixel value."),

                ifd0Id, imgStruct, unsignedShort, -1, printValue), // TIFF tag

        TagInfo(0x0124, "T4Options", N_("T4 Options"),

                N_("T.4-encoding options."),

                ifd0Id, imgStruct, unsignedLong, 1, printValue), // TIFF tag

        TagInfo(0x0125, "T6Options", N_("T6 Options"),

                N_("T.6-encoding options."),

                ifd0Id, imgStruct, unsignedLong, 1, printValue), // TIFF tag

        TagInfo(0x0128, "ResolutionUnit", N_("Resolution Unit"),

                N_("The unit for measuring <XResolution> and <YResolution>. The same "

                "unit is used for both <XResolution> and <YResolution>. If "

                "the image resolution is unknown, 2 (inches) is designated."),

                ifd0Id, imgStruct, unsignedShort, 1, printExifUnit),

        TagInfo(0x0129, "PageNumber", N_("Page Number"),

                N_("The page number of the page from which this image was scanned."),

                ifd0Id, imgStruct, unsignedShort, 2, printValue),

        TagInfo(0x012d, "TransferFunction", N_("Transfer Function"),

                N_("A transfer function for the image, described in tabular style. "

                "Normally this tag is not necessary, since color space is "

                "specified in the color space information tag (<ColorSpace>)."),

                ifd0Id, imgCharacter, unsignedShort, 3*256, printValue),

        TagInfo(0x0131, "Software", N_("Software"),

                N_("This tag records the name and version of the software or "

                "firmware of the camera or image input device used to "

                "generate the image. The detailed format is not specified, but "

                "it is recommended that the example shown below be "

                "followed. When the field is left blank, it is treated as unknown."),

                ifd0Id, otherTags, asciiString, 0, printValue),

        TagInfo(0x0132, "DateTime", N_("Date and Time"),

                N_("The date and time of image creation. In Exif standard, "

                "it is the date and time the file was changed."),

                ifd0Id, otherTags, asciiString, 20, printValue),

        TagInfo(0x013b, "Artist", N_("Artist"),

                N_("This tag records the name of the camera owner, photographer or "

                "image creator. The detailed format is not specified, but it is "

                "recommended that the information be written as in the example "

                "below for ease of Interoperability. When the field is "

                "left blank, it is treated as unknown. Ex.) \"Camera owner, John "

                "Smith; Photographer, Michael Brown; Image creator, Ken James\""),

                ifd0Id, otherTags, asciiString, 0, printValue),

        TagInfo(0x013c, "HostComputer", N_("Host Computer"),

                N_("This tag records information about the host computer used "

                "to generate the image."),

                ifd0Id, otherTags, asciiString, 0, printValue),

        TagInfo(0x013d, "Predictor", N_("Predictor"),

                N_("A predictor is a mathematical operator that is applied to "

                   "the image data before an encoding scheme is applied."),

                ifd0Id, imgStruct, unsignedShort, 1, EXV_PRINT_TAG(exifPredictor)), // TIFF tag

        TagInfo(0x013e, "WhitePoint", N_("White Point"),

                N_("The chromaticity of the white point of the image. Normally "

                "this tag is not necessary, since color space is specified "

                "in the colorspace information tag (<ColorSpace>)."),

                ifd0Id, imgCharacter, unsignedRational, 2, printValue),

        TagInfo(0x013f, "PrimaryChromaticities", N_("Primary Chromaticities"),

                N_("The chromaticity of the three primary colors of the image. "

                "Normally this tag is not necessary, since colorspace is "

                "specified in the colorspace information tag (<ColorSpace>)."),

                ifd0Id, imgCharacter, unsignedRational, 6, printValue),

        TagInfo(0x0140, "ColorMap", N_("Color Map"),

                N_("A color map for palette color images. This field defines "

                   "a Red-Green-Blue color map (often called a lookup table) "

                   "for palette-color images. In a palette-color image, a "

                   "pixel value is used to index into an RGB lookup table."),

                ifd0Id, imgCharacter, unsignedShort, -1, printValue),

        TagInfo(0x0141, "HalftoneHints", N_("Halftone Hints"),

                N_("The purpose of the HalftoneHints field is to convey to the "

                   "halftone function the range of gray levels within a "

                   "colorimetrically-specified image that should retain tonal detail."),

                ifd0Id, imgStruct, unsignedShort, 2, printValue), // TIFF tag

        TagInfo(0x0142, "TileWidth", N_("Tile Width"),

                N_("The tile width in pixels. This is the number of columns in each tile."),

                ifd0Id, recOffset, unsignedShort, 1, printValue), // TIFF tag

        TagInfo(0x0143, "TileLength", N_("Tile Length"),

                N_("The tile length (height) in pixels. This is the number of rows in each tile."),

                ifd0Id, recOffset, unsignedShort, 1, printValue), // TIFF tag

        TagInfo(0x0144, "TileOffsets", N_("Tile Offsets"),

                N_("For each tile, the byte offset of that tile, as compressed and "

                   "stored on disk. The offset is specified with respect to the "

                   "beginning of the TIFF file. Note that this implies that each "

                   "tile has a location independent of the locations of other tiles."),

                ifd0Id, recOffset, unsignedShort, -1, printValue), // TIFF tag

        TagInfo(0x0145, "TileByteCounts", N_("Tile Byte Counts"),

                N_("For each tile, the number of (compressed) bytes in that tile. See "

                   "TileOffsets for a description of how the byte counts are ordered."),

                ifd0Id, recOffset, unsignedShort, -1, printValue), // TIFF tag

        TagInfo(0x014a, "SubIFDs", N_("SubIFD Offsets"),

                N_("Defined by Adobe Corporation to enable TIFF Trees within a TIFF file."),

                ifd0Id, tiffEp, unsignedLong, -1, printValue),

        TagInfo(0x014c, "InkSet", N_("Ink Set"),

                N_("The set of inks used in a separated (PhotometricInterpretation=5) image."),

                ifd0Id, imgStruct, unsignedShort, 1, EXV_PRINT_TAG(exifInkSet)), // TIFF tag

        TagInfo(0x014d, "InkNames", N_("Ink Names"),

                N_("The name of each ink used in a separated (PhotometricInterpretation=5) image."),

                ifd0Id, imgStruct, asciiString, 0, printValue), // TIFF tag

        TagInfo(0x014e, "NumberOfInks", N_("Number Of Inks"),

                N_("The number of inks. Usually equal to SamplesPerPixel, unless there are extra samples."),

                ifd0Id, imgStruct, unsignedShort, 1, printValue), // TIFF tag

        TagInfo(0x0150, "DotRange", N_("Dot Range"),

                N_("The component values that correspond to a 0% dot and 100% dot."),

                ifd0Id, imgStruct, unsignedByte, -1, printValue), // TIFF tag

        TagInfo(0x0151, "TargetPrinter", N_("Target Printer"),

                N_("A description of the printing environment for which this separation is intended."),

                ifd0Id, imgStruct, asciiString, 0, printValue), // TIFF tag

        TagInfo(0x0152, "ExtraSamples", N_("Extra Samples"),

                N_("Specifies that each pixel has m extra components whose interpretation "

                   "is defined by one of the values listed below."),

                ifd0Id, imgStruct, unsignedShort, -1, printValue), // TIFF tag

        TagInfo(0x0153, "SampleFormat", N_("Sample Format"),

                N_("This field specifies how to interpret each data sample in a pixel."),

                ifd0Id, imgStruct, unsignedShort, -1, EXV_PRINT_TAG(exifSampleFormat)), // TIFF tag

        TagInfo(0x0154, "SMinSampleValue", N_("SMin Sample Value"),

                N_("This field specifies the minimum sample value."),

                ifd0Id, imgStruct, unsignedShort, -1, printValue), // TIFF tag

        TagInfo(0x0155, "SMaxSampleValue", N_("SMax Sample Value"),

                N_("This field specifies the maximum sample value."),

                ifd0Id, imgStruct, unsignedShort, -1, printValue), // TIFF tag

        TagInfo(0x0156, "TransferRange", N_("Transfer Range"),

                N_("Expands the range of the TransferFunction"),

                ifd0Id, imgCharacter, unsignedShort, 6, printValue), // TIFF tag

        TagInfo(0x0157, "ClipPath", N_("Clip Path"),

                N_("A TIFF ClipPath is intended to mirror the essentials of PostScript's "

                   "path creation functionality."),

                ifd0Id, tiffPm6, unsignedByte, -1, printValue), // TIFF&PM6 tag

        TagInfo(0x0158, "XClipPathUnits", N_("X Clip Path Units"),

                N_("The number of units that span the width of the image, in terms of "

                   "integer ClipPath coordinates."),

                ifd0Id, tiffPm6, signedShort, 1, printValue), // TIFF&PM6 tag

        TagInfo(0x0159, "YClipPathUnits", N_("Y Clip Path Units"),

                N_("The number of units that span the height of the image, in terms of "

                   "integer ClipPath coordinates."),

                ifd0Id, tiffPm6, signedShort, 1, printValue), // TIFF&PM6 tag

        TagInfo(0x015a, "Indexed", N_("Indexed"),

                N_("Indexed images are images where the 'pixels' do not represent color "

                   "values, but rather an index (usually 8-bit) into a separate color "

                   "table, the ColorMap."),

                ifd0Id, tiffPm6, unsignedShort, 1, EXV_PRINT_TAG(exifIndexed)), // TIFF&PM6 tag

        TagInfo(0x015b, "JPEGTables", N_("JPEG tables"),

                N_("This optional tag may be used to encode the JPEG quantization and "

                   "Huffman tables for subsequent use by the JPEG decompression process."),

                ifd0Id, imgStruct, undefined, 0, printValue), // TIFF/EP tag

        TagInfo(0x015F, "OPIProxy", N_("OPI Proxy"),

                N_("OPIProxy gives information concerning whether this image is a "

                   "low-resolution proxy of a high-resolution image (Adobe OPI)."),

                ifd0Id, adobeOpi, unsignedShort, 1, printValue), // Adobe OPI tag

        TagInfo(0x0200, "JPEGProc", N_("JPEG Process"),

                N_("This field indicates the process used to produce the compressed data"),

                ifd0Id, recOffset, unsignedLong, 1, printValue), // TIFF tag

        TagInfo(0x0201, "JPEGInterchangeFormat", N_("JPEG Interchange Format"),

                N_("The offset to the start byte (SOI) of JPEG compressed "

                "thumbnail data. This is not used for primary image JPEG data."),

                ifd0Id, recOffset, unsignedLong, 1, printValue),

        TagInfo(0x0202, "JPEGInterchangeFormatLength", N_("JPEG Interchange Format Length"),

                N_("The number of bytes of JPEG compressed thumbnail data. This "

                "is not used for primary image JPEG data. JPEG thumbnails "

                "are not divided but are recorded as a continuous JPEG "

                "bitstream from SOI to EOI. Appn and COM markers should "

                "not be recorded. Compressed thumbnails must be recorded in no "

                "more than 64 Kbytes, including all other data to be recorded in APP1."),

                ifd0Id, recOffset, unsignedLong, 1, printValue),

        TagInfo(0x0203, "JPEGRestartInterval", N_("JPEG Restart Interval"),

                N_("This Field indicates the length of the restart interval used "

                   "in the compressed image data."),

                ifd0Id, imgStruct, unsignedShort, 1, printValue), // TIFF tag

        TagInfo(0x0205, "JPEGLosslessPredictors", N_("JPEG Lossless Predictors"),

                N_("This Field points to a list of lossless predictor-selection "

                   "values, one per component."),

                ifd0Id, imgStruct, unsignedShort, -1, EXV_PRINT_TAG(exifJpegLosslessPredictor)), // TIFF tag

        TagInfo(0x0206, "JPEGPointTransforms", N_("JPEG Point Transforms"),

                N_("This Field points to a list of point transform values, one per component."),

                ifd0Id, imgStruct, unsignedShort, -1, printValue), // TIFF tag

        TagInfo(0x0207, "JPEGQTables", N_("JPEG Q-Tables"),

                N_("This Field points to a list of offsets to the quantization tables, "

                   "one per component."),

                ifd0Id, imgStruct, unsignedLong, -1, printValue), // TIFF tag

        TagInfo(0x0208, "JPEGDCTables", N_("JPEG DC-Tables"),

                N_("This Field points to a list of offsets to the DC Huffman tables or "

                   "the lossless Huffman tables, one per component."),

                ifd0Id, imgStruct, unsignedLong, -1, printValue), // TIFF tag

        TagInfo(0x0209, "JPEGACTables", N_("JPEG AC-Tables"),

                N_("This Field points to a list of offsets to the Huffman AC tables, "

                   "one per component."),

                ifd0Id, imgStruct, unsignedLong, -1, printValue), // TIFF tag

        TagInfo(0x0211, "YCbCrCoefficients", N_("YCbCr Coefficients"),

                N_("The matrix coefficients for transformation from RGB to YCbCr "

                "image data. No default is given in TIFF; but here the "

                "value given in Appendix E, \"Color Space Guidelines\", is used "

                "as the default. The color space is declared in a "

                "color space information tag, with the default being the value "

                "that gives the optimal image characteristics "

                "Interoperability this condition."),

                ifd0Id, imgCharacter, unsignedRational, 3, printValue),

        TagInfo(0x0212, "YCbCrSubSampling", N_("YCbCr Sub-Sampling"),

                N_("The sampling ratio of chrominance components in relation to the "

                "luminance component. In JPEG compressed data a JPEG marker "

                "is used instead of this tag."),

                ifd0Id, imgStruct, unsignedShort, 2, printValue),

        TagInfo(0x0213, "YCbCrPositioning", N_("YCbCr Positioning"),

                N_("The position of chrominance components in relation to the "

                "luminance component. This field is designated only for "

                "JPEG compressed data or uncompressed YCbCr data. The TIFF "

                "default is 1 (centered); but when Y:Cb:Cr = 4:2:2 it is "

                "recommended in this standard that 2 (co-sited) be used to "

                "record data, in order to improve the image quality when viewed "

                "on TV systems. When this field does not exist, the reader shall "

                "assume the TIFF default. In the case of Y:Cb:Cr = 4:2:0, the "

                "TIFF default (centered) is recommended. If the reader "

                "does not have the capability of supporting both kinds of "

                "<YCbCrPositioning>, it shall follow the TIFF default regardless "

                "of the value in this field. It is preferable that readers "

                "be able to support both centered and co-sited positioning."),

                ifd0Id, imgStruct, unsignedShort, 1, print0x0213),

        TagInfo(0x0214, "ReferenceBlackWhite", N_("Reference Black/White"),

                N_("The reference black point value and reference white point "

                "value. No defaults are given in TIFF, but the values "

                "below are given as defaults here. The color space is declared "

                "in a color space information tag, with the default "

                "being the value that gives the optimal image characteristics "

                "Interoperability these conditions."),

                ifd0Id, imgCharacter, unsignedRational, 6, printValue),

        TagInfo(0x02bc, "XMLPacket", N_("XML Packet"),

                N_("XMP Metadata (Adobe technote 9-14-02)"),

                ifd0Id, otherTags, unsignedByte, -1, printValue),

        TagInfo(0x4746, "Rating", N_("Windows Rating"),

                N_("Rating tag used by Windows"),

                ifd0Id, otherTags, unsignedShort, -1, printValue), // Windows Tag

        TagInfo(0x4749, "RatingPercent", N_("Windows Rating Percent"),

                N_("Rating tag used by Windows, value in percent"),

                ifd0Id, otherTags, unsignedShort, -1, printValue), // Windows Tag

        TagInfo(0x800d, "ImageID", N_("Image ID"),

                N_("ImageID is the full pathname of the original, high-resolution image, "

                   "or any other identifying string that uniquely identifies the original "

                   "image (Adobe OPI)."),

                ifd0Id, adobeOpi, asciiString, 0, printValue), // Adobe OPI tag

        TagInfo(0x828d, "CFARepeatPatternDim", N_("CFA Repeat Pattern Dimension"),

                N_("Contains two values representing the minimum rows and columns "

                "to define the repeating patterns of the color filter array"),

                ifd0Id, tiffEp, unsignedShort, 2, printValue), // TIFF/EP Tag

        TagInfo(0x828e, "CFAPattern", N_("CFA Pattern"),

                N_("Indicates the color filter array (CFA) geometric pattern of the image "

                "sensor when a one-chip color area sensor is used. It does not apply to "

                "all sensing methods"),

                ifd0Id, tiffEp, unsignedByte, -1, printValue), // TIFF/EP Tag

        TagInfo(0x828f, "BatteryLevel", N_("Battery Level"),

                "Contains a value of the battery level as a fraction or string",

                ifd0Id, tiffEp, unsignedRational, 1, printValue), // TIFF/EP Tag

        TagInfo(0x8298, "Copyright", N_("Copyright"),

                N_("Copyright information. In this standard the tag is used to "

                "indicate both the photographer and editor copyrights. It is "

                "the copyright notice of the person or organization claiming "

                "rights to the image. The Interoperability copyright "

                "statement including date and rights should be written in this "

                "field; e.g., \"Copyright, John Smith, 19xx. All rights "

                "reserved.\". In this standard the field records both the "

                "photographer and editor copyrights, with each recorded in a "

                "separate part of the statement. When there is a clear distinction "

                "between the photographer and editor copyrights, these are to be "

                "written in the order of photographer followed by editor copyright, "

                "separated by NULL (in this case since the statement also ends with "

                "a NULL, there are two NULL codes). When only the photographer "

                "copyright is given, it is terminated by one NULL code. When only "

                "the editor copyright is given, the photographer copyright part "

                "consists of one space followed by a terminating NULL code, then "

                "the editor copyright is given. When the field is left blank, it is "

                "treated as unknown."),

                ifd0Id, otherTags, asciiString, 0, print0x8298),

        TagInfo(0x829a, "ExposureTime", N_("Exposure Time"), N_("Exposure time, given in seconds."), ifd0Id, tiffEp, unsignedRational, 1, print0x829a), // TIFF/EP tag

        TagInfo(0x829d, "FNumber", N_("FNumber"), N_("The F number."), ifd0Id, tiffEp, unsignedRational, 1, print0x829d), // TIFF/EP tag

        TagInfo(0x83bb, "IPTCNAA", N_("IPTC/NAA"),

                N_("Contains an IPTC/NAA record"),

                ifd0Id, tiffEp, unsignedLong, 0, printValue), // TIFF/EP Tag

        TagInfo(0x8649, "ImageResources", N_("Image Resources Block"),

                N_("Contains information embedded by the Adobe Photoshop application"),

                ifd0Id, otherTags, unsignedByte, -1, printValue),

        TagInfo(0x8769, "ExifTag", N_("Exif IFD Pointer"),

                N_("A pointer to the Exif IFD. Interoperability, Exif IFD has the "

                "same structure as that of the IFD specified in TIFF. "

                "ordinarily, however, it does not contain image data as in "

                "the case of TIFF."),

                ifd0Id, exifFormat, unsignedLong, 1, printValue),

        TagInfo(0x8773, "InterColorProfile", N_("Inter Color Profile"),

                N_("Contains an InterColor Consortium (ICC) format color space characterization/profile"),

                ifd0Id, tiffEp, undefined, -1, printValue),

        TagInfo(0x8822, "ExposureProgram", N_("Exposure Program"), N_("The class of the program used by the camera to set exposure when the picture is taken."), ifd0Id, tiffEp, unsignedShort, 1, print0x8822), // TIFF/EP tag

        TagInfo(0x8824, "SpectralSensitivity", N_("Spectral Sensitivity"), N_("Indicates the spectral sensitivity of each channel of the camera used."), ifd0Id, tiffEp, asciiString, 0, printValue), // TIFF/EP tag

        TagInfo(0x8825, "GPSTag", N_("GPS Info IFD Pointer"),

                N_("A pointer to the GPS Info IFD. The "

                "Interoperability structure of the GPS Info IFD, like that of "

                "Exif IFD, has no image data."),

                ifd0Id, exifFormat, unsignedLong, 1, printValue),

        TagInfo(0x8827, "ISOSpeedRatings", N_("ISO Speed Ratings"), N_("Indicates the ISO Speed and ISO Latitude of the camera or input device as specified in ISO 12232."), ifd0Id, tiffEp, unsignedShort, 0, print0x8827), // TIFF/EP tag

        TagInfo(0x8828, "OECF", N_("OECF"), N_("Indicates the Opto-Electric Conversion Function (OECF) specified in ISO 14524."), ifd0Id, tiffEp, undefined, 0, printValue), // TIFF/EP tag

        TagInfo(0x8829, "Interlace", N_("Interlace"), N_("Indicates the field number of multifield images."), ifd0Id, tiffEp, unsignedShort, 1, printValue), // TIFF/EP tag

        TagInfo(0x882a, "TimeZoneOffset", N_("Time Zone Offset"),

                N_("This optional tag encodes the time zone of the camera clock (relative "

                   "to Greenwich Mean Time) used to create the DataTimeOriginal tag-value "

                   "when the picture was taken. It may also contain the time zone offset "

                   "of the clock used to create the DateTime tag-value when the image was "

                   "modified."),

                ifd0Id, tiffEp, signedShort, -1, printValue),

        TagInfo(0x882b, "SelfTimerMode", N_("Self Timer Mode"), N_("Number of seconds image capture was delayed from button press."), ifd0Id, tiffEp, unsignedShort, 1, printValue), // TIFF/EP tag

        TagInfo(0x9003, "DateTimeOriginal", N_("Date Time Original"), N_("The date and time when the original image data was generated."), ifd0Id, tiffEp, asciiString, 20, printValue), // TIFF/EP tag

        TagInfo(0x9102, "CompressedBitsPerPixel", N_("Compressed Bits Per Pixel"), N_("Specific to compressed data; states the compressed bits per pixel."), ifd0Id, tiffEp, unsignedRational, 1, printFloat), // TIFF/EP tag

        TagInfo(0x9201, "ShutterSpeedValue", N_("Shutter Speed Value"), N_("Shutter speed."), ifd0Id, tiffEp, signedRational, 1, print0x9201), // TIFF/EP tag

        TagInfo(0x9202, "ApertureValue", N_("Aperture Value"), N_("The lens aperture."), ifd0Id, tiffEp, unsignedRational, 1, print0x9202), // TIFF/EP tag

        TagInfo(0x9203, "BrightnessValue", N_("Brightness Value"), N_("The value of brightness."), ifd0Id, tiffEp, signedRational, 1, printFloat), // TIFF/EP tag

        TagInfo(0x9204, "ExposureBiasValue", N_("Exposure Bias Value"), N_("The exposure bias."), ifd0Id, tiffEp, signedRational, 1, print0x9204), // TIFF/EP tag

        TagInfo(0x9205, "MaxApertureValue", N_("Max Aperture Value"), N_("The smallest F number of the lens."), ifd0Id, tiffEp, unsignedRational, 1, print0x9202), // TIFF/EP tag

        TagInfo(0x9206, "SubjectDistance", N_("Subject Distance"), N_("The distance to the subject, given in meters."), ifd0Id, tiffEp, signedRational, 1, print0x9206), // TIFF/EP tag

        TagInfo(0x9207, "MeteringMode", N_("Metering Mode"), N_("The metering mode."), ifd0Id, tiffEp, unsignedShort, 1, print0x9207), // TIFF/EP tag

        TagInfo(0x9208, "LightSource", N_("Light Source"), N_("The kind of light source."), ifd0Id, tiffEp, unsignedShort, 1, print0x9208), // TIFF/EP tag

        TagInfo(0x9209, "Flash", N_("Flash"), N_("Indicates the status of flash when the image was shot."), ifd0Id, tiffEp, unsignedShort, 1, EXV_PRINT_TAG(exifFlash)), // TIFF/EP tag

        TagInfo(0x920a, "FocalLength", N_("Focal Length"), N_("The actual focal length of the lens, in mm."), ifd0Id, tiffEp, unsignedRational, 1, print0x920a), // TIFF/EP tag

        TagInfo(0x920b, "FlashEnergy", N_("Flash Energy"), N_("Amount of flash energy (BCPS)."), ifd0Id, tiffEp, unsignedRational, 1, printValue), // TIFF/EP tag

        TagInfo(0x920c, "SpatialFrequencyResponse", N_("Spatial Frequency Response"), N_("SFR of the camera."), ifd0Id, tiffEp, undefined, 0, printValue), // TIFF/EP tag

        TagInfo(0x920d, "Noise", N_("Noise"), N_("Noise measurement values."), ifd0Id, tiffEp, undefined, 0, printValue), // TIFF/EP tag

        TagInfo(0x920e, "FocalPlaneXResolution", N_("Focal Plane X Resolution"), N_("Number of pixels per FocalPlaneResolutionUnit (37392) in ImageWidth direction for main image."), ifd0Id, tiffEp, unsignedRational, 1, printValue), // TIFF/EP tag

        TagInfo(0x920f, "FocalPlaneYResolution", N_("Focal Plane Y Resolution"), N_("Number of pixels per FocalPlaneResolutionUnit (37392) in ImageLength direction for main image."), ifd0Id, tiffEp, unsignedRational, 1, printValue), // TIFF/EP tag

        TagInfo(0x9210, "FocalPlaneResolutionUnit", N_("Focal Plane Resolution Unit"), N_("Unit of measurement for FocalPlaneXResolution(37390) and FocalPlaneYResolution(37391)."), ifd0Id, tiffEp, unsignedShort, 1, printValue), // TIFF/EP tag

        TagInfo(0x9211, "ImageNumber", N_("Image Number"), N_("Number assigned to an image, e.g., in a chained image burst."), ifd0Id, tiffEp, unsignedLong, 1, printValue), // TIFF/EP tag

        TagInfo(0x9212, "SecurityClassification", N_("Security Classification"), N_("Security classification assigned to the image."), ifd0Id, tiffEp, asciiString, 0, printValue), // TIFF/EP tag

        TagInfo(0x9213, "ImageHistory", N_("Image History"), N_("Record of what has been done to the image."), ifd0Id, tiffEp, asciiString, 0, printValue), // TIFF/EP tag

        TagInfo(0x9214, "SubjectLocation", N_("Subject Location"), N_("Indicates the location and area of the main subject in the overall scene."), ifd0Id, tiffEp, unsignedShort, 2, printValue), // TIFF/EP tag

        TagInfo(0x9215, "ExposureIndex", N_("Exposure Index"), N_("Encodes the camera exposure index setting when image was captured."), ifd0Id, tiffEp, unsignedRational, 1, printValue), // TIFF/EP tag

        TagInfo(0x9216, "TIFFEPStandardID", N_("TIFF/EP Standard ID"),

                N_("Contains four ASCII characters representing the TIFF/EP standard "

                "version of a TIFF/EP file, eg '1', '0', '0', '0'"),

                ifd0Id, tiffEp, unsignedByte, 4, printValue), // TIFF/EP Tag

        TagInfo(0x9217, "SensingMethod", N_("Sensing Method"), N_("Type of image sensor."), ifd0Id, tiffEp, unsignedShort, 1, printValue), // TIFF/EP tag

        TagInfo(0x9c9b, "XPTitle", N_("Windows Title"),

                N_("Title tag used by Windows, encoded in UCS2"),

                ifd0Id, otherTags, unsignedByte, -1, printUcs2), // Windows Tag

        TagInfo(0x9c9c, "XPComment", N_("Windows Comment"),

                N_("Comment tag used by Windows, encoded in UCS2"),

                ifd0Id, otherTags, unsignedByte, -1, printUcs2), // Windows Tag

        TagInfo(0x9c9d, "XPAuthor", N_("Windows Author"),

                N_("Author tag used by Windows, encoded in UCS2"),

                ifd0Id, otherTags, unsignedByte, -1, printUcs2), // Windows Tag

        TagInfo(0x9c9e, "XPKeywords", N_("Windows Keywords"),

                N_("Keywords tag used by Windows, encoded in UCS2"),

                ifd0Id, otherTags, unsignedByte, -1, printUcs2), // Windows Tag

        TagInfo(0x9c9f, "XPSubject", N_("Windows Subject"),

                N_("Subject tag used by Windows, encoded in UCS2"),

                ifd0Id, otherTags, unsignedByte, -1, printUcs2), // Windows Tag

        TagInfo(0xc4a5, "PrintImageMatching", N_("Print Image Matching"),

                N_("Print Image Matching, description needed."),

                ifd0Id, otherTags, undefined, -1, printValue),

        TagInfo(0xc612, "DNGVersion", N_("DNG version"),

                N_("This tag encodes the DNG four-tier version number. For files "

                   "compliant with version 1.1.0.0 of the DNG specification, this "

                   "tag should contain the bytes: 1, 1, 0, 0."),

                ifd0Id, dngTags, unsignedByte, 4, printValue), // DNG tag

        TagInfo(0xc613, "DNGBackwardVersion", N_("DNG backward version"),

                N_("This tag specifies the oldest version of the Digital Negative "

                   "specification for which a file is compatible. Readers should"

                   "not attempt to read a file if this tag specifies a version "

                   "number that is higher than the version number of the specification "

                   "the reader was based on.  In addition to checking the version tags, "

                   "readers should, for all tags, check the types, counts, and values, "

                   "to verify it is able to correctly read the file."),

                ifd0Id, dngTags, unsignedByte, 4, printValue), // DNG tag

        TagInfo(0xc614, "UniqueCameraModel", N_("Unique Camera Model"),

                N_("Defines a unique, non-localized name for the camera model that "

                   "created the image in the raw file. This name should include the "

                   "manufacturer's name to avoid conflicts, and should not be localized, "

                   "even if the camera name itself is localized for different markets "

                   "(see LocalizedCameraModel). This string may be used by reader "

                   "software to index into per-model preferences and replacement profiles."),

                ifd0Id, dngTags, asciiString, 0, printValue), // DNG tag

        TagInfo(0xc615, "LocalizedCameraModel", N_("Localized Camera Model"),

                N_("Similar to the UniqueCameraModel field, except the name can be "

                   "localized for different markets to match the localization of the "

                   "camera name."),