diff --git a/core/dplugins/dimg/imagemagick/dimgimagemagickplugin.cpp b/core/dplugins/dimg/imagemagick/dimgimagemagickplugin.cpp
index 1858b4d27b..20ef01be73 100644
--- a/core/dplugins/dimg/imagemagick/dimgimagemagickplugin.cpp
+++ b/core/dplugins/dimg/imagemagick/dimgimagemagickplugin.cpp
@@ -1,305 +1,305 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2019-09-21
  * Description : ImageMagick DImg plugin.
  *
  * Copyright (C) 2019 by Gilles Caulier <caulier dot gilles at gmail dot com>
  *
  * 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, 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.
  *
  * ============================================================ */
 
 #include "dimgimagemagickplugin.h"
 
 // Image Magick includes
 
 #if defined(Q_CC_CLANG)
 #   pragma clang diagnostic push
 #   pragma clang diagnostic ignored "-Wkeyword-macro"
 #endif
 
 #include <Magick++.h>
 
 #if MagickLibVersion < 0x700
 #   include <magick/magick.h>
 #endif
 
 using namespace Magick;
 using namespace MagickCore;
 
 #if defined(Q_CC_CLANG)
 #   pragma clang diagnostic pop
 #endif
 
 // Qt includes
 
 #include <QMimeDatabase>
 
 // KDE includes
 
 #include <klocalizedstring.h>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "digikam_globals.h"
 #include "dimgimagemagickloader.h"
 
 namespace DigikamImageMagickDImgPlugin
 {
 
 DImgImageMagickPlugin::DImgImageMagickPlugin(QObject* const parent)
     : DPluginDImg(parent)
 {
     MagickCoreGenesis((char*)NULL ,MagickFalse);
 }
 
 DImgImageMagickPlugin::~DImgImageMagickPlugin()
 {
 }
 
 void DImgImageMagickPlugin::cleanUp()
 {
     MagickCoreTerminus();
 }
 
 QString DImgImageMagickPlugin::name() const
 {
     return i18n("ImageMagick loader");
 }
 
 QString DImgImageMagickPlugin::iid() const
 {
     return QLatin1String(DPLUGIN_IID);
 }
 
 QIcon DImgImageMagickPlugin::icon() const
 {
     return QIcon::fromTheme(QLatin1String("image-x-generic"));
 }
 
 QString DImgImageMagickPlugin::description() const
 {
     return i18n("An image loader based on ImageMagick coders");
 }
 
 QString DImgImageMagickPlugin::details() const
 {
     return i18n("<p>This plugin permit to load and save image using ImageMagick coders.</p>"
                 "<p>ImageMagick is a free and open-source software suite for converting raster image and vector image files. "
                 "It can read and write over 200 image file formats.</p>"
                 "<p>See <a href='https://en.wikipedia.org/wiki/ImageMagick'>ImageMagick documentation</a> for details.</p>"
     );
 }
 
 QList<DPluginAuthor> DImgImageMagickPlugin::authors() const
 {
     return QList<DPluginAuthor>()
             << DPluginAuthor(QString::fromUtf8("Maik Qualmann"),
                              QString::fromUtf8("metzpinguin at gmail dot com"),
                              QString::fromUtf8("(C) 2019"))
             << DPluginAuthor(QString::fromUtf8("Gilles Caulier"),
                              QString::fromUtf8("caulier dot gilles at gmail dot com"),
                              QString::fromUtf8("(C) 2006-2019"))
             ;
 }
 
 void DImgImageMagickPlugin::setup(QObject* const /*parent*/)
 {
     // Nothing to do
 }
 
 QMap<QString, QString> DImgImageMagickPlugin::extraAboutData() const
 {
     QString mimes = typeMimes();
 
     QMap<QString, QString> map;
-    ExceptionInfo ex;
+    ExceptionInfo ex = *AcquireExceptionInfo();
     size_t n                  = 0;
     const MagickInfo** inflst = GetMagickInfoList("*", &n, &ex);
 
     if (!inflst)
     {
         qWarning() << "ImageMagick coders list is null!";
         return QMap<QString, QString>();
     }
 
     for (uint i = 0 ; i < n ; ++i)
     {
         const MagickInfo* inf = inflst[i];
 
         if (inf)
         {
             QString mod =
 #if (MagickLibVersion >= 0x69A && defined(magick_module))
                 QString::fromLatin1(inf->magick_module).toUpper();
 #else
                 QString::fromLatin1(inf->module).toUpper();
 #endif
 
             if (mimes.contains(mod))
             {
                 map.insert(mod, QLatin1String(inf->description));
             }
         }
     }
 
     return map;
 }
 
 QString DImgImageMagickPlugin::loaderName() const
 {
     return QLatin1String("IMAGEMAGICK");
 }
 
 QString DImgImageMagickPlugin::typeMimes() const
 {
     QStringList formats = decoderFormats();
     formats.sort();
 
     QString ret;
 
     foreach (const QString& str, formats)
     {
         if (!ret.contains(str))
         {
             ret += QString::fromUtf8("%1 ").arg(str.toUpper());
         }
     }
 
     return ret;
 }
 
 int DImgImageMagickPlugin::canRead(const QFileInfo& fileInfo, bool magic) const
 {
     QString filePath = fileInfo.filePath();
     QString format   = fileInfo.suffix().toUpper();
 
     if (!magic)
     {
         QString mimeType(QMimeDatabase().mimeTypeForFile(filePath).name());
 
         // Ignore non image format.
 
         if (
             mimeType.startsWith(QLatin1String("video/")) ||
             mimeType.startsWith(QLatin1String("audio/"))
            )
         {
             return 0;
         }
 
         if (decoderFormats().contains(format))
         {
             if (format == QLatin1String("WEBP"))
             {
                 return 70;
             }
             else
             {
                 return 90;
             }
         }
     }
 
     return 0;
 }
 
 int DImgImageMagickPlugin::canWrite(const QString& format) const
 {
     QStringList formats;
-    ExceptionInfo ex;
+    ExceptionInfo ex = *AcquireExceptionInfo();
     size_t n                  = 0;
     const MagickInfo** inflst = GetMagickInfoList("*", &n, &ex);
 
     if (!inflst)
     {
         qWarning() << "ImageMagick coders list is null!";
         return 0;
     }
 
     for (uint i = 0 ; i < n ; ++i)
     {
         const MagickInfo* inf = inflst[i];
 
         if (inf && inf->encoder)
         {
 #if (MagickLibVersion >= 0x69A && defined(magick_module))
             formats.append(QString::fromLatin1(inf->magick_module).toUpper());
 #else
             formats.append(QString::fromLatin1(inf->module).toUpper());
 #endif
         }
     }
 
     if (formats.contains(format.toUpper()))
     {
         if (format.toUpper() == QLatin1String("WEBP"))
         {
             return 70;
         }
         else
         {
             return 90;
         }
     }
 
     return 0;
 }
 
 DImgLoader* DImgImageMagickPlugin::loader(DImg* const image, const DRawDecoding&) const
 {
     return new DImgImageMagickLoader(image);
 }
 
 QStringList DImgImageMagickPlugin::decoderFormats() const
 {
     QStringList formats;
-    ExceptionInfo ex;
+    ExceptionInfo ex = *AcquireExceptionInfo();
     size_t n                  = 0;
     const MagickInfo** inflst = GetMagickInfoList("*", &n, &ex);
 
     if (!inflst)
     {
         qWarning() << "ImageMagick coders list is null!";
         return formats;
     }
 
     for (uint i = 0 ; i < n ; ++i)
     {
         const MagickInfo* inf = inflst[i];
 
         if (inf && inf->decoder)
         {
 #if (MagickLibVersion >= 0x69A && defined(magick_module))
             formats.append(QString::fromLatin1(inf->magick_module).toUpper());
 #else
             formats.append(QString::fromLatin1(inf->module).toUpper());
 #endif
         }
     }
 
     if (formats.contains(QLatin1String("JPEG")))
     {
         formats.append(QLatin1String("JPG"));
         formats.append(QLatin1String("JPE"));
     }
 
     // Remove known formats that are not stable.
     formats.removeAll(QLatin1String("XCF"));
 
     return formats;
 }
 
 } // namespace DigikamImageMagickDImgPlugin
diff --git a/core/tests/dimg/magickloader.cpp b/core/tests/dimg/magickloader.cpp
index 2526779047..73f2abec0e 100644
--- a/core/tests/dimg/magickloader.cpp
+++ b/core/tests/dimg/magickloader.cpp
@@ -1,229 +1,229 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * http://www.digikam.org
  *
  * Date        : 2017-09-24
  * Description : Test ImageMagick loader to QImage.
  *
  * Copyright (C) 2019 by Gilles Caulier <caulier dot gilles at gmail dot com>
  *
  * 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, 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.
  *
  * ============================================================ */
 
 // ImageMagick includes
 
 #include <Magick++.h>
 
 #if MagickLibVersion < 0x700
 #   include <magick/magick.h>
 #endif
 
 using namespace Magick;
 using namespace MagickCore;
 
 // Qt includes
 
 #include <QImage>
 #include <QPixmap>
 #include <QLabel>
 #include <QDir>
 #include <QStringList>
 #include <QList>
 #include <QDebug>
 #include <QApplication>
 #include <QStandardPaths>
 #include <QFileDialog>
 #include <QMimeDatabase>
 
 /** Convert from QImage to IM::Image
  */
 /*Image* toImage(QImage* const qimage)
 {
     qDebug() << "toImage:" << qimage->width() << qimage->height();
 
     Image* const newImage = new Image(Magick::Geometry(qimage->width(), qimage->height()), Magick::ColorRGB(0.5, 0.2, 0.3));
     newImage->modifyImage();
 
     double scale                = 1 / 256.0;
     Magick::Quantum* pixels = 0;
     Magick::ColorRGB mgc;
 
     for (int y = 0 ; y < qimage->height() ; ++y)
     {
         pixels = newImage->setPixels(0, y, newImage->columns(), 1);
 
         for (int x = 0 ; x < qimage->width() ; ++x)
         {
             QColor pix = qimage->pixel(x, y);
             mgc.red  (scale * pix.red());
             mgc.green(scale * pix.green());
             mgc.blue (scale * pix.blue());
             *pixels++ = mgc;
         }
 
         newImage->syncPixels();
     }
 
     return newImage;
 }
 */
 /** Convert pixel from IM::Image to QImage.
  */
 
 // -- ImageMagick codecs to QImage --------------------------------------------------------
 
 bool loadWithImageMagick(const QString& path, QImage& qimg)
 {
     qDebug() << "Try to load image with ImageMagick codecs";
 
     try
     {
         Magick::Image image;
         image.read(path.toUtf8().constData());
 
         qDebug() << "IM toQImage     :" << image.columns() << image.rows();
         qDebug() << "IM QuantumRange :" << QuantumRange;
 
         Blob* const pixelBlob = new Blob;
         image.write(pixelBlob, "BGRA", 8);
         qDebug() << "IM blob size    :" << pixelBlob->length();
 
         qimg = QImage((uchar*)pixelBlob->data(), image.columns(), image.rows(), QImage::Format_ARGB32);
 
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
         qDebug() << "QImage data size:" << qimg.sizeInBytes();
 #else
         qDebug() << "QImage data size:" << qimg.byteCount();
 #endif
 
         if (qimg.isNull())
         {
             return false;
         }
     }
     catch (Exception& error_)
     {
         qWarning() << "Cannot load [" << path << "] due to ImageMagick exception:" << error_.what();
         qimg = QImage();
         return false;
     }
 
     return true;
 }
 
 // ---------------------------------------------------------------------------------------------------
 
 int main(int argc, char** argv)
 {
     MagickCoreGenesis((char*)NULL, MagickFalse);
 
-    ExceptionInfo ex;
+    ExceptionInfo ex = *AcquireExceptionInfo();
     size_t n                  = 0;
     const MagickInfo** inflst = GetMagickInfoList("*", &n, &ex);
 
     if (!inflst)
     {
         qWarning() << "ImageMagick coders list is null!";
         return -1;
     }
 
     qDebug().noquote() << "Name             :: Module           :: Mime Type                    :: Mode  :: Version                      :: Description";
 
     for (uint i = 0 ; i < n ; ++i)
     {
         const MagickInfo* inf = inflst[i];
 
         if (inf)
         {
             QString mode;
 
             if (inf->decoder) mode.append(QLatin1Char('R'));
             else              mode.append(QLatin1Char('-'));
 
             if (inf->encoder) mode.append(QLatin1Char('W'));
             else              mode.append(QLatin1Char('-'));
 
 #if (MagickLibVersion >= 0x69A && defined(magick_module))
             QString mod  = QLatin1String(inf->magick_module);
 #else
             QString mod  = QLatin1String(inf->module);
 #endif
 
             QString mime = QMimeDatabase().mimeTypeForFile(QFileInfo(QString::fromLatin1("foo.%1").arg(mod))).name();
 
             if (mod != QLatin1String("DNG")  &&
                 mod != QLatin1String("JPEG") &&
                 mod != QLatin1String("PNG")  &&
                 mod != QLatin1String("TIFF") &&
                 mod != QLatin1String("JP2")  &&
                 mime.startsWith(QLatin1String("image/")))
             {
                 qDebug().noquote()
                      << QString::fromLatin1("%1").arg(QLatin1String(inf->name),        16) << "::"
                      << QString::fromLatin1("%1").arg(mod,                             16) << "::"
                      << QString::fromLatin1("%1").arg(mime,                            28) << "::"
                      << QString::fromLatin1("%1").arg(mode,                             5) << "::"
                      << QString::fromLatin1("%1").arg(QLatin1String(inf->version),     28) << "::"
                      << QString::fromLatin1("%1").arg(QLatin1String(inf->description), 64);
             }
         }
     }
 
     QApplication app(argc, argv);
 
     QStringList list;
 
     if (argc <= 1)
     {
         list = QFileDialog::getOpenFileNames(nullptr, QString::fromLatin1("Select Image Files to Load"),
                                              QStandardPaths::standardLocations(QStandardPaths::PicturesLocation).first(),
                                              QLatin1String("Image Files (*.png *.jpg *.tif *.bmp *.gif *.xcf *.kra *.psd)"));
     }
     else
     {
         for (int i = 1 ; i < argc ; ++i)
         {
             list.append(QString::fromLocal8Bit(argv[i]));
         }
     }
 
     qDebug() << "Files to load:" << list;
 
     if (!list.isEmpty())
     {
         foreach (const QString& path, list)
         {
             QImage qimg;
             bool ret = loadWithImageMagick(path, qimg);
 
             if (ret)
             {
                 QLabel* const lbl  = new QLabel;
                 lbl->setPixmap(QPixmap::fromImage(qimg.scaled(512, 512, Qt::KeepAspectRatio)));
                 lbl->show();
             }
             else
             {
                 qWarning() << "exit -1";
                 MagickCoreTerminus();
                 return -1;
             }
         }
 
         app.exec();
     }
 
     MagickCoreTerminus();
 
     return 0;
 }