// ***************************************************************** -*- 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.

 */

/*

  File:      convert.cpp

  Author(s): Andreas Huggel (ahu) <ahuggel@gmx.net>

             Vladimir Nadvornik (vn) <nadvornik@suse.cz>

  History:   17-Mar-08, ahu: created basic converter framework

             20-May-08, vn:  added actual conversion logic

 */

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

// included header files

#include "config.h"

#include "types.hpp"

#include "error.hpp"

#include "exif.hpp"

#include "iptc.hpp"

#include "xmp_exiv2.hpp"

#include "futils.hpp"

#include "convert.hpp"

#include "unused.h"

// + standard includes

#include <utility>

#include <iostream>

#include <iomanip>

#include <ios>

#include <sstream>

#include <stdio.h> // for snprintf (C99)

#ifdef _MSC_VER

# define snprintf _snprintf

#endif

#include <cstring>

#if defined WIN32 && !defined __CYGWIN__

# include <windows.h>

#endif

#ifdef EXV_HAVE_ICONV

# include <iconv.h>

# include <errno.h>

#endif

// Adobe XMP Toolkit

#ifdef EXV_HAVE_XMP_TOOLKIT

# define TXMP_STRING_TYPE std::string

# ifdef EXV_ADOBE_XMPSDK

#  include <XMP.hpp>

# else

#  include <XMPSDK.hpp>

# endif

# include <MD5.h>

#endif // EXV_HAVE_XMP_TOOLKIT

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

// local declarations

namespace {

#if defined WIN32 && !defined __CYGWIN__

    // Convert string charset with Windows functions.

    bool convertStringCharsetWindows(std::string& str, const char* from, const char* to);

#endif

#if defined EXV_HAVE_ICONV

    // Convert string charset with iconv.

    bool convertStringCharsetIconv(std::string& str, const char* from, const char* to);

#endif

    /*!

      @brief Get the text value of an XmpDatum \em pos.

      If \em pos refers to a LangAltValue, \em value is set to the default language

      entry without the x-default qualifier. If there is no default but

      exactly one entry, \em value is set to this entry, without the qualifier.

      The return code indicates if the operation was successful.

     */

    bool getTextValue(std::string& value, const Exiv2::XmpData::iterator& pos);

}

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

// class member definitions

namespace Exiv2 {

    //! Metadata conversions.

    class Converter {

    public:

        /*!

          @brief Type for metadata converter functions, taking two key strings,

                 \em from and \em to.

          These functions have access to both the source and destination metadata

          containers and store the result directly in the destination container.

         */

        typedef void (Converter::*ConvertFct)(const char* from, const char* to);

        //! Structure to define conversions between two keys.

        struct Conversion {

            MetadataId  metadataId_; //!< Type of metadata for the first key.

            const char* key1_;       //!< First metadata key.

            const char* key2_;       //!< Second metadata key (always an XMP key for now).

            ConvertFct  key1ToKey2_; //!< Conversion from first to second key.

            ConvertFct  key2ToKey1_; //!< Conversion from second to first key.

        };

    public:

        //! @name Creators

        //@{

        //! Constructor for Exif tags and XMP properties.

        Converter(ExifData& exifData, XmpData& xmpData);

        //! Constructor for Iptc tags and XMP properties.

        Converter(IptcData& iptcData, XmpData& xmpData, const char *iptcCharset = 0);

        //@}

        //! @name Manipulators

        //@{

        //! Convert Exif tags or IPTC datasets to XMP properties according to the conversion table.

        void cnvToXmp();

        //! Convert XMP properties to Exif tags or IPTC datasets according to the conversion table.

        void cnvFromXmp();

        /*!

          @brief Set the erase flag.

          This flag indicates whether successfully converted source records are erased.

         */

        void setErase(bool onoff =true) { erase_ = onoff; }

        /*!

          @brief Set the overwrite flag.

          This flag indicates whether existing target records are overwritten.

         */

        void setOverwrite(bool onoff =true) { overwrite_ = onoff; }

        //@}

        //! @name Conversion functions (manipulators)

        //@{

        /*!

          @brief Do nothing conversion function.

          Use when, for example, a one-way conversion is needed.

         */

        void cnvNone(const char*, const char*);

        /*!

          @brief Simple Exif to XMP conversion function.

          Sets the XMP property to an XmpText value containing the Exif value string.

         */

        void cnvExifValue(const char* from, const char* to);

        /*!

          @brief Convert the tag Exif.Photo.UserComment to XMP.

          Todo: Convert the Exif comment to UTF-8 if necessary.

         */

        void cnvExifComment(const char* from, const char* to);

        /*!

          @brief Converts Exif tag with multiple components to XMP array.

          Converts Exif tag with multiple components to XMP array. This function is

          used for ComponentsConfiguration tag.

         */

        void cnvExifArray(const char* from, const char* to);

        /*!

          @brief Exif date to XMP conversion function.

          Sets the XMP property to an XmpText value containing date and time. This function

          combines values from multiple Exif tags as described in XMP specification. It

          is used for DateTime, DateTimeOriginal, DateTimeDigitized and GPSTimeStamp.

         */

        void cnvExifDate(const char* from, const char* to);

        /*!

          @brief Exif version to XMP conversion function.

          Converts ExifVersion tag to XmpText value.

         */

        void cnvExifVersion(const char* from, const char* to);

        /*!

          @brief Exif GPS version to XMP conversion function.

          Converts GPSVersionID tag to XmpText value.

         */

        void cnvExifGPSVersion(const char* from, const char* to);

        /*!

          @brief Exif Flash to XMP conversion function.

          Converts Flash tag to XMP structure.

         */

        void cnvExifFlash(const char* from, const char* to);

        /*!

          @brief Exif GPS coordinate to XMP conversion function.

          Converts GPS coordinates tag to XmpText value. It combines multiple Exif tags

          as described in XMP specification.

         */

        void cnvExifGPSCoord(const char* from, const char* to);

        /*!

          @brief Simple XMP to Exif conversion function.

          Sets the Exif tag according to the XMP property.

          For LangAlt values, only the x-default entry is used.

          Todo: Escape non-ASCII characters in XMP text values

         */

        void cnvXmpValue(const char* from, const char* to);

        /*!

          @brief Convert the tag Xmp.exif.UserComment to Exif.

         */

        void cnvXmpComment(const char* from, const char* to);

        /*!

          @brief Converts XMP array to Exif tag with multiple components.

          Converts XMP array to Exif tag with multiple components. This function is

          used for ComponentsConfiguration tag.

         */

        void cnvXmpArray(const char* from, const char* to);

        /*!

          @brief XMP to Exif date conversion function.

          Converts the XmpText value to Exif date and time. This function

          sets multiple Exif tags as described in XMP specification. It

          is used for DateTime, DateTimeOriginal, DateTimeDigitized and GPSTimeStamp.

         */

        void cnvXmpDate(const char* from, const char* to);

        /*!

          @brief XMP to Exif version conversion function.

          Converts XmpText value to ExifVersion tag.

         */

        void cnvXmpVersion(const char* from, const char* to);

        /*!

          @brief XMP to Exif GPS version conversion function.

          Converts XmpText value to GPSVersionID tag.

         */

        void cnvXmpGPSVersion(const char* from, const char* to);

        /*!

          @brief XMP to Exif Flash conversion function.

          Converts XMP structure to Flash tag.

         */

        void cnvXmpFlash(const char* from, const char* to);

        /*!

          @brief XMP to Exif GPS coordinate conversion function.

          Converts XmpText value to GPS coordinates tags. It sets multiple Exif tags

          as described in XMP specification.

         */

        void cnvXmpGPSCoord(const char* from, const char* to);

        /*!

          @brief IPTC dataset to XMP conversion function.

          Multiple IPTC datasets with the same key are converted to an XMP array.

         */

        void cnvIptcValue(const char* from, const char* to);

        /*!

          @brief XMP to IPTC dataset conversion function.

          Each array element of an XMP array value is added as one IPTC dataset.

         */

        void cnvXmpValueToIptc(const char* from, const char* to);

        /*!

          @brief Write exif:NativeDigest and tiff:NativeDigest properties to XMP.

          Compute digests from Exif values and write them to  exif:NativeDigest

          and tiff:NativeDigest properties. This should be compatible with XMP SDK.

         */

        void writeExifDigest();

        /*!

          @brief Copies metadata in appropriate direction.

          From values of exif:NativeDigest and tiff:NativeDigest detects which of

          XMP and Exif was updated more recently and copies metadata in appropriate direction.

         */

        void syncExifWithXmp();

        //@}

        //! @name Accessors

        //@{

        //! Get the value of the erase flag, see also setErase(bool on).

        bool erase() const { return erase_; }

        //! Get the value of the overwrite flag, see also setOverwrite(bool on).

        bool overwrite() const { return overwrite_; }

        //@}

    private:

        bool prepareExifTarget(const char* to, bool force =false);

        bool prepareIptcTarget(const char* to, bool force =false);

        bool prepareXmpTarget(const char* to, bool force =false);

        std::string computeExifDigest(bool tiff);

        std::string computeIptcDigest();

        // DATA

        static const Conversion conversion_[];  //

        bool erase_;

        bool overwrite_;

        ExifData *exifData_;

        IptcData *iptcData_;

        XmpData  *xmpData_;

        const char *iptcCharset_;

    }; // class Converter

    // Order is important for computing digests

    const Converter::Conversion Converter::conversion_[] = {

        { mdExif, "Exif.Image.ImageWidth",                "Xmp.tiff.ImageWidth",                &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.ImageLength",               "Xmp.tiff.ImageLength",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.BitsPerSample",             "Xmp.tiff.BitsPerSample",             &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.Compression",               "Xmp.tiff.Compression",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.PhotometricInterpretation", "Xmp.tiff.PhotometricInterpretation", &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.Orientation",               "Xmp.tiff.Orientation",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.SamplesPerPixel",           "Xmp.tiff.SamplesPerPixel",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.PlanarConfiguration",       "Xmp.tiff.PlanarConfiguration",       &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.YCbCrSubSampling",          "Xmp.tiff.YCbCrSubSampling",          &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.YCbCrPositioning",          "Xmp.tiff.YCbCrPositioning",          &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.XResolution",               "Xmp.tiff.XResolution",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.YResolution",               "Xmp.tiff.YResolution",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.ResolutionUnit",            "Xmp.tiff.ResolutionUnit",            &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.TransferFunction",          "Xmp.tiff.TransferFunction",          &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.WhitePoint",                "Xmp.tiff.WhitePoint",                &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.PrimaryChromaticities",     "Xmp.tiff.PrimaryChromaticities",     &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.YCbCrCoefficients",         "Xmp.tiff.YCbCrCoefficients",         &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.ReferenceBlackWhite",       "Xmp.tiff.ReferenceBlackWhite",       &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.DateTime",                  "Xmp.xmp.ModifyDate",                 &Converter::cnvExifDate , &Converter::cnvXmpDate  }, // MWG Guidelines

        { mdExif, "Exif.Image.ImageDescription",          "Xmp.dc.description",                 &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.Make",                      "Xmp.tiff.Make",                      &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.Model",                     "Xmp.tiff.Model",                     &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.Software",                  "Xmp.tiff.Software",                  &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.Artist",                    "Xmp.dc.creator",                     &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.Rating",                    "Xmp.xmp.Rating",                     &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Image.Copyright",                 "Xmp.dc.rights",                      &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.ExifVersion",               "Xmp.exif.ExifVersion",               &Converter::cnvExifVersion, &Converter::cnvXmpVersion },

        { mdExif, "Exif.Photo.FlashpixVersion",           "Xmp.exif.FlashpixVersion",           &Converter::cnvExifVersion, &Converter::cnvXmpVersion },

        { mdExif, "Exif.Photo.ColorSpace",                "Xmp.exif.ColorSpace",                &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.ComponentsConfiguration",   "Xmp.exif.ComponentsConfiguration",   &Converter::cnvExifArray, &Converter::cnvXmpArray },

        { mdExif, "Exif.Photo.CompressedBitsPerPixel",    "Xmp.exif.CompressedBitsPerPixel",    &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.PixelXDimension",           "Xmp.exif.PixelXDimension",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.PixelYDimension",           "Xmp.exif.PixelYDimension",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.UserComment",               "Xmp.exif.UserComment",               &Converter::cnvExifComment, &Converter::cnvXmpComment },

        { mdExif, "Exif.Photo.RelatedSoundFile",          "Xmp.exif.RelatedSoundFile",          &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.DateTimeOriginal",          "Xmp.photoshop.DateCreated",          &Converter::cnvExifDate,  &Converter::cnvXmpDate  }, // MWG Guidelines

        { mdExif, "Exif.Photo.DateTimeDigitized",         "Xmp.xmp.CreateDate",                 &Converter::cnvExifDate,  &Converter::cnvXmpDate  }, // MWG Guidelines

        { mdExif, "Exif.Photo.ExposureTime",              "Xmp.exif.ExposureTime",              &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.FNumber",                   "Xmp.exif.FNumber",                   &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.ExposureProgram",           "Xmp.exif.ExposureProgram",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.SpectralSensitivity",       "Xmp.exif.SpectralSensitivity",       &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.ISOSpeedRatings",           "Xmp.exif.ISOSpeedRatings",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.OECF",                      "Xmp.exif.OECF",                      &Converter::cnvExifValue, &Converter::cnvXmpValue }, // FIXME ?

        { mdExif, "Exif.Photo.ShutterSpeedValue",         "Xmp.exif.ShutterSpeedValue",         &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.ApertureValue",             "Xmp.exif.ApertureValue",             &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.BrightnessValue",           "Xmp.exif.BrightnessValue",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.ExposureBiasValue",         "Xmp.exif.ExposureBiasValue",         &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.MaxApertureValue",          "Xmp.exif.MaxApertureValue",          &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.SubjectDistance",           "Xmp.exif.SubjectDistance",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.MeteringMode",              "Xmp.exif.MeteringMode",              &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.LightSource",               "Xmp.exif.LightSource",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.Flash",                     "Xmp.exif.Flash",                     &Converter::cnvExifFlash, &Converter::cnvXmpFlash },

        { mdExif, "Exif.Photo.FocalLength",               "Xmp.exif.FocalLength",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.SubjectArea",               "Xmp.exif.SubjectArea",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.FlashEnergy",               "Xmp.exif.FlashEnergy",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.SpatialFrequencyResponse",  "Xmp.exif.SpatialFrequencyResponse",  &Converter::cnvExifValue, &Converter::cnvXmpValue }, // FIXME ?

        { mdExif, "Exif.Photo.FocalPlaneXResolution",     "Xmp.exif.FocalPlaneXResolution",     &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.FocalPlaneYResolution",     "Xmp.exif.FocalPlaneYResolution",     &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.FocalPlaneResolutionUnit",  "Xmp.exif.FocalPlaneResolutionUnit",  &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.SubjectLocation",           "Xmp.exif.SubjectLocation",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.ExposureIndex",             "Xmp.exif.ExposureIndex",             &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.SensingMethod",             "Xmp.exif.SensingMethod",             &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.FileSource",                "Xmp.exif.FileSource",                &Converter::cnvExifValue, &Converter::cnvXmpValue }, // FIXME ?

        { mdExif, "Exif.Photo.SceneType",                 "Xmp.exif.SceneType",                 &Converter::cnvExifValue, &Converter::cnvXmpValue }, // FIXME ?

        { mdExif, "Exif.Photo.CFAPattern",                "Xmp.exif.CFAPattern",                &Converter::cnvExifValue, &Converter::cnvXmpValue }, // FIXME ?

        { mdExif, "Exif.Photo.CustomRendered",            "Xmp.exif.CustomRendered",            &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.ExposureMode",              "Xmp.exif.ExposureMode",              &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.WhiteBalance",              "Xmp.exif.WhiteBalance",              &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.DigitalZoomRatio",          "Xmp.exif.DigitalZoomRatio",          &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.FocalLengthIn35mmFilm",     "Xmp.exif.FocalLengthIn35mmFilm",     &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.SceneCaptureType",          "Xmp.exif.SceneCaptureType",          &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.GainControl",               "Xmp.exif.GainControl",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.Contrast",                  "Xmp.exif.Contrast",                  &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.Saturation",                "Xmp.exif.Saturation",                &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.Sharpness",                 "Xmp.exif.Sharpness",                 &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.DeviceSettingDescription",  "Xmp.exif.DeviceSettingDescription",  &Converter::cnvExifValue, &Converter::cnvXmpValue }, // FIXME ?

        { mdExif, "Exif.Photo.SubjectDistanceRange",      "Xmp.exif.SubjectDistanceRange",      &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.Photo.ImageUniqueID",             "Xmp.exif.ImageUniqueID",             &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSVersionID",            "Xmp.exif.GPSVersionID",              &Converter::cnvExifGPSVersion, &Converter::cnvXmpGPSVersion },

        { mdExif, "Exif.GPSInfo.GPSLatitude",             "Xmp.exif.GPSLatitude",               &Converter::cnvExifGPSCoord, &Converter::cnvXmpGPSCoord },

        { mdExif, "Exif.GPSInfo.GPSLongitude",            "Xmp.exif.GPSLongitude",              &Converter::cnvExifGPSCoord, &Converter::cnvXmpGPSCoord },

        { mdExif, "Exif.GPSInfo.GPSAltitudeRef",          "Xmp.exif.GPSAltitudeRef",            &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSAltitude",             "Xmp.exif.GPSAltitude",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSTimeStamp",            "Xmp.exif.GPSTimeStamp",              &Converter::cnvExifDate,  &Converter::cnvXmpDate  }, // FIXME ?

        { mdExif, "Exif.GPSInfo.GPSSatellites",           "Xmp.exif.GPSSatellites",             &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSStatus",               "Xmp.exif.GPSStatus",                 &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSMeasureMode",          "Xmp.exif.GPSMeasureMode",            &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSDOP",                  "Xmp.exif.GPSDOP",                    &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSSpeedRef",             "Xmp.exif.GPSSpeedRef",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSSpeed",                "Xmp.exif.GPSSpeed",                  &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSTrackRef",             "Xmp.exif.GPSTrackRef",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSTrack",                "Xmp.exif.GPSTrack",                  &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSImgDirectionRef",      "Xmp.exif.GPSImgDirectionRef",        &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSImgDirection",         "Xmp.exif.GPSImgDirection",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSMapDatum",             "Xmp.exif.GPSMapDatum",               &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSDestLatitude",         "Xmp.exif.GPSDestLatitude",           &Converter::cnvExifGPSCoord, &Converter::cnvXmpGPSCoord },

        { mdExif, "Exif.GPSInfo.GPSDestLongitude",        "Xmp.exif.GPSDestLongitude",          &Converter::cnvExifGPSCoord, &Converter::cnvXmpGPSCoord },

        { mdExif, "Exif.GPSInfo.GPSDestBearingRef",       "Xmp.exif.GPSDestBearingRef",         &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSDestBearing",          "Xmp.exif.GPSDestBearing",            &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSDestDistanceRef",      "Xmp.exif.GPSDestDistanceRef",        &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSDestDistance",         "Xmp.exif.GPSDestDistance",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdExif, "Exif.GPSInfo.GPSProcessingMethod",     "Xmp.exif.GPSProcessingMethod",       &Converter::cnvExifValue, &Converter::cnvXmpValue }, // FIXME ?

        { mdExif, "Exif.GPSInfo.GPSAreaInformation",      "Xmp.exif.GPSAreaInformation",        &Converter::cnvExifValue, &Converter::cnvXmpValue }, // FIXME ?

        { mdExif, "Exif.GPSInfo.GPSDifferential",         "Xmp.exif.GPSDifferential",           &Converter::cnvExifValue, &Converter::cnvXmpValue },

        { mdIptc, "Iptc.Application2.ObjectName",         "Xmp.dc.title",                       &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.Urgency",            "Xmp.photoshop.Urgency",              &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.Category",           "Xmp.photoshop.Category",             &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.SuppCategory",       "Xmp.photoshop.SupplementalCategories", &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.Keywords",           "Xmp.dc.subject",                     &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.SubLocation",        "Xmp.iptc.Location",                  &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.SpecialInstructions","Xmp.photoshop.Instructions",         &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.DateCreated",        "Xmp.photoshop.DateCreated",          &Converter::cnvNone, &Converter::cnvXmpValueToIptc }, // FIXME to IPTC Date and IPTC Time

        { mdIptc, "Iptc.Application2.DigitizationDate",   "Xmp.xmp.CreateDate",                 &Converter::cnvNone, &Converter::cnvXmpValueToIptc }, // FIXME to IPTC Date and IPTC Time

        { mdIptc, "Iptc.Application2.Byline",             "Xmp.dc.creator",                     &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.BylineTitle",        "Xmp.photoshop.AuthorsPosition",      &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.City",               "Xmp.photoshop.City",                 &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.ProvinceState",      "Xmp.photoshop.State",                &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.CountryCode",        "Xmp.iptc.CountryCode",               &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.CountryName",        "Xmp.photoshop.Country",              &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.TransmissionReference", "Xmp.photoshop.TransmissionReference", &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.Headline",            "Xmp.photoshop.Headline",            &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.Credit",             "Xmp.photoshop.Credit",               &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.Source",             "Xmp.photoshop.Source",               &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.Copyright",          "Xmp.dc.rights",                      &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.Caption",            "Xmp.dc.description",                 &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc },

        { mdIptc, "Iptc.Application2.Writer",             "Xmp.photoshop.CaptionWriter",        &Converter::cnvIptcValue, &Converter::cnvXmpValueToIptc }

    };

    Converter::Converter(ExifData& exifData, XmpData& xmpData)

        : erase_(false), overwrite_(true), exifData_(&exifData), iptcData_(0), xmpData_(&xmpData), iptcCharset_(0)

    {

    }

    Converter::Converter(IptcData& iptcData, XmpData& xmpData, const char *iptcCharset)

        : erase_(false), overwrite_(true), exifData_(0), iptcData_(&iptcData), xmpData_(&xmpData), iptcCharset_(iptcCharset)

    {

    }

    void Converter::cnvToXmp()

    {

        for (unsigned int i = 0; i < EXV_COUNTOF(conversion_); ++i) {

            const Conversion& c = conversion_[i];

            if (   (c.metadataId_ == mdExif && exifData_)

                || (c.metadataId_ == mdIptc && iptcData_)) {

                EXV_CALL_MEMBER_FN(*this, c.key1ToKey2_)(c.key1_, c.key2_);

            }

        }

    }

    void Converter::cnvFromXmp()

    {

        for (unsigned int i = 0; i < EXV_COUNTOF(conversion_); ++i) {

            const Conversion& c = conversion_[i];

            if (   (c.metadataId_ == mdExif && exifData_)

                || (c.metadataId_ == mdIptc && iptcData_)) {

                EXV_CALL_MEMBER_FN(*this, c.key2ToKey1_)(c.key2_, c.key1_);

            }

        }

    }

    void Converter::cnvNone(const char*, const char*)

    {

        return;

    }

    bool Converter::prepareExifTarget(const char* to, bool force)

    {

        Exiv2::ExifData::iterator pos = exifData_->findKey(ExifKey(to));

        if (pos == exifData_->end()) return true;

        if (!overwrite_ && !force) return false;

        exifData_->erase(pos);

        return true;

    }

    bool Converter::prepareIptcTarget(const char* to, bool force)

    {

        Exiv2::IptcData::iterator pos = iptcData_->findKey(IptcKey(to));

        if (pos == iptcData_->end()) return true;

        if (!overwrite_ && !force) return false;

        while ((pos = iptcData_->findKey(IptcKey(to))) != iptcData_->end()) {

            iptcData_->erase(pos);

        }

        return true;

    }

    bool Converter::prepareXmpTarget(const char* to, bool force)

    {

        Exiv2::XmpData::iterator pos = xmpData_->findKey(XmpKey(to));

        if (pos == xmpData_->end()) return true;

        if (!overwrite_ && !force) return false;

        xmpData_->erase(pos);

        return true;

    }

    void Converter::cnvExifValue(const char* from, const char* to)

    {

        Exiv2::ExifData::iterator pos = exifData_->findKey(ExifKey(from));

        if (pos == exifData_->end()) return;

        std::string value = pos->toString();

        if (!pos->value().ok()) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

            return;

        }

        if (!prepareXmpTarget(to)) return;

        (*xmpData_)[to] = value;

        if (erase_) exifData_->erase(pos);

    }

    void Converter::cnvExifComment(const char* from, const char* to)

    {

        Exiv2::ExifData::iterator pos = exifData_->findKey(ExifKey(from));

        if (pos == exifData_->end()) return;

        if (!prepareXmpTarget(to)) return;

        const CommentValue* cv = dynamic_cast<const CommentValue*>(&pos->value());

        if (cv == 0) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

            return;

        }

        // Todo: Convert to UTF-8 if necessary

        (*xmpData_)[to] = cv->comment();

        if (erase_) exifData_->erase(pos);

    }

    void Converter::cnvExifArray(const char* from, const char* to)

    {

        Exiv2::ExifData::iterator pos = exifData_->findKey(ExifKey(from));

        if (pos == exifData_->end()) return;

        if (!prepareXmpTarget(to)) return;

        for (int i = 0; i < pos->count(); ++i) {

            std::string value = pos->toString(i);

            if (!pos->value().ok()) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

                return;

            }

            (*xmpData_)[to] = value;

        }

        if (erase_) exifData_->erase(pos);

    }

    void Converter::cnvExifDate(const char* from, const char* to)

    {

        Exiv2::ExifData::iterator pos = exifData_->findKey(ExifKey(from));

        if (pos == exifData_->end()) return;

        if (!prepareXmpTarget(to)) return;

        int year, month, day, hour, min, sec;

        std::string subsec;

        char buf[30];

        if (std::string(from) != "Exif.GPSInfo.GPSTimeStamp") {

            std::string value = pos->toString();

            if (!pos->value().ok()) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

                return;

            }

            if (sscanf(value.c_str(), "%d:%d:%d %d:%d:%d", &year, &month, &day, &hour, &min, &sec) != 6) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Failed to convert " << from << " to " << to

                            << ", unable to parse '" << value << "'\n";

#endif

                return;

            }

        }

        else { // "Exif.GPSInfo.GPSTimeStamp"

            bool ok = true;

            if (pos->count() != 3) ok = false;

            if (ok) {

                for (int i = 0; i < 3; ++i) {

                    if (pos->toRational(i).second == 0) {

                        ok = false;

                        break;

                    }

                }

            }

            if (!ok) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

                return;

            }

            double dhour = pos->toFloat(0);

            double dmin = pos->toFloat(1);

            // Hack: Need Value::toDouble

            Rational r = pos->toRational(2);

            double dsec = static_cast<double>(r.first)/r.second;

            if (!pos->value().ok()) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

                return;

            }

            dsec = dhour * 3600.0 + dmin * 60.0 + dsec;

            hour = static_cast<int>(dsec / 3600.0);

            dsec -= hour * 3600;

            min = static_cast<int>(dsec / 60.0);

            dsec -= min * 60;

            sec = static_cast<int>(dsec);

            dsec -= sec;

            snprintf(buf, sizeof(buf), "%.9f", dsec);

            buf[sizeof(buf) - 1] = 0;

            buf[1] = '.'; // some locales use ','

            subsec = buf + 1;

            Exiv2::ExifData::iterator datePos = exifData_->findKey(ExifKey("Exif.GPSInfo.GPSDateStamp"));

            if (datePos == exifData_->end()) {

                datePos = exifData_->findKey(ExifKey("Exif.Photo.DateTimeOriginal"));

            }

            if (datePos == exifData_->end()) {

                datePos = exifData_->findKey(ExifKey("Exif.Photo.DateTimeDigitized"));

            }

            if (datePos == exifData_->end()) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

                return;

            }

            std::string value = datePos->toString();

            if (sscanf(value.c_str(), "%d:%d:%d", &year, &month, &day) != 3) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Failed to convert " << from << " to " << to

                            << ", unable to parse '" << value << "'\n";

#endif

                return;

            }

        }

        const char* subsecTag = 0;

        if (std::string(from) == "Exif.Image.DateTime") {

            subsecTag = "Exif.Photo.SubSecTime";

        }

        else if (std::string(from) == "Exif.Photo.DateTimeOriginal") {

            subsecTag = "Exif.Photo.SubSecTimeOriginal";

        }

        else if (std::string(from) == "Exif.Photo.DateTimeDigitized") {

            subsecTag = "Exif.Photo.SubSecTimeDigitized";

        }

        if (subsecTag) {

            ExifData::iterator subsec_pos = exifData_->findKey(ExifKey(subsecTag));

            if (   subsec_pos != exifData_->end()

                && subsec_pos->typeId() == asciiString) {

                std::string ss = subsec_pos->toString();

                if (!ss.empty()) {

                    bool ok = false;

                    stringTo<long>(ss, ok);

                    if (ok) subsec = std::string(".") + ss;

                }

            }

            if (erase_) exifData_->erase(subsec_pos);

        }

        if (subsec.size() > 10) subsec = subsec.substr(0, 10);

        snprintf(buf, sizeof(buf), "%4d-%02d-%02dT%02d:%02d:%02d%s",

                 year, month, day, hour, min, sec, subsec.c_str());

        buf[sizeof(buf) - 1] = 0;

        (*xmpData_)[to] = buf;

        if (erase_) exifData_->erase(pos);

    }

    void Converter::cnvExifVersion(const char* from, const char* to)

    {

        Exiv2::ExifData::iterator pos = exifData_->findKey(ExifKey(from));

        if (pos == exifData_->end()) return;

        if (!prepareXmpTarget(to)) return;

        std::ostringstream value;

        for (int i = 0; i < pos->count(); ++i) {

            value << static_cast<char>(pos->toLong(i));

        }

        (*xmpData_)[to] = value.str();

        if (erase_) exifData_->erase(pos);

    }

    void Converter::cnvExifGPSVersion(const char* from, const char* to)

    {

        Exiv2::ExifData::iterator pos = exifData_->findKey(ExifKey(from));

        if (pos == exifData_->end()) return;

        if (!prepareXmpTarget(to)) return;

        std::ostringstream value;

        for (int i = 0; i < pos->count(); ++i) {

            if (i > 0) value << '.';

            value << pos->toLong(i);

        }

        (*xmpData_)[to] = value.str();

        if (erase_) exifData_->erase(pos);

    }

    void Converter::cnvExifFlash(const char* from, const char* to)

    {

        Exiv2::ExifData::iterator pos = exifData_->findKey(ExifKey(from));

        if (pos == exifData_->end() || pos->count() == 0) return;

        if (!prepareXmpTarget(to)) return;

        int value = pos->toLong();

        if (!pos->value().ok()) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

            return;

        }

        (*xmpData_)["Xmp.exif.Flash/exif:Fired"] = static_cast<bool>(value & 1);

        (*xmpData_)["Xmp.exif.Flash/exif:Return"] = (value >> 1) & 3;

        (*xmpData_)["Xmp.exif.Flash/exif:Mode"] = (value >> 3) & 3;

        (*xmpData_)["Xmp.exif.Flash/exif:Function"] = static_cast<bool>((value >> 5) & 1);

        (*xmpData_)["Xmp.exif.Flash/exif:RedEyeMode"] = static_cast<bool>((value >> 6) & 1);

        if (erase_) exifData_->erase(pos);

    }

    void Converter::cnvExifGPSCoord(const char* from, const char* to)

    {

        Exiv2::ExifData::iterator pos = exifData_->findKey(ExifKey(from));

        if (pos == exifData_->end()) return;

        if (!prepareXmpTarget(to)) return;

        if (pos->count() != 3) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

            return;

        }

        Exiv2::ExifData::iterator refPos = exifData_->findKey(ExifKey(std::string(from) + "Ref"));

        if (refPos == exifData_->end()) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

            return;

        }

        double deg[3];

        for (int i = 0; i < 3; ++i) {

            const int32_t z = pos->toRational(i).first;

            const int32_t d = pos->toRational(i).second;

            if (d == 0) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

                return;

            }

            // Hack: Need Value::toDouble

            deg[i] = static_cast<double>(z)/d;

        }

        double min = deg[0] * 60.0 + deg[1] + deg[2] / 60.0;

        int ideg = static_cast<int>(min / 60.0);

        min -= ideg * 60;

        std::ostringstream oss;

        oss << ideg << ","

            << std::fixed << std::setprecision(7) << min

            << refPos->toString().c_str()[0];

        (*xmpData_)[to] = oss.str();

        if (erase_) exifData_->erase(pos);

        if (erase_) exifData_->erase(refPos);

    }

    void Converter::cnvXmpValue(const char* from, const char* to)

    {

        Exiv2::XmpData::iterator pos = xmpData_->findKey(XmpKey(from));

        if (pos == xmpData_->end()) return;

        if (!prepareExifTarget(to)) return;

        std::string value;

        if (!getTextValue(value, pos)) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

            return;

        }

        // Todo: Escape non-ASCII characters in XMP text values

        ExifKey key(to);

        Exifdatum ed(key);

        if (0 == ed.setValue(value)) {

            exifData_->add(ed);

        }

        if (erase_) xmpData_->erase(pos);

    }

    void Converter::cnvXmpComment(const char* from, const char* to)

    {

        if (!prepareExifTarget(to)) return;

        Exiv2::XmpData::iterator pos = xmpData_->findKey(XmpKey(from));

        if (pos == xmpData_->end()) return;

        std::string value;

        if (!getTextValue(value, pos)) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

            return;

        }

        // Assumes the XMP value is encoded in UTF-8, as it should be

        (*exifData_)[to] = "charset=Unicode " + value;

        if (erase_) xmpData_->erase(pos);

    }

    void Converter::cnvXmpArray(const char* from, const char* to)

    {

        if (!prepareExifTarget(to)) return;

        Exiv2::XmpData::iterator pos = xmpData_->findKey(XmpKey(from));

        if (pos == xmpData_->end()) return;

        std::ostringstream array;

        for (int i = 0; i < pos->count(); ++i) {

            std::string value = pos->toString(i);

            if (!pos->value().ok()) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

                return;

            }

            array << value;

            if (i != pos->count() - 1) array << " ";

        }

        (*exifData_)[to] = array.str();

        if (erase_) xmpData_->erase(pos);

    }

    void Converter::cnvXmpDate(const char* from, const char* to)

    {

        Exiv2::XmpData::iterator pos = xmpData_->findKey(XmpKey(from));

        if (pos == xmpData_->end()) return;

        if (!prepareExifTarget(to)) return;

#ifdef EXV_HAVE_XMP_TOOLKIT

        std::string value = pos->toString();

        if (!pos->value().ok()) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Failed to convert " << from << " to " << to << "\n";

#endif

            return;

        }

        XMP_DateTime datetime;

        try {

            SXMPUtils::ConvertToDate(value, &datetime);

        }

#ifndef SUPPRESS_WARNINGS

        catch (const XMP_Error& e) {

            EXV_WARNING << "Failed to convert " << from << " to " << to << " (" << e.GetErrMsg() << ")\n";

            return;

        }

#else

        catch (const XMP_Error&) {

            return;

        }

#endif // SUPPRESS_WARNINGS

        char buf[30];

        if (std::string(to) != "Exif.GPSInfo.GPSTimeStamp") {

            SXMPUtils::ConvertToLocalTime(&datetime);

            snprintf(buf, sizeof(buf), "%4d:%02d:%02d %02d:%02d:%02d",

                     static_cast<int>(datetime.year),

                     static_cast<int>(datetime.month),

                     static_cast<int>(datetime.day),

                     static_cast<int>(datetime.hour),

                     static_cast<int>(datetime.minute),

                     static_cast<int>(datetime.second));

            buf[sizeof(buf) - 1] = 0;