qimagewriter.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qimagewriter.h"
 
#include <qbytearray.h>
#include <qfile.h>
#include <qfileinfo.h>
#include <qimage.h>
#include <qimageiohandler.h>
#include <qset.h>
#include <qvariant.h>
 
// factory loader
#include <qcoreapplication.h>
#include <private/qfactoryloader_p.h>
 
// image handlers
#include <private/qbmphandler_p.h>
#include <private/qppmhandler_p.h>
#include <private/qxbmhandler_p.h>
#include <private/qxpmhandler_p.h>
#ifndef QT_NO_IMAGEFORMAT_PNG
#include <private/qpnghandler_p.h>
#endif
 
#include <private/qimagereaderwriterhelpers_p.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
static QImageIOHandler *createWriteHandlerHelper(QIODevice *device,
    const QByteArray &format)
{
    QByteArray form = format.toLower();
    QByteArray suffix;
    QImageIOHandler *handler = nullptr;
 
#ifndef QT_NO_IMAGEFORMATPLUGIN
    typedef QMultiMap<int, QString> PluginKeyMap;
 
    // check if any plugins can write the image
    auto l = QImageReaderWriterHelpers::pluginLoader();
    const PluginKeyMap keyMap = l->keyMap();
    int suffixPluginIndex = -1;
#endif
 
    if (device && format.isEmpty()) {
        // if there's no format, see if \a device is a file, and if so, find
        // the file suffix and find support for that format among our plugins.
        // this allows plugins to override our built-in handlers.
        if (QFileDevice *file = qobject_cast<QFileDevice *>(device)) {
            if (!(suffix = QFileInfo(file->fileName()).suffix().toLower().toLatin1()).isEmpty()) {
#ifndef QT_NO_IMAGEFORMATPLUGIN
                const int index = keyMap.key(QString::fromLatin1(suffix), -1);
                if (index != -1)
                    suffixPluginIndex = index;
#endif
            }
        }
    }
 
    QByteArray testFormat = !form.isEmpty() ? form : suffix;
 
#ifndef QT_NO_IMAGEFORMATPLUGIN
    if (suffixPluginIndex != -1) {
        // when format is missing, check if we can find a plugin for the
        // suffix.
        const int index = keyMap.key(QString::fromLatin1(suffix), -1);
        if (index != -1) {
            QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(index));
            if (plugin && (plugin->capabilities(device, suffix) & QImageIOPlugin::CanWrite))
                handler = plugin->create(device, suffix);
        }
    }
#endif // QT_NO_IMAGEFORMATPLUGIN
 
    // check if any built-in handlers can write the image
    if (!handler && !testFormat.isEmpty()) {
        if (false) {
#ifndef QT_NO_IMAGEFORMAT_PNG
        } else if (testFormat == "png") {
            handler = new QPngHandler;
#endif
#ifndef QT_NO_IMAGEFORMAT_BMP
        } else if (testFormat == "bmp") {
            handler = new QBmpHandler;
        } else if (testFormat == "dib") {
            handler = new QBmpHandler(QBmpHandler::DibFormat);
#endif
#ifndef QT_NO_IMAGEFORMAT_XPM
        } else if (testFormat == "xpm") {
            handler = new QXpmHandler;
#endif
#ifndef QT_NO_IMAGEFORMAT_XBM
        } else if (testFormat == "xbm") {
            handler = new QXbmHandler;
            handler->setOption(QImageIOHandler::SubType, testFormat);
#endif
#ifndef QT_NO_IMAGEFORMAT_PPM
        } else if (testFormat == "pbm" || testFormat == "pbmraw" || testFormat == "pgm"
                 || testFormat == "pgmraw" || testFormat == "ppm" || testFormat == "ppmraw") {
            handler = new QPpmHandler;
            handler->setOption(QImageIOHandler::SubType, testFormat);
#endif
        }
    }
 
#ifndef QT_NO_IMAGEFORMATPLUGIN
    if (!testFormat.isEmpty()) {
        const int keyCount = keyMap.size();
        for (int i = 0; i < keyCount; ++i) {
            QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(i));
            if (plugin && (plugin->capabilities(device, testFormat) & QImageIOPlugin::CanWrite)) {
                delete handler;
                handler = plugin->create(device, testFormat);
                break;
            }
        }
    }
#endif // QT_NO_IMAGEFORMATPLUGIN
 
    if (!handler)
        return nullptr;
 
    handler->setDevice(device);
    if (!testFormat.isEmpty())
        handler->setFormat(testFormat);
    return handler;
}
 
class QImageWriterPrivate
{
public:
    QImageWriterPrivate(QImageWriter *qq);
 
    bool canWriteHelper();
 
    // device
    QByteArray format;
    QIODevice *device;
    bool deleteDevice;
    QImageIOHandler *handler;
 
    // image options
    int quality;
    int compression;
    float gamma;
    QString description;
    QString text;
    QByteArray subType;
    bool optimizedWrite;
    bool progressiveScanWrite;
    QImageIOHandler::Transformations transformation;
 
    // error
    QImageWriter::ImageWriterError imageWriterError;
    QString errorString;
 
    QImageWriter *q;
};
 
QImageWriterPrivate::QImageWriterPrivate(QImageWriter *qq)
{
    device = nullptr;
    deleteDevice = false;
    handler = nullptr;
    quality = -1;
    compression = -1;
    gamma = 0.0;
    optimizedWrite = false;
    progressiveScanWrite = false;
    imageWriterError = QImageWriter::UnknownError;
    errorString = QImageWriter::tr("Unknown error");
    transformation = QImageIOHandler::TransformationNone;
 
    q = qq;
}
 
bool QImageWriterPrivate::canWriteHelper()
{
    if (!device) {
        imageWriterError = QImageWriter::DeviceError;
        errorString = QImageWriter::tr("Device is not set");
        return false;
    }
    if (!device->isOpen()) {
        if (!device->open(QIODevice::WriteOnly)) {
            imageWriterError = QImageWriter::DeviceError;
            errorString = QImageWriter::tr("Cannot open device for writing: %1").arg(device->errorString());
            return false;
        }
    }
    if (!device->isWritable()) {
        imageWriterError = QImageWriter::DeviceError;
        errorString = QImageWriter::tr("Device not writable");
        return false;
    }
    if (!handler && (handler = createWriteHandlerHelper(device, format)) == nullptr) {
        imageWriterError = QImageWriter::UnsupportedFormatError;
        errorString = QImageWriter::tr("Unsupported image format");
        return false;
    }
    return true;
}
 
QImageWriter::QImageWriter()
    : d(new QImageWriterPrivate(this))
{
}
 
QImageWriter::QImageWriter(QIODevice *device, const QByteArray &format)
    : d(new QImageWriterPrivate(this))
{
    d->device = device;
    d->format = format;
}
 
QImageWriter::QImageWriter(const QString &fileName, const QByteArray &format)
    : QImageWriter(new QFile(fileName), format)
{
    d->deleteDevice = true;
}
 
QImageWriter::~QImageWriter()
{
    delete d->handler;
    if (d->deleteDevice)
        delete d->device;
    delete d;
}
 
void QImageWriter::setFormat(const QByteArray &format)
{
    d->format = format;
}
 
QByteArray QImageWriter::format() const
{
    return d->format;
}
 
void QImageWriter::setDevice(QIODevice *device)
{
    delete d->handler;
    d->handler = nullptr;
    if (d->device && d->deleteDevice)
        delete d->device;
 
    d->device = device;
    d->deleteDevice = false;
}
 
QIODevice *QImageWriter::device() const
{
    return d->device;
}
 
void QImageWriter::setFileName(const QString &fileName)
{
    setDevice(new QFile(fileName));
    d->deleteDevice = true;
}
 
QString QImageWriter::fileName() const
{
    QFileDevice *file = qobject_cast<QFileDevice *>(d->device);
    return file ? file->fileName() : QString();
}
 
void QImageWriter::setQuality(int quality)
{
    d->quality = quality;
}
 
int QImageWriter::quality() const
{
    return d->quality;
}
 
void QImageWriter::setCompression(int compression)
{
    d->compression = compression;
}
 
int QImageWriter::compression() const
{
    return d->compression;
}
 
void QImageWriter::setSubType(const QByteArray &type)
{
    d->subType = type;
}
 
QByteArray QImageWriter::subType() const
{
    return d->subType;
}
 
QList<QByteArray> QImageWriter::supportedSubTypes() const
{
    if (!supportsOption(QImageIOHandler::SupportedSubTypes))
        return QList<QByteArray>();
    return qvariant_cast<QList<QByteArray> >(d->handler->option(QImageIOHandler::SupportedSubTypes));
}
 
void QImageWriter::setOptimizedWrite(bool optimize)
{
    d->optimizedWrite = optimize;
}
 
bool QImageWriter::optimizedWrite() const
{
    return d->optimizedWrite;
}
 
void QImageWriter::setProgressiveScanWrite(bool progressive)
{
    d->progressiveScanWrite = progressive;
}
 
bool QImageWriter::progressiveScanWrite() const
{
    return d->progressiveScanWrite;
}
 
void QImageWriter::setTransformation(QImageIOHandler::Transformations transform)
{
    d->transformation = transform;
}
 
QImageIOHandler::Transformations QImageWriter::transformation() const
{
    return d->transformation;
}
 
void QImageWriter::setText(const QString &key, const QString &text)
{
    if (!d->description.isEmpty())
        d->description += "\n\n"_L1;
    d->description += key.simplified() + ": "_L1 + text.simplified();
}
 
bool QImageWriter::canWrite() const
{
    if (QFile *file = qobject_cast<QFile *>(d->device)) {
        const bool remove = !file->isOpen() && !file->exists();
        const bool result = d->canWriteHelper();
 
        // This looks strange (why remove if it doesn't exist?) but the issue
        // here is that canWriteHelper will create the file in the process of
        // checking if the write can succeed. If it subsequently fails, we
        // should remove that empty file.
        if (!result && remove)
            file->remove();
        return result;
    }
 
    return d->canWriteHelper();
}
 
extern void qt_imageTransform(QImage &src, QImageIOHandler::Transformations orient);
 
bool QImageWriter::write(const QImage &image)
{
    // Do this before canWrite, so it doesn't create a file if this fails.
    if (Q_UNLIKELY(image.isNull())) {
        d->imageWriterError = QImageWriter::InvalidImageError;
        d->errorString = QImageWriter::tr("Image is empty");
        return false;
    }
 
    if (!canWrite())
        return false;
 
    QImage img = image;
    if (d->handler->supportsOption(QImageIOHandler::Quality))
        d->handler->setOption(QImageIOHandler::Quality, d->quality);
    if (d->handler->supportsOption(QImageIOHandler::CompressionRatio))
        d->handler->setOption(QImageIOHandler::CompressionRatio, d->compression);
    if (d->handler->supportsOption(QImageIOHandler::Gamma))
        d->handler->setOption(QImageIOHandler::Gamma, d->gamma);
    if (!d->description.isEmpty() && d->handler->supportsOption(QImageIOHandler::Description))
        d->handler->setOption(QImageIOHandler::Description, d->description);
    if (!d->subType.isEmpty() && d->handler->supportsOption(QImageIOHandler::SubType))
        d->handler->setOption(QImageIOHandler::SubType, d->subType);
    if (d->handler->supportsOption(QImageIOHandler::OptimizedWrite))
        d->handler->setOption(QImageIOHandler::OptimizedWrite, d->optimizedWrite);
    if (d->handler->supportsOption(QImageIOHandler::ProgressiveScanWrite))
        d->handler->setOption(QImageIOHandler::ProgressiveScanWrite, d->progressiveScanWrite);
    if (d->handler->supportsOption(QImageIOHandler::ImageTransformation))
        d->handler->setOption(QImageIOHandler::ImageTransformation, int(d->transformation));
    else
        qt_imageTransform(img, d->transformation);
 
    if (!d->handler->write(img))
        return false;
    if (QFileDevice *file = qobject_cast<QFileDevice *>(d->device))
        file->flush();
    return true;
}
 
QImageWriter::ImageWriterError QImageWriter::error() const
{
    return d->imageWriterError;
}
 
QString QImageWriter::errorString() const
{
    return d->errorString;
}
 
bool QImageWriter::supportsOption(QImageIOHandler::ImageOption option) const
{
    if (!d->handler && (d->handler = createWriteHandlerHelper(d->device, d->format)) == nullptr) {
        d->imageWriterError = QImageWriter::UnsupportedFormatError;
        d->errorString = QImageWriter::tr("Unsupported image format");
        return false;
    }
 
    return d->handler->supportsOption(option);
}
 
QList<QByteArray> QImageWriter::supportedImageFormats()
{
    return QImageReaderWriterHelpers::supportedImageFormats(QImageReaderWriterHelpers::CanWrite);
}
 
QList<QByteArray> QImageWriter::supportedMimeTypes()
{
    return QImageReaderWriterHelpers::supportedMimeTypes(QImageReaderWriterHelpers::CanWrite);
}
 
QList<QByteArray> QImageWriter::imageFormatsForMimeType(const QByteArray &mimeType)
{
    return QImageReaderWriterHelpers::imageFormatsForMimeType(mimeType,
                                                              QImageReaderWriterHelpers::CanWrite);
}
 
QT_END_NAMESPACE