PORTREVISION=	13

PORTREVISION=	14

- 

From e7bf1f0d299c4f7c6529438059d14e7a99907066 Mon Sep 17 00:00:00 2001

From: Antonio Rojas <arojas@archlinux.org>

Date: Sun, 4 Jun 2023 18:04:59 +0200

Subject: [PATCH] Fix build with exiv2 0.28

---

 plugins/impex/jpeg/kis_jpeg_converter.cc     |  8 ++

 plugins/impex/tiff/kis_tiff_export.cc        |  9 +++

 plugins/impex/tiff/kis_tiff_import.cc        |  9 +++

 plugins/metadata/common/KisExiv2IODevice.cpp | 36 +++++++++

 plugins/metadata/common/KisExiv2IODevice.h   | 23 ++++++

 plugins/metadata/common/kis_exiv2_common.h   | 20 +++++

 plugins/metadata/exif/kis_exif_io.cpp        | 79 +++++++++++++++++++-

 plugins/metadata/iptc/kis_iptc_io.cpp        | 12 +++

 plugins/metadata/xmp/kis_xmp_io.cpp          |  9 ++-

 9 files changed, 200 insertions(+), 5 deletions(-)

diff --git ./plugins/impex/jpeg/kis_jpeg_converter.cc ./plugins/impex/jpeg/kis_jpeg_converter.cc

index 3364ae6eda7..476151e1234 100644

--- ./plugins/impex/jpeg/kis_jpeg_converter.cc

+++ ./plugins/impex/jpeg/kis_jpeg_converter.cc

@@ -20,6 +20,10 @@ extern "C" {

 }

 #include <exiv2/jpgimage.hpp>

+#include <exiv2/version.hpp>

+#if EXIV2_TEST_VERSION(0,28,0)

+#include <exiv2/photoshop.hpp>

+#endif

 #include <QFile>

 #include <QBuffer>

@@ -376,7 +380,11 @@ KisImportExportErrorCode KisJPEGConverter::decode(QIODevice *io)

             uint32_t sizeHdr = 0;

             // Find actual Iptc data within the APP13 segment

             if (!Exiv2::Photoshop::locateIptcIrb((Exiv2::byte*)(marker->data + 14),

+#if EXIV2_TEST_VERSION(0,28,0)

+                                                 marker->data_length - 14, &record, sizeHdr, sizeIptc)) {

+#else

                                                  marker->data_length - 14, &record, &sizeHdr, &sizeIptc)) {

+#endif

                 if (sizeIptc) {

                     // Decode the IPTC data

                     QByteArray byteArray((const char*)(record + sizeHdr), sizeIptc);

diff --git ./plugins/impex/tiff/kis_tiff_export.cc ./plugins/impex/tiff/kis_tiff_export.cc

index 8c8f71d7c08..69cbda63033 100644

--- ./plugins/impex/tiff/kis_tiff_export.cc

+++ ./plugins/impex/tiff/kis_tiff_export.cc

@@ -206,7 +206,11 @@ KisImportExportErrorCode KisTIFFExport::convert(KisDocument *document, QIODevice

         try {

             KisExiv2IODevice::ptr_type basicIoDevice(new KisExiv2IODevice(filename()));

+#if EXIV2_TEST_VERSION(0,28,0)

+            const std::unique_ptr<Exiv2::Image> img = Exiv2::ImageFactory::open(std::move(basicIoDevice));

+#else

             const std::unique_ptr<Exiv2::Image> img(Exiv2::ImageFactory::open(basicIoDevice).release());

+#endif

             img->readMetadata();

@@ -241,9 +245,14 @@ KisImportExportErrorCode KisTIFFExport::convert(KisDocument *document, QIODevice

             }

             // Write metadata

             img->writeMetadata();

+#if EXIV2_TEST_VERSION(0,28,0)

+        } catch (Exiv2::Error &e) {

+            errFile << "Failed injecting TIFF metadata:" << Exiv2::Error(e.code()).what();

+#else

         } catch (Exiv2::AnyError &e) {

             errFile << "Failed injecting TIFF metadata:" << e.code()

                     << e.what();

+#endif

         }

     }

     return ImportExportCodes::OK;

diff --git ./plugins/impex/tiff/kis_tiff_import.cc ./plugins/impex/tiff/kis_tiff_import.cc

index e6d408e923b..5be62bbbf51 100644

--- ./plugins/impex/tiff/kis_tiff_import.cc

+++ ./plugins/impex/tiff/kis_tiff_import.cc

@@ -1842,7 +1842,11 @@ KisTIFFImport::convert(KisDocument *document,

         try {

             KisExiv2IODevice::ptr_type basicIoDevice(new KisExiv2IODevice(filename()));

+#if EXIV2_TEST_VERSION(0,28,0)

+            const std::unique_ptr<Exiv2::Image> readImg = Exiv2::ImageFactory::open(std::move(basicIoDevice));

+#else

             const std::unique_ptr<Exiv2::Image> readImg(Exiv2::ImageFactory::open(basicIoDevice).release());

+#endif

             readImg->readMetadata();

@@ -1910,8 +1914,13 @@ KisTIFFImport::convert(KisDocument *document,

             // Inject the data as any other IOBackend

             io->loadFrom(layer->metaData(), &ioDevice);

+#if EXIV2_TEST_VERSION(0,28,0)

+        } catch (Exiv2::Error &e) {

+            errFile << "Failed metadata import:" << Exiv2::Error(e.code()).what();

+#else

         } catch (Exiv2::AnyError &e) {

             errFile << "Failed metadata import:" << e.code() << e.what();

+#endif

         }

     }

diff --git ./plugins/metadata/common/KisExiv2IODevice.cpp ./plugins/metadata/common/KisExiv2IODevice.cpp

index c62e2d15ae9..bf5cdc2bd63 100644

--- ./plugins/metadata/common/KisExiv2IODevice.cpp

+++ ./plugins/metadata/common/KisExiv2IODevice.cpp

@@ -39,7 +39,11 @@ int KisExiv2IODevice::close()

     return 0;

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+size_t KisExiv2IODevice::write(const Exiv2::byte *data, size_t wcount)

+#else

 long KisExiv2IODevice::write(const Exiv2::byte *data, long wcount)

+#endif

 {

     if (!m_file.isWritable()) {

         qWarning() << "KisExiv2IODevice: File not open for writing.";

@@ -53,7 +57,11 @@ long KisExiv2IODevice::write(const Exiv2::byte *data, long wcount)

     return 0;

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+size_t KisExiv2IODevice::write(Exiv2::BasicIo &src)

+#else

 long KisExiv2IODevice::write(Exiv2::BasicIo &src)

+#endif

 {

     if (static_cast<BasicIo *>(this) == &src) {

         return 0;

@@ -88,15 +96,28 @@ int KisExiv2IODevice::putb(Exiv2::byte data)

     }

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+Exiv2::DataBuf KisExiv2IODevice::read(size_t rcount)

+#else

 Exiv2::DataBuf KisExiv2IODevice::read(long rcount)

+#endif

 {

     Exiv2::DataBuf buf(rcount);

+#if EXIV2_TEST_VERSION(0,28,0)

+    const size_t readCount = read(buf.data(), buf.size());

+    buf.resize(readCount);

+#else

     const long readCount = read(buf.pData_, buf.size_);

     buf.size_ = readCount;

+#endif

     return buf;

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+size_t KisExiv2IODevice::read(Exiv2::byte *buf, size_t rcount)

+#else

 long KisExiv2IODevice::read(Exiv2::byte *buf, long rcount)

+#endif

 {

     const qint64 bytesRead = m_file.read(reinterpret_cast<char *>(buf), rcount);

     if (bytesRead > 0) {

@@ -202,7 +223,18 @@ int KisExiv2IODevice::munmap()

     return 0;

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+void KisExiv2IODevice::populateFakeData()

+{

+    return;

+}

+#endif

+

+#if EXIV2_TEST_VERSION(0,28,0)

+size_t KisExiv2IODevice::tell() const

+#else

 long KisExiv2IODevice::tell() const

+#endif

 {

     return m_file.pos();

 }

@@ -231,7 +263,11 @@ bool KisExiv2IODevice::eof() const

     return m_file.atEnd();

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+const std::string& KisExiv2IODevice::path() const noexcept

+#else

 std::string KisExiv2IODevice::path() const

+#endif

 {

     return filePathQString().toStdString();

 }

diff --git ./plugins/metadata/common/KisExiv2IODevice.h ./plugins/metadata/common/KisExiv2IODevice.h

index d90831e8325..27f5f8d5fc4 100644

--- ./plugins/metadata/common/KisExiv2IODevice.h

+++ ./plugins/metadata/common/KisExiv2IODevice.h

@@ -18,18 +18,30 @@

 class KRITAEXIFCOMMON_EXPORT KisExiv2IODevice : public Exiv2::BasicIo

 {

 public:

+#if EXIV2_TEST_VERSION(0,28,0)

+    using ptr_type = Exiv2::BasicIo::UniquePtr;

+#else

     using ptr_type = Exiv2::BasicIo::AutoPtr;

+#endif

     KisExiv2IODevice(QString path);

     ~KisExiv2IODevice() override;

     int open() override;

     int close() override;

+#if EXIV2_TEST_VERSION(0,28,0)

+    size_t write(const Exiv2::byte *data, size_t wcount) override;

+    size_t write(Exiv2::BasicIo &src) override;

+    int putb(Exiv2::byte data) override;

+    Exiv2::DataBuf read(size_t rcount) override;

+    size_t read(Exiv2::byte *buf, size_t rcount) override;

+#else

     long write(const Exiv2::byte *data, long wcount) override;

     long write(Exiv2::BasicIo &src) override;

     int putb(Exiv2::byte data) override;

     Exiv2::DataBuf read(long rcount) override;

     long read(Exiv2::byte *buf, long rcount) override;

+#endif

     int getb() override;

     void transfer(BasicIo &src) override;

 #if defined(_MSC_VER)

@@ -39,13 +51,24 @@ public:

 #endif

     Exiv2::byte *mmap(bool isWriteable = false) override;

+#if EXIV2_TEST_VERSION(0,28,0)

+    void populateFakeData() override;

+#endif

     int munmap() override;

+#if EXIV2_TEST_VERSION(0,28,0)

+    size_t tell() const override;

+#else

     long tell() const override;

+#endif

     size_t size() const override;

     bool isopen() const override;

     int error() const override;

     bool eof() const override;

+#if EXIV2_TEST_VERSION(0,28,0)

+    const std::string& path() const noexcept override;

+#else

     std::string path() const override;

+#endif

 private:

     bool open(QFile::OpenMode mode);

--- ./plugins/metadata/common/kis_exiv2_common.h

+++ ./plugins/metadata/common/kis_exiv2_common.h

@@ -19,9 +19,13 @@

 // Convert an exiv value to a KisMetaData value

 inline KisMetaData::Value

+#if EXIV2_TEST_VERSION(0,28,0)

+exivValueToKMDValue(const Exiv2::Value::UniquePtr &value, bool forceSeq, KisMetaData::Value::ValueType arrayType = KisMetaData::Value::UnorderedArray)

+#else

 exivValueToKMDValue(const Exiv2::Value::AutoPtr value,

                     bool forceSeq,

                     KisMetaData::Value::ValueType arrayType = KisMetaData::Value::UnorderedArray)

+#endif

 {

     switch (value->typeId()) {

     case Exiv2::signedByte:

@@ -42,11 +46,19 @@

     case Exiv2::signedShort:

     case Exiv2::signedLong: {

         if (value->count() == 1 && !forceSeq) {

+#if EXIV2_TEST_VERSION(0,28,0)

+            return {static_cast<int>(value->toUint32())};

+#else

             return KisMetaData::Value((int)value->toLong());

+#endif

         } else {

             QList<KisMetaData::Value> array;

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

+#if EXIV2_TEST_VERSION(0,28,0)

+                array.push_back({static_cast<int>(value->toUint32(i))});

+#else

                 array.push_back(KisMetaData::Value((int)value->toLong(i)));

+#endif

             return KisMetaData::Value(array, arrayType);

         }

     }

@@ -63,7 +75,11 @@

             return {KisMetaData::Rational(value->toRational().first, value->toRational().second)};

         } else {

             QList<KisMetaData::Value> array;

+#if EXIV2_TEST_VERSION(0,28,0)

+            for (size_t i = 0; i < value->count(); i++) {

+#else

             for (long i = 0; i < value->count(); i++) {

+#endif

                 array.push_back(KisMetaData::Rational(value->toRational(i).first, value->toRational(i).second));

             }

             return KisMetaData::Value(array, arrayType);

@@ -77,7 +93,11 @@

             return KisMetaData::Value(KisMetaData::Rational(value->toRational().first, value->toRational().second));

         } else {

             QList<KisMetaData::Value> array;

+#if EXIV2_TEST_VERSION(0,28,0)

+            for (size_t i = 0; i < value->count(); i++) {

+#else

             for (long i = 0; i < value->count(); i++) {

+#endif

                 array.push_back(KisMetaData::Rational(value->toRational(i).first, value->toRational(i).second));

             }

             return KisMetaData::Value(array, arrayType);

diff --git ./plugins/metadata/exif/kis_exif_io.cpp ./plugins/metadata/exif/kis_exif_io.cpp

index a3ee6927fca..a3b903afcb5 100644

--- ./plugins/metadata/exif/kis_exif_io.cpp

+++ ./plugins/metadata/exif/kis_exif_io.cpp

@@ -31,7 +31,11 @@

 // ---- Exception conversion functions ---- //

 // convert ExifVersion and FlashpixVersion to a KisMetaData value

+#if EXIV2_TEST_VERSION(0,28,0)

+KisMetaData::Value exifVersionToKMDValue(const Exiv2::Value::UniquePtr value)

+#else

 KisMetaData::Value exifVersionToKMDValue(const Exiv2::Value::AutoPtr value)

+#endif

 {

     const Exiv2::DataValue *dvalue = dynamic_cast<const Exiv2::DataValue *>(&*value);

     if (dvalue) {

@@ -55,13 +59,22 @@ Exiv2::Value *kmdValueToExifVersion(const KisMetaData::Value &value)

 }

 // Convert an exif array of integer string to a KisMetaData array of integer

+#if EXIV2_TEST_VERSION(0,28,0)

+KisMetaData::Value exifArrayToKMDIntOrderedArray(const Exiv2::Value::UniquePtr value)

+#else

 KisMetaData::Value exifArrayToKMDIntOrderedArray(const Exiv2::Value::AutoPtr value)

+#endif

 {

     QList<KisMetaData::Value> v;

     const Exiv2::DataValue *dvalue = dynamic_cast<const Exiv2::DataValue *>(&*value);

     if (dvalue) {

+#if EXIV2_TEST_VERSION(0,28,0)

+        for (size_t i = 0; i < dvalue->count(); i++) {

+            v.push_back({(int)dvalue->toUint32(i)});

+#else

         for (long i = 0; i < dvalue->count(); i++) {

             v.push_back({(int)dvalue->toLong(i)});

+#endif

         }

     } else {

         Q_ASSERT(value->typeId() == Exiv2::asciiString);

@@ -81,7 +94,11 @@ Exiv2::Value *kmdIntOrderedArrayToExifArray(const KisMetaData::Value &value)

     return new Exiv2::DataValue(v.data(), static_cast<long>(v.size()));

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+QDateTime exivValueToDateTime(const Exiv2::Value::UniquePtr value)

+#else

 QDateTime exivValueToDateTime(const Exiv2::Value::AutoPtr value)

+#endif

 {

     return QDateTime::fromString(value->toString().c_str(), Qt::ISODate);

 }

@@ -115,7 +132,11 @@ Exiv2::ByteOrder invertByteOrder(Exiv2::ByteOrder order)

     return Exiv2::invalidByteOrder;

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+KisMetaData::Value exifOECFToKMDOECFStructure(const Exiv2::Value::UniquePtr value, Exiv2::ByteOrder order)

+#else

 KisMetaData::Value exifOECFToKMDOECFStructure(const Exiv2::Value::AutoPtr value, Exiv2::ByteOrder order)

+#endif

 {

     QMap<QString, KisMetaData::Value> oecfStructure;

     const Exiv2::DataValue *dvalue = dynamic_cast<const Exiv2::DataValue *>(&*value);

@@ -123,22 +144,39 @@ KisMetaData::Value exifOECFToKMDOECFStructure(const Exiv2::Value::AutoPtr value,

     QByteArray array(dvalue->count(), 0);

     dvalue->copy((Exiv2::byte *)array.data());

+#if EXIV2_TEST_VERSION(0,28,0)

+    size_t columns = fixEndianess<qsizetype>((reinterpret_cast<qsizetype *>(array.data()))[0], order);

+    size_t rows = fixEndianess<qsizetype>((reinterpret_cast<qsizetype *>(array.data()))[1], order);

+#else

     int columns = fixEndianess<quint16>((reinterpret_cast<quint16 *>(array.data()))[0], order);

     int rows = fixEndianess<quint16>((reinterpret_cast<quint16 *>(array.data()))[1], order);

+#endif

     if ((columns * rows + 4)

         > dvalue->count()) { // Sometime byteOrder get messed up (especially if metadata got saved with kexiv2 library,

                              // or any library that doesn't save back with the same byte order as the camera)

         order = invertByteOrder(order);

+#if EXIV2_TEST_VERSION(0,28,0)

+        columns = fixEndianess<qsizetype>((reinterpret_cast<qsizetype *>(array.data()))[0], order);

+        rows = fixEndianess<qsizetype>((reinterpret_cast<qsizetype *>(array.data()))[1], order);

+#else

         columns = fixEndianess<quint16>((reinterpret_cast<quint16 *>(array.data()))[0], order);

         rows = fixEndianess<quint16>((reinterpret_cast<quint16 *>(array.data()))[1], order);

+#endif

         Q_ASSERT((columns * rows + 4) > dvalue->count());

     }

-    oecfStructure["Columns"] = KisMetaData::Value(columns);

-    oecfStructure["Rows"] = KisMetaData::Value(rows);

+    QVariant qcolumns, qrows;

+    qcolumns.setValue(columns);

+    qrows.setValue(rows);

+    oecfStructure["Columns"] = KisMetaData::Value(qcolumns);

+    oecfStructure["Rows"] = KisMetaData::Value(qrows);

     int index = 4;

     QList<KisMetaData::Value> names;

+#if EXIV2_TEST_VERSION(0,28,0)

+    for (size_t i = 0; i < columns; i++) {

+#else

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

+#endif

         int lastIndex = array.indexOf((char)0, index);

         QString name = array.mid(index, lastIndex - index);

         if (index != lastIndex) {

@@ -153,8 +191,13 @@ KisMetaData::Value exifOECFToKMDOECFStructure(const Exiv2::Value::AutoPtr value,

     oecfStructure["Names"] = KisMetaData::Value(names, KisMetaData::Value::OrderedArray);

     QList<KisMetaData::Value> values;

     qint32 *dataIt = reinterpret_cast<qint32 *>(array.data() + index);

+#if EXIV2_TEST_VERSION(0,28,0)

+    for (size_t i = 0; i < columns; i++) {

+        for (size_t j = 0; j < rows; j++) {

+#else

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

         for (int j = 0; j < rows; j++) {

+#endif

             values.append(KisMetaData::Value(

                 KisMetaData::Rational(fixEndianess<qint32>(dataIt[0], order), fixEndianess<qint32>(dataIt[1], order))));

             dataIt += 2;

@@ -202,7 +245,11 @@ Exiv2::Value *kmdOECFStructureToExifOECF(const KisMetaData::Value &value)

     return new Exiv2::DataValue((const Exiv2::byte *)array.data(), array.size());

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+KisMetaData::Value deviceSettingDescriptionExifToKMD(const Exiv2::Value::UniquePtr value)

+#else

 KisMetaData::Value deviceSettingDescriptionExifToKMD(const Exiv2::Value::AutoPtr value)

+#endif

 {

     QMap<QString, KisMetaData::Value> deviceSettingStructure;

     QByteArray array;

@@ -258,15 +305,24 @@ Exiv2::Value *deviceSettingDescriptionKMDToExif(const KisMetaData::Value &value)

     return new Exiv2::DataValue((const Exiv2::byte *)array.data(), array.size());

 }

+#if EXIV2_TEST_VERSION(0,28,0)

+KisMetaData::Value cfaPatternExifToKMD(const Exiv2::Value::UniquePtr value, Exiv2::ByteOrder order)

+#else

 KisMetaData::Value cfaPatternExifToKMD(const Exiv2::Value::AutoPtr value, Exiv2::ByteOrder order)

+#endif

 {

     QMap<QString, KisMetaData::Value> cfaPatternStructure;

     const Exiv2::DataValue *dvalue = dynamic_cast<const Exiv2::DataValue *>(&*value);

     Q_ASSERT(dvalue);

     QByteArray array(dvalue->count(), 0);

     dvalue->copy((Exiv2::byte *)array.data());

+#if EXIV2_TEST_VERSION(0,28,0)

+    size_t columns = fixEndianess<qsizetype>((reinterpret_cast<qsizetype *>(array.data()))[0], order);

+    size_t rows = fixEndianess<qsizetype>((reinterpret_cast<qsizetype *>(array.data()))[1], order);

+#else

     int columns = fixEndianess<quint16>((reinterpret_cast<quint16 *>(array.data()))[0], order);

     int rows = fixEndianess<quint16>((reinterpret_cast<quint16 *>(array.data()))[1], order);

+#endif

     if ((columns * rows + 4)

         != dvalue->count()) { // Sometime byteOrder get messed up (especially if metadata got saved with kexiv2 library,

                               // or any library that doesn't save back with the same byte order as the camera)

@@ -275,8 +331,11 @@ KisMetaData::Value cfaPatternExifToKMD(const Exiv2::Value::AutoPtr value, Exiv2:

         rows = fixEndianess<quint16>((reinterpret_cast<quint16 *>(array.data()))[1], order);

         Q_ASSERT((columns * rows + 4) == dvalue->count());

     }

-    cfaPatternStructure["Columns"] = KisMetaData::Value(columns);

-    cfaPatternStructure["Rows"] = KisMetaData::Value(rows);

+    QVariant qcolumns, qrows;

+    qcolumns.setValue(columns);

+    qrows.setValue(rows);

+    cfaPatternStructure["Columns"] = KisMetaData::Value(qcolumns);

+    cfaPatternStructure["Rows"] = KisMetaData::Value(qrows);

     QList<KisMetaData::Value> values;

     int index = 4;

     for (int i = 0; i < columns * rows; i++) {

@@ -310,9 +369,17 @@ Exiv2::Value *cfaPatternKMDToExif(const KisMetaData::Value &value)

 // Read and write Flash //

+#if EXIV2_TEST_VERSION(0,28,0)

+KisMetaData::Value flashExifToKMD(const Exiv2::Value::UniquePtr value)

+#else

 KisMetaData::Value flashExifToKMD(const Exiv2::Value::AutoPtr value)

+#endif

 {

+#if EXIV2_TEST_VERSION(0,28,0)

+    const uint16_t v = static_cast<uint16_t>(value->toUint32());

+#else

     const uint16_t v = static_cast<uint16_t>(value->toLong());

+#endif

     QMap<QString, KisMetaData::Value> flashStructure;

     bool fired = (v & 0x01); // bit 1 is whether flash was fired or not

     flashStructure["Fired"] = QVariant(fired);

@@ -465,7 +532,11 @@ bool KisExifIO::saveTo(const KisMetaData::Store *store, QIODevice *ioDevice, Hea

                                 << exivKey; // << " of KMD value" << entry.value();

                 }

             }

+#if EXIV2_TEST_VERSION(0,28,0)

+        } catch (Exiv2::Error &e) {

+#else

         } catch (Exiv2::AnyError &e) {

+#endif

             dbgMetaData << "exiv error " << e.what();

         }

     }

diff --git ./plugins/metadata/iptc/kis_iptc_io.cpp ./plugins/metadata/iptc/kis_iptc_io.cpp

index 9e85624644d..88d80b38b8d 100644

--- ./plugins/metadata/iptc/kis_iptc_io.cpp

+++ ./plugins/metadata/iptc/kis_iptc_io.cpp

@@ -109,7 +109,11 @@ bool KisIptcIO::saveTo(const KisMetaData::Store *store, QIODevice *ioDevice, Hea

                 if (v && v->typeId() != Exiv2::invalidTypeId) {

                     iptcData.add(iptcKey, v);

                 }

+#if EXIV2_TEST_VERSION(0,28,0)

+            } catch (Exiv2::Error &e) {

+#else

             } catch (Exiv2::AnyError &e) {

+#endif

                 dbgMetaData << "exiv error " << e.what();

             }

         }

@@ -127,7 +131,11 @@ bool KisIptcIO::saveTo(const KisMetaData::Store *store, QIODevice *ioDevice, Hea

         header.append(photoshopBimId_);

         header.append(photoshopIptc_);

         header.append(QByteArray(2, 0));

+#if EXIV2_TEST_VERSION(0, 28, 0)

+        qint32 size = rawData.size();

+#else

         qint32 size = rawData.size_;

+#endif

         QByteArray sizeArray(4, 0);

         sizeArray[0] = (char)((size & 0xff000000) >> 24);

         sizeArray[1] = (char)((size & 0x00ff0000) >> 16);

@@ -137,7 +145,11 @@ bool KisIptcIO::saveTo(const KisMetaData::Store *store, QIODevice *ioDevice, Hea

         ioDevice->write(header);

     }

+#if EXIV2_TEST_VERSION(0, 28, 0)

+    ioDevice->write((const char *)rawData.data(), rawData.size());

+#else

     ioDevice->write((const char *)rawData.pData_, rawData.size_);

+#endif

     ioDevice->close();

     return true;

 }

diff --git ./plugins/metadata/xmp/kis_xmp_io.cpp ./plugins/metadata/xmp/kis_xmp_io.cpp

index a1003175455..927abe8dddf 100644

--- ./plugins/metadata/xmp/kis_xmp_io.cpp

+++ ./plugins/metadata/xmp/kis_xmp_io.cpp

@@ -249,8 +249,11 @@ bool KisXMPIO::loadFrom(KisMetaData::Store *store, QIODevice *ioDevice) const

                     Q_ASSERT(schema);

                 }

             }

+#if EXIV2_TEST_VERSION(0,28,0)

+            const Exiv2::Value::UniquePtr value = it->getValue();

+#else

             const Exiv2::Value::AutoPtr value = it->getValue();

-

+#endif

             QString structName;

             int arrayIndex = -1;

             QString tagName;

@@ -279,7 +282,11 @@ bool KisXMPIO::loadFrom(KisMetaData::Store *store, QIODevice *ioDevice) const

                 const Exiv2::XmpArrayValue *xav = dynamic_cast<const Exiv2::XmpArrayValue *>(value.get());

                 Q_ASSERT(xav);

                 QList<KisMetaData::Value> array;

+#if EXIV2_TEST_VERSION(0,28,0)

+                for (size_t i = 0; i < xav->count(); ++i) {

+#else

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

+#endif

                     QString value = QString::fromStdString(xav->toString(i));

                     if (parser) {

                         array.push_back(parser->parse(value));