File indexing completed on 2024-04-21 15:22:24

 /*
     SPDX-FileCopyrightText: 2006-2015 Gilles Caulier <caulier dot gilles at gmail dot com>
     SPDX-FileCopyrightText: 2006-2013 Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "kexiv2.h"
 #include "kexiv2_p.h"
 
 // Local includes
 
 #include "libkexiv2_version.h"
 #include "libkexiv2_debug.h"
 
 namespace KExiv2Iface
 {
 
 KExiv2::KExiv2()
     : d(new KExiv2Private)
 {
 }
 
 KExiv2::KExiv2(const KExiv2& metadata)
     : d(new KExiv2Private)
 {
     d->copyPrivateData(metadata.d.get());
 }
 
 KExiv2::KExiv2(const KExiv2Data& data)
     : d(new KExiv2Private)
 {
     setData(data);
 }
 
 KExiv2::KExiv2(const QString& filePath)
     : d(new KExiv2Private)
 {
     load(filePath);
 }
 
 KExiv2::~KExiv2() = default;
 
 KExiv2& KExiv2::operator=(const KExiv2& metadata)
 {
     d->copyPrivateData(metadata.d.get());
 
     return *this;
 }
 
 //-- Statics methods ----------------------------------------------
 
 bool KExiv2::initializeExiv2()
 {
 #ifdef _XMP_SUPPORT_
 
     if (!Exiv2::XmpParser::initialize())
         return false;
 
     registerXmpNameSpace(QString::fromLatin1("http://ns.adobe.com/lightroom/1.0/"),  QString::fromLatin1("lr"));
     registerXmpNameSpace(QString::fromLatin1("http://www.digikam.org/ns/kipi/1.0/"), QString::fromLatin1("kipi"));
     registerXmpNameSpace(QString::fromLatin1("http://ns.microsoft.com/photo/1.2/"),  QString::fromLatin1("MP"));
     registerXmpNameSpace(QString::fromLatin1("http://ns.acdsee.com/iptc/1.0/"),      QString::fromLatin1("acdsee"));
     registerXmpNameSpace(QString::fromLatin1("http://www.video"),                    QString::fromLatin1("video"));
 
 #endif // _XMP_SUPPORT_
 
 #ifdef EXV_ENABLE_BMFF
     Exiv2::enableBMFF(true);
 #endif
 
     return true;
 }
 
 bool KExiv2::cleanupExiv2()
 {
     // Fix memory leak if Exiv2 support XMP.
 #ifdef _XMP_SUPPORT_
 
     unregisterXmpNameSpace(QString::fromLatin1("http://ns.adobe.com/lightroom/1.0/"));
     unregisterXmpNameSpace(QString::fromLatin1("http://www.digikam.org/ns/kipi/1.0/"));
     unregisterXmpNameSpace(QString::fromLatin1("http://ns.microsoft.com/photo/1.2/"));
     unregisterXmpNameSpace(QString::fromLatin1("http://ns.acdsee.com/iptc/1.0/"));
     unregisterXmpNameSpace(QString::fromLatin1("http://www.video"));
     
     Exiv2::XmpParser::terminate();
 
 #endif // _XMP_SUPPORT_
 
     return true;
 }
 
 bool KExiv2::supportXmp()
 {
 #ifdef _XMP_SUPPORT_
     return true;
 #else
     return false;
 #endif // _XMP_SUPPORT_
 }
 
 bool KExiv2::supportMetadataWritting(const QString& typeMime)
 {
     if (typeMime == QString::fromLatin1("image/jpeg"))
     {
         return true;
     }
     else if (typeMime == QString::fromLatin1("image/tiff"))
     {
         return true;
     }
     else if (typeMime == QString::fromLatin1("image/png"))
     {
         return true;
     }
     else if (typeMime == QString::fromLatin1("image/jp2"))
     {
         return true;
     }
     else if (typeMime == QString::fromLatin1("image/x-raw"))
     {
         return true;
     }
     else if (typeMime == QString::fromLatin1("image/pgf"))
     {
         return true;
     }
 
     return false;
 }
 
 QString KExiv2::Exiv2Version()
 {
     // Since 0.14.0 release, we can extract run-time version of Exiv2.
     // else we return make version.
 
     return QString::fromStdString(Exiv2::versionString());
 }
 
 QString KExiv2::version()
 {
     return QString::fromLatin1(KEXIV2_VERSION_STRING);
 }
 
 QString KExiv2::sidecarFilePathForFile(const QString& path)
 {
     QString ret;
 
     if (!path.isEmpty())
     {
         ret = path + QString::fromLatin1(".xmp");
     }
 
     return ret;
 }
 
 QUrl KExiv2::sidecarUrl(const QUrl& url)
 {
     QString sidecarPath = sidecarFilePathForFile(url.path());
     QUrl sidecarUrl(url);
     sidecarUrl.setPath(sidecarPath);
     return sidecarUrl;
 }
 
 QUrl KExiv2::sidecarUrl(const QString& path)
 {
     return QUrl::fromLocalFile(sidecarFilePathForFile(path));
 }
 
 QString KExiv2::sidecarPath(const QString& path)
 {
     return sidecarFilePathForFile(path);
 }
 
 bool KExiv2::hasSidecar(const QString& path)
 {
     return QFileInfo(sidecarFilePathForFile(path)).exists();
 }
 
 //-- General methods ----------------------------------------------
 
 KExiv2Data KExiv2::data() const
 {
     KExiv2Data data;
     data.d = d->data;
     return data;
 }
 
 void KExiv2::setData(const KExiv2Data& data)
 {
     if (data.d)
     {
         d->data = data.d;
     }
     else
     {
         // KExiv2Data can have a null pointer,
         // but we never want a null pointer in Private.
         d->data->clear();
     }
 }
 
 bool KExiv2::loadFromData(const QByteArray& imgData) const
 {
     if (imgData.isEmpty())
         return false;
 
     try
     {
 #if EXIV2_TEST_VERSION(0,28,0)
         Exiv2::Image::UniquePtr image = Exiv2::ImageFactory::open((Exiv2::byte*)imgData.data(), imgData.size());
 #else
         Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open((Exiv2::byte*)imgData.data(), imgData.size());
 #endif
 
         d->filePath.clear();
         image->readMetadata();
 
         // Size and mimetype ---------------------------------
 
         d->pixelSize = QSize(image->pixelWidth(), image->pixelHeight());
         d->mimeType  = QString::fromLatin1(image->mimeType().c_str());
 
         // Image comments ---------------------------------
 
         d->imageComments() = image->comment();
 
         // Exif metadata ----------------------------------
 
         d->exifMetadata() = image->exifData();
 
         // Iptc metadata ----------------------------------
 
         d->iptcMetadata() = image->iptcData();
 
 #ifdef _XMP_SUPPORT_
 
         // Xmp metadata -----------------------------------
 
         d->xmpMetadata() = image->xmpData();
 
 #endif // _XMP_SUPPORT_
 
         return true;
     }
     catch( Exiv2::Error& e )
     {
         d->printExiv2ExceptionError(QString::fromLatin1("Cannot load metadata using Exiv2 "), e);
     }
     catch(...)
     {
         qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
     }
 
     return false;
 }
 
 bool KExiv2::load(const QString& filePath) const
 {
     if (filePath.isEmpty())
     {
         return false;
     }
 
     d->filePath      = filePath;
     bool hasLoaded   = false;
 
     try
     {
 #if EXIV2_TEST_VERSION(0,28,0)
         Exiv2::Image::UniquePtr image;
 #else
         Exiv2::Image::AutoPtr image;
 #endif
 
         image        = Exiv2::ImageFactory::open((const char*)(QFile::encodeName(filePath)).constData());
 
         image->readMetadata();
 
         // Size and mimetype ---------------------------------
 
         d->pixelSize = QSize(image->pixelWidth(), image->pixelHeight());
         d->mimeType  = QString::fromLatin1(image->mimeType().c_str());
 
         // Image comments ---------------------------------
 
         d->imageComments() = image->comment();
 
         // Exif metadata ----------------------------------
 
         d->exifMetadata() = image->exifData();
 
         // Iptc metadata ----------------------------------
 
         d->iptcMetadata() = image->iptcData();
 
 #ifdef _XMP_SUPPORT_
 
         // Xmp metadata -----------------------------------
         d->xmpMetadata() = image->xmpData();
 
 #endif // _XMP_SUPPORT_
 
         hasLoaded = true;
     }
     catch( Exiv2::Error& e )
     {
         d->printExiv2ExceptionError(QString::fromLatin1("Cannot load metadata from file "), e);
     }
     catch(...)
     {
         qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
     }
 
 #ifdef _XMP_SUPPORT_
     try
     {
         if (d->useXMPSidecar4Reading)
         {
             QString xmpSidecarPath = sidecarFilePathForFile(filePath);
             QFileInfo xmpSidecarFileInfo(xmpSidecarPath);
 
 #if EXIV2_TEST_VERSION(0,28,0)
             Exiv2::Image::UniquePtr xmpsidecar;
 #else
             Exiv2::Image::AutoPtr xmpsidecar;
 #endif
 
             if (xmpSidecarFileInfo.exists() && xmpSidecarFileInfo.isReadable())
             {
                 // Read sidecar data
                 xmpsidecar = Exiv2::ImageFactory::open(QFile::encodeName(xmpSidecarPath).constData());
                 xmpsidecar->readMetadata();
 
                 // Merge
 #if EXIV2_TEST_VERSION(0,28,0)
                 d->loadSidecarData(std::move(xmpsidecar));
 #else
                 d->loadSidecarData(xmpsidecar);
 #endif
                 hasLoaded = true;
             }
         }
     }
     catch( Exiv2::Error& e )
     {
         d->printExiv2ExceptionError(QString::fromLatin1("Cannot load XMP sidecar"), e);
     }
     catch(...)
     {
         qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
     }
 
 #endif // _XMP_SUPPORT_
 
     return hasLoaded;
 }
 
 bool KExiv2::save(const QString& imageFilePath) const
 {
     // If our image is really a symlink, we should follow the symlink so that
     // when we delete the file and rewrite it, we are honoring the symlink
     // (rather than just deleting it and putting a file there).
 
     // However, this may be surprising to the user when they are writing sidecar
     // files.  They might expect them to show up where the symlink is.  So, we
     // shouldn't follow the link when figuring out what the filename for the
     // sidecar should be.
 
     // Note, we are not yet handling the case where the sidecar itself is a
     // symlink.
     QString regularFilePath = imageFilePath; // imageFilePath might be a
                                              // symlink.  Below we will change
                                              // regularFile to the pointed to
                                              // file if so.
     QFileInfo givenFileInfo(imageFilePath);
 
     if (givenFileInfo.isSymLink())
     {
         qCDebug(LIBKEXIV2_LOG) << "filePath" << imageFilePath << "is a symlink."
                                << "Using target" << givenFileInfo.canonicalPath();
 
         regularFilePath = givenFileInfo.canonicalPath();// Walk all the symlinks
     }
 
     // NOTE: see B.K.O #137770 & #138540 : never touch the file if is read only.
     QFileInfo finfo(regularFilePath);
     QFileInfo dinfo(finfo.path());
 
     if (!dinfo.isWritable())
     {
         qCDebug(LIBKEXIV2_LOG) << "Dir '" << dinfo.filePath() << "' is read-only. Metadata not saved.";
         return false;
     }
 
     bool writeToFile                     = false;
     bool writeToSidecar                  = false;
     bool writeToSidecarIfFileNotPossible = false;
     bool writtenToFile                   = false;
     bool writtenToSidecar                = false;
 
     qCDebug(LIBKEXIV2_LOG) << "KExiv2::metadataWritingMode" << d->metadataWritingMode;
 
     switch(d->metadataWritingMode)
     {
         case WRITETOSIDECARONLY:
             writeToSidecar = true;
             break;
         case WRITETOIMAGEONLY:
             writeToFile    = true;
             break;
         case WRITETOSIDECARANDIMAGE:
             writeToFile    = true;
             writeToSidecar = true;
             break;
         case WRITETOSIDECARONLY4READONLYFILES:
             writeToFile = true;
             writeToSidecarIfFileNotPossible = true;
             break;
     }
 
     if (writeToFile)
     {
         qCDebug(LIBKEXIV2_LOG) << "Will write Metadata to file" << finfo.absoluteFilePath();
         writtenToFile = d->saveToFile(finfo);
 
         if (writtenToFile)
         {
             qCDebug(LIBKEXIV2_LOG) << "Metadata for file" << finfo.fileName() << "written to file.";
         }
     }
 
     if (writeToSidecar || (writeToSidecarIfFileNotPossible && !writtenToFile))
     {
         qCDebug(LIBKEXIV2_LOG) << "Will write XMP sidecar for file" << givenFileInfo.fileName();
         writtenToSidecar = d->saveToXMPSidecar(QFileInfo(imageFilePath));
 
         if (writtenToSidecar)
         {
             qCDebug(LIBKEXIV2_LOG) << "Metadata for file '" << givenFileInfo.fileName() << "' written to XMP sidecar.";
         }
     }
 
     return writtenToFile || writtenToSidecar;
 }
 
 bool KExiv2::applyChanges() const
 {
     if (d->filePath.isEmpty())
     {
         qCDebug(LIBKEXIV2_LOG) << "Failed to apply changes: file path is empty!";
         return false;
     }
 
     return save(d->filePath);
 }
 
 bool KExiv2::isEmpty() const
 {
     if (!hasComments() && !hasExif() && !hasIptc() && !hasXmp())
         return true;
 
     return false;
 }
 
 void KExiv2::setFilePath(const QString& path)
 {
     d->filePath = path;
 }
 
 QString KExiv2::getFilePath() const
 {
     return d->filePath;
 }
 
 QSize KExiv2::getPixelSize() const
 {
     return d->pixelSize;
 }
 
 QString KExiv2::getMimeType() const
 {
     return d->mimeType;
 }
 
 void KExiv2::setWriteRawFiles(const bool on)
 {
     d->writeRawFiles = on;
 }
 
 bool KExiv2::writeRawFiles() const
 {
     return d->writeRawFiles;
 }
 
 void KExiv2::setUseXMPSidecar4Reading(const bool on)
 {
     d->useXMPSidecar4Reading = on;
 }
 
 bool KExiv2::useXMPSidecar4Reading() const
 {
     return d->useXMPSidecar4Reading;
 }
 
 void KExiv2::setMetadataWritingMode(const int mode)
 {
     d->metadataWritingMode = mode;
 }
 
 int KExiv2::metadataWritingMode() const
 {
     return d->metadataWritingMode;
 }
 
 void KExiv2::setUpdateFileTimeStamp(bool on)
 {
     d->updateFileTimeStamp = on;
 }
 
 bool KExiv2::updateFileTimeStamp() const
 {
     return d->updateFileTimeStamp;
 }
 
 bool KExiv2::setProgramId(bool /*on*/) const
 {
     return true;
 }
 
 }  // NameSpace KExiv2Iface