File indexing completed on 2024-05-12 15:54:49

 /*
  * SPDX-FileCopyrightText: (C) 2012-2015 Vishesh Handa <vhanda@kde.org>
  *
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 #include "exiv2extractor.h"
 
 #include <KFileMetaData/UserMetaData>
 #include <QDebug>
 #include <QFile>
 #include <QFileInfo>
 #include <QStandardPaths>
 
 Exiv2Extractor::Exiv2Extractor(QObject *parent)
     : QObject(parent)
     , m_filePath(QString())
     , m_latitude(0)
     , m_longitude(0)
     , m_height(0)
     , m_width(0)
     , m_size(0)
     , m_model("")
     , m_time("")
     , m_favorite(false)
     , m_rating(0)
     , m_description("")
     , m_tags(QStringList())
     , m_error(false)
 {
 }
 
 Exiv2Extractor::~Exiv2Extractor()
 {
 }
 
 QUrl Exiv2Extractor::filePath() const
 {
     return QUrl::fromLocalFile(m_filePath);
 }
 
 QString Exiv2Extractor::simplifiedPath() const
 {
     auto url = filePath();
     QString home = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
     if (QUrl::fromLocalFile(home).isParentOf(url)) {
         return QStringLiteral("~") + url.toLocalFile().remove(0, home.length());
     }
     return url.toLocalFile();
 }
 
 static QDateTime dateTimeFromString(const QString &dateString)
 {
     QDateTime dateTime;
 
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("yyyy-MM-dd"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("dd-MM-yyyy"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("yyyy-MM"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("MM-yyyy"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("yyyy.MM.dd"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("dd.MM.yyyy"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("dd MMMM yyyy"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("MM.yyyy"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("yyyy.MM"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("yyyy"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("yy"));
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, Qt::ISODate);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("dddd d MMM yyyy h':'mm':'ss AP"));
         dateTime.setTimeSpec(Qt::LocalTime);
     }
     if (!dateTime.isValid()) {
         dateTime = QDateTime::fromString(dateString, QStringLiteral("yyyy:MM:dd hh:mm:ss"));
         dateTime.setTimeSpec(Qt::LocalTime);
     }
     if (!dateTime.isValid()) {
         dateTime = QLocale::system().toDateTime(dateString, QLocale::ShortFormat);
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         dateTime = QLocale::system().toDateTime(dateString, QLocale::LongFormat);
         dateTime.setTimeSpec(Qt::UTC);
     }
     if (!dateTime.isValid()) {
         qWarning() << "Could not determine correct datetime format from:" << dateString;
         return QDateTime();
     }
 
     return dateTime;
 }
 static QDateTime toDateTime(const Exiv2::Value &value)
 {
     if (value.typeId() == Exiv2::asciiString) {
         QDateTime val = dateTimeFromString(value.toString().c_str());
         if (val.isValid()) {
             // Datetime is stored in exif as local time.
             val.setOffsetFromUtc(0);
             return val;
         }
     }
 
     return QDateTime();
 }
 
 void Exiv2Extractor::updateFavorite(const QString &filePath)
 {
     if (!QFileInfo::exists(filePath)) {
         return;
     }
 
     auto fileMetaData = KFileMetaData::UserMetaData(filePath);
 
     m_favorite = fileMetaData.hasAttribute("koko.favorite");
 
     Q_EMIT favoriteChanged();
 }
 
 void Exiv2Extractor::toggleFavorite(const QString &filePath)
 {
     if (!QFileInfo::exists(filePath)) {
         return;
     }
 
     auto fileMetaData = KFileMetaData::UserMetaData(filePath);
 
     if (fileMetaData.hasAttribute("koko.favorite")) {
         fileMetaData.setAttribute("koko.favorite", "");
     } else {
         fileMetaData.setAttribute("koko.favorite", "true");
     }
 
     m_favorite = fileMetaData.hasAttribute("koko.favorite");
 
     Q_EMIT favoriteChanged();
 }
 
 void Exiv2Extractor::setRating(const int &rating)
 {
     if (rating == m_rating) {
         return;
     }
 
     if (!QFileInfo::exists(m_filePath)) {
         return;
     }
 
     auto fileMetaData = KFileMetaData::UserMetaData(m_filePath);
 
     fileMetaData.setRating(rating);
 
     m_rating = rating;
 
     Q_EMIT filePathChanged();
 }
 
 void Exiv2Extractor::setDescription(const QString &description)
 {
     if (description == m_description) {
         return;
     }
 
     if (!QFileInfo::exists(m_filePath)) {
         return;
     }
 
     auto fileMetaData = KFileMetaData::UserMetaData(m_filePath);
 
     fileMetaData.setUserComment(description);
 
     m_description = description;
 
     Q_EMIT filePathChanged();
 }
 
 void Exiv2Extractor::setTags(const QStringList &tags)
 {
     if (tags == m_tags) {
         return;
     }
 
     if (!QFileInfo::exists(m_filePath)) {
         return;
     }
 
     auto fileMetaData = KFileMetaData::UserMetaData(m_filePath);
 
     fileMetaData.setTags(tags);
 
     m_tags = tags;
 
     Q_EMIT filePathChanged();
 }
 
 void Exiv2Extractor::extract(const QString &filePath)
 {
     if (filePath == m_filePath) {
         return;
     }
 
     // init values
     m_error = false;
     m_latitude = 0.0;
     m_longitude = 0.0;
     m_width = 0;
     m_height = 0;
     m_size = 0;
     m_model = "";
     m_time = "";
     m_favorite = false;
     m_dateTime = QDateTime();
     m_rating = 0;
     m_description = "";
     m_tags = QStringList();
     m_filePath = filePath;
 
     QByteArray arr = QFile::encodeName(filePath);
     std::string fileString(arr.data(), arr.length());
 
     Exiv2::LogMsg::setLevel(Exiv2::LogMsg::mute);
 #if EXIV2_TEST_VERSION(0, 27, 99)
     Exiv2::Image::UniquePtr image;
 #else
     Exiv2::Image::AutoPtr image;
 #endif
 
     QFileInfo file_info(m_filePath);
 
     if (!QFileInfo::exists(m_filePath)) {
         m_error = true; // only critical error (don't prevent indexing stuff without Exif metadata)
         Q_EMIT filePathChanged();
         Q_EMIT favoriteChanged();
         return;
     }
 
     m_size = file_info.size();
 
     auto fileMetaData = KFileMetaData::UserMetaData(m_filePath);
 
     m_favorite = fileMetaData.hasAttribute("koko.favorite");
     Q_EMIT favoriteChanged();
 
     m_rating = fileMetaData.rating();
     m_description = fileMetaData.userComment();
     m_tags = fileMetaData.tags();
 
     try {
         image = Exiv2::ImageFactory::open(fileString);
     } catch (const std::exception &) {
         Q_EMIT filePathChanged();
         return;
     }
     if (!image.get()) {
         Q_EMIT filePathChanged();
         return;
     }
 
     if (!image->good()) {
         Q_EMIT filePathChanged();
         return;
     }
 
     try {
         image->readMetadata();
     } catch (const std::exception &) {
         Q_EMIT filePathChanged();
         return;
     }
 
     const Exiv2::ExifData &data = image->exifData();
 
     Exiv2::ExifData::const_iterator it = data.findKey(Exiv2::ExifKey("Exif.Photo.DateTimeOriginal"));
     if (it != data.end()) {
         m_dateTime = toDateTime(it->value());
         m_time = QString::fromStdString(it->toString());
     }
     if (m_dateTime.isNull()) {
         it = data.findKey(Exiv2::ExifKey("Exif.Image.DateTime"));
         if (it != data.end()) {
             m_dateTime = toDateTime(it->value());
         }
     }
 
     it = data.findKey(Exiv2::ExifKey("Exif.Image.Model"));
     if (it != data.end()) {
         m_model = QString::fromStdString(it->toString());
     }
 
     m_latitude = fetchGpsDouble(data, "Exif.GPSInfo.GPSLatitude");
     m_longitude = fetchGpsDouble(data, "Exif.GPSInfo.GPSLongitude");
 
     m_height = image->pixelHeight();
     m_width = image->pixelWidth();
 
     QByteArray latRef = fetchByteArray(data, "Exif.GPSInfo.GPSLatitudeRef");
     if (!latRef.isEmpty() && latRef[0] == 'S')
         m_latitude *= -1;
 
     QByteArray longRef = fetchByteArray(data, "Exif.GPSInfo.GPSLongitudeRef");
     if (!longRef.isEmpty() && longRef[0] == 'W')
         m_longitude *= -1;
 
     Q_EMIT filePathChanged();
 }
 
 double Exiv2Extractor::fetchGpsDouble(const Exiv2::ExifData &data, const char *name)
 {
     Exiv2::ExifData::const_iterator it = data.findKey(Exiv2::ExifKey(name));
     if (it != data.end() && it->count() == 3) {
         double n = 0.0;
         double d = 0.0;
 
         n = (*it).toRational(0).first;
         d = (*it).toRational(0).second;
 
         if (d == 0) {
             return 0.0;
         }
 
         double deg = n / d;
 
         n = (*it).toRational(1).first;
         d = (*it).toRational(1).second;
 
         if (d == 0) {
             return deg;
         }
 
         double min = n / d;
         if (min != -1.0) {
             deg += min / 60.0;
         }
 
         n = (*it).toRational(2).first;
         d = (*it).toRational(2).second;
 
         if (d == 0) {
             return deg;
         }
 
         double sec = n / d;
         if (sec != -1.0) {
             deg += sec / 3600.0;
         }
 
         return deg;
     }
 
     return 0.0;
 }
 
 QByteArray Exiv2Extractor::fetchByteArray(const Exiv2::ExifData &data, const char *name)
 {
     Exiv2::ExifData::const_iterator it = data.findKey(Exiv2::ExifKey(name));
     if (it != data.end()) {
         std::string str = it->value().toString();
         return QByteArray(str.c_str(), str.size());
     }
 
     return QByteArray();
 }
 
 bool Exiv2Extractor::error() const
 {
     return m_error;
 }