File indexing completed on 2025-01-05 03:58:04

 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2020-09-24
  * Description : Test ImageMagick loader to QImage.
  *
  * SPDX-FileCopyrightText: 2020-2024 by Gilles Caulier <caulier dot gilles at gmail dot com>
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  *
  * ============================================================ */
 
 // Qt includes
 
 #include <QImage>
 #include <QPixmap>
 #include <QLabel>
 #include <QDir>
 #include <QStringList>
 #include <QList>
 #include <QApplication>
 #include <QStandardPaths>
 #include <QFileDialog>
 #include <QMimeDatabase>
 
 // ImageMagick includes
 
 // Pragma directives to reduce warnings from ImageMagick header files.
 #if !defined(Q_OS_DARWIN) && defined(Q_CC_GNU)
 #   pragma GCC diagnostic push
 #   pragma GCC diagnostic ignored "-Wignored-qualifiers"
 #   pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
 #endif
 
 #if defined(Q_CC_CLANG)
 #   pragma clang diagnostic push
 #   pragma clang diagnostic ignored "-Wignored-qualifiers"
 #   pragma clang diagnostic ignored "-Wkeyword-macro"
 #endif
 
 #include <Magick++.h>
 
 #if MagickLibVersion < 0x700
 #   include <magick/magick.h>
 #endif
 
 #if defined(Q_CC_CLANG)
 #   pragma clang diagnostic pop
 #endif
 
 #if defined(Q_CC_GNU)
 #   pragma GCC diagnostic pop
 #endif
 
 // Local includes
 
 #include "digikam_debug.h"
 
 using namespace Magick;
 using namespace MagickCore;
 
 /** Convert from QImage to IM::Image
  */
 /*Image* toImage(QImage* const qimage)
 {
     qCDebug(DIGIKAM_TESTS_LOG) << "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)
 {
     qCDebug(DIGIKAM_TESTS_LOG) << "Try to load image with ImageMagick codecs";
 
     try
     {
         Magick::Image image;
         image.read(path.toUtf8().constData());
 
         qCDebug(DIGIKAM_TESTS_LOG) << "IM toQImage     :" << image.columns() << image.rows();
         qCDebug(DIGIKAM_TESTS_LOG) << "IM QuantumRange :" << QuantumRange;
 
         Blob* const pixelBlob = new Blob;
         image.write(pixelBlob, "BGRA", 8);
         qCDebug(DIGIKAM_TESTS_LOG) << "IM blob size    :" << pixelBlob->length();
 
         qimg = QImage((uchar*)pixelBlob->data(), image.columns(), image.rows(), QImage::Format_ARGB32);
         qCDebug(DIGIKAM_TESTS_LOG) << "QImage data size:" << qimg.sizeInBytes();
 
         if (qimg.isNull())
         {
             return false;
         }
     }
     catch (Exception& error_)
     {
         qCWarning(DIGIKAM_TESTS_LOG) << "Cannot load [" << path << "] due to ImageMagick exception:" << error_.what();
         qimg = QImage();
         return false;
     }
 
     return true;
 }
 
 // ---------------------------------------------------------------------------------------------------
 
 int main(int argc, char** argv)
 {
     MagickCoreGenesis((char*)nullptr, MagickFalse);
 
     ExceptionInfo ex = *AcquireExceptionInfo();
     size_t n                  = 0;
     const MagickInfo** inflst = GetMagickInfoList("*", &n, &ex);
 
     if (!inflst)
     {
         qCWarning(DIGIKAM_TESTS_LOG) << "ImageMagick coders list is null!";
         return -1;
     }
 
     qCDebug(DIGIKAM_TESTS_LOG).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/")))
             {
                 qCDebug(DIGIKAM_TESTS_LOG).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]));
         }
     }
 
     qCDebug(DIGIKAM_TESTS_LOG) << "Files to load:" << list;
 
     if (!list.isEmpty())
     {
         Q_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
             {
                 qCWarning(DIGIKAM_TESTS_LOG) << "exit -1";
                 MagickCoreTerminus();
                 return -1;
             }
         }
 
         app.exec();
     }
 
     free(inflst);
     MagickCoreTerminus();
 
     return 0;
 }