qimagereader.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
 
//#define QIMAGEREADER_DEBUG
 
#include "qimagereader.h"
 
#include <qbytearray.h>
#ifdef QIMAGEREADER_DEBUG
#include <qdebug.h>
#endif
#include <qfile.h>
#include <qfileinfo.h>
#include <qimage.h>
#include <qimageiohandler.h>
#include <qlist.h>
#include <qrect.h>
#include <qsize.h>
#include <qcolor.h>
#include <qvariant.h>
 
// factory loader
#include <qcoreapplication.h>
#include <private/qfactoryloader_p.h>
#include <QtCore/private/qlocking_p.h>
 
// for qt_getImageText
#include <private/qimage_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 <qtgui_tracepoints_p.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
using namespace QImageReaderWriterHelpers;
using namespace Qt::StringLiterals;
 
Q_TRACE_POINT(qtgui, QImageReader_read_before_reading, QImageReader *reader, const QString &filename);
Q_TRACE_POINT(qtgui, QImageReader_read_after_reading, QImageReader *reader, bool result);
 
static QImageIOHandler *createReadHandlerHelper(QIODevice *device,
                                                const QByteArray &format,
                                                bool autoDetectImageFormat,
                                                bool ignoresFormatAndExtension)
{
    if (!autoDetectImageFormat && format.isEmpty())
        return nullptr;
 
    QByteArray form = format.toLower();
    QImageIOHandler *handler = nullptr;
    QByteArray suffix;
 
#ifndef QT_NO_IMAGEFORMATPLUGIN
    Q_CONSTINIT static QBasicMutex mutex;
    const auto locker = qt_scoped_lock(mutex);
 
    typedef QMultiMap<int, QString> PluginKeyMap;
 
    // check if we have plugins that support the image format
    auto l = QImageReaderWriterHelpers::pluginLoader();
    const PluginKeyMap keyMap = l->keyMap();
 
#ifdef QIMAGEREADER_DEBUG
    qDebug() << "QImageReader::createReadHandler( device =" << (void *)device << ", format =" << format << "),"
             << keyMap.uniqueKeys().size() << "plugins available: " << keyMap;
#endif
 
    int suffixPluginIndex = -1;
#endif // QT_NO_IMAGEFORMATPLUGIN
 
    if (device && format.isEmpty() && autoDetectImageFormat && !ignoresFormatAndExtension) {
        // 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 (QFile *file = qobject_cast<QFile *>(device)) {
#ifdef QIMAGEREADER_DEBUG
            qDebug() << "QImageReader::createReadHandler: device is a file:" << file->fileName();
#endif
            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) {
#ifdef QIMAGEREADER_DEBUG
                    qDebug() << "QImageReader::createReadHandler: suffix recognized; the"
                             << suffix << "plugin might be able to read this";
#endif
                    suffixPluginIndex = index;
                }
#endif // QT_NO_IMAGEFORMATPLUGIN
            }
        }
    }
 
    QByteArray testFormat = !form.isEmpty() ? form : suffix;
 
    if (ignoresFormatAndExtension)
        testFormat = QByteArray();
 
#ifndef QT_NO_IMAGEFORMATPLUGIN
    if (suffixPluginIndex != -1) {
        // check if the plugin that claims support for this format can load
        // from this device with this format.
        const qint64 pos = device ? device->pos() : 0;
        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, testFormat) & QImageIOPlugin::CanRead) {
                handler = plugin->create(device, testFormat);
#ifdef QIMAGEREADER_DEBUG
                qDebug() << "QImageReader::createReadHandler: using the" << suffix
                         << "plugin";
#endif
            }
        }
        if (device && !device->isSequential())
            device->seek(pos);
    }
 
    if (!handler && !testFormat.isEmpty() && !ignoresFormatAndExtension) {
        // check if any plugin supports the format (they are not allowed to
        // read from the device yet).
        const qint64 pos = device ? device->pos() : 0;
 
        if (autoDetectImageFormat) {
            const int keyCount = keyMap.size();
            for (int i = 0; i < keyCount; ++i) {
                if (i != suffixPluginIndex) {
                    QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(i));
                    if (plugin && plugin->capabilities(device, testFormat) & QImageIOPlugin::CanRead) {
#ifdef QIMAGEREADER_DEBUG
                        qDebug() << "QImageReader::createReadHandler: the" << keyMap.keys().at(i) << "plugin can read this format";
#endif
                        handler = plugin->create(device, testFormat);
                        break;
                    }
                }
            }
        } else {
            const int testIndex = keyMap.key(QLatin1StringView(testFormat), -1);
            if (testIndex != -1) {
                QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(testIndex));
                if (plugin && plugin->capabilities(device, testFormat) & QImageIOPlugin::CanRead) {
#ifdef QIMAGEREADER_DEBUG
                    qDebug() << "QImageReader::createReadHandler: the" << testFormat << "plugin can read this format";
#endif
                    handler = plugin->create(device, testFormat);
                }
            }
        }
        if (device && !device->isSequential())
            device->seek(pos);
    }
 
#endif // QT_NO_IMAGEFORMATPLUGIN
 
    // if we don't have a handler yet, check if we have built-in support for
    // the format
    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
        }
 
#ifdef QIMAGEREADER_DEBUG
        if (handler)
            qDebug() << "QImageReader::createReadHandler: using the built-in handler for" << testFormat;
#endif
    }
 
    if (handler && device && !suffix.isEmpty()) {
        Q_ASSERT(qobject_cast<QFile *>(device));
        // We have a file claiming to be of a recognized format. Now confirm that
        // the handler also recognizes the file contents.
        const qint64 pos = device->pos();
        handler->setDevice(device);
        if (!form.isEmpty())
            handler->setFormat(form);
        bool canRead = handler->canRead();
        device->seek(pos);
        if (canRead) {
            // ok, we're done.
            return handler;
        }
#ifdef QIMAGEREADER_DEBUG
        qDebug() << "QImageReader::createReadHandler: the" << suffix << "handler can not read this file";
#endif
        // File may still be valid, just with wrong suffix, so fall back to
        // finding a handler based on contents, below.
        delete handler;
        handler = nullptr;
    }
 
#ifndef QT_NO_IMAGEFORMATPLUGIN
    if (!handler && (autoDetectImageFormat || ignoresFormatAndExtension)) {
        // check if any of our plugins recognize the file from its contents.
        const qint64 pos = device ? device->pos() : 0;
        const int keyCount = keyMap.size();
        for (int i = 0; i < keyCount; ++i) {
            if (i != suffixPluginIndex) {
                QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(i));
                if (plugin && plugin->capabilities(device, QByteArray()) & QImageIOPlugin::CanRead) {
                    handler = plugin->create(device, testFormat);
#ifdef QIMAGEREADER_DEBUG
                    qDebug() << "QImageReader::createReadHandler: the" << keyMap.value(i) << "plugin can read this data";
#endif
                    break;
                }
            }
        }
        if (device && !device->isSequential())
            device->seek(pos);
    }
#endif // QT_NO_IMAGEFORMATPLUGIN
 
    if (!handler && (autoDetectImageFormat || ignoresFormatAndExtension)) {
        // check if any of our built-in handlers recognize the file from its
        // contents.
        int currentFormat = 0;
        if (!suffix.isEmpty()) {
            // If reading from a file with a suffix, start testing our
            // built-in handler for that suffix first.
            for (int i = 0; i < _qt_NumFormats; ++i) {
                if (_qt_BuiltInFormats[i].extension == suffix) {
                    currentFormat = i;
                    break;
                }
            }
        }
 
        QByteArray subType;
        int numFormats = _qt_NumFormats;
        while (device && numFormats >= 0) {
            const qint64 pos = device->pos();
            switch (currentFormat) {
#ifndef QT_NO_IMAGEFORMAT_PNG
            case _qt_PngFormat:
                if (QPngHandler::canRead(device))
                    handler = new QPngHandler;
                break;
#endif
#ifndef QT_NO_IMAGEFORMAT_BMP
            case _qt_BmpFormat:
                if (QBmpHandler::canRead(device))
                    handler = new QBmpHandler;
                break;
#endif
#ifndef QT_NO_IMAGEFORMAT_XPM
            case _qt_XpmFormat:
                if (QXpmHandler::canRead(device))
                    handler = new QXpmHandler;
                break;
#endif
#ifndef QT_NO_IMAGEFORMAT_PPM
            case _qt_PbmFormat:
            case _qt_PgmFormat:
            case _qt_PpmFormat:
                if (QPpmHandler::canRead(device, &subType)) {
                    handler = new QPpmHandler;
                    handler->setOption(QImageIOHandler::SubType, subType);
                }
                break;
#endif
#ifndef QT_NO_IMAGEFORMAT_XBM
            case _qt_XbmFormat:
                if (QXbmHandler::canRead(device))
                    handler = new QXbmHandler;
                break;
#endif
            default:
                break;
            }
            if (!device->isSequential())
                device->seek(pos);
 
            if (handler) {
#ifdef QIMAGEREADER_DEBUG
                qDebug("QImageReader::createReadHandler: the %s built-in handler can read this data",
                       _qt_BuiltInFormats[currentFormat].extension);
#endif
                break;
            }
 
            --numFormats;
            ++currentFormat;
            if (currentFormat >= _qt_NumFormats)
                currentFormat = 0;
        }
    }
 
    if (!handler) {
#ifdef QIMAGEREADER_DEBUG
        qDebug("QImageReader::createReadHandler: no handlers found. giving up.");
#endif
        // no handler: give up.
        return nullptr;
    }
 
    handler->setDevice(device);
    if (!form.isEmpty())
        handler->setFormat(form);
    return handler;
}
 
class QImageReaderPrivate
{
public:
    QImageReaderPrivate(QImageReader *qq);
    ~QImageReaderPrivate();
 
    // device
    QByteArray format;
    bool autoDetectImageFormat;
    bool ignoresFormatAndExtension;
    QIODevice *device;
    bool deleteDevice;
    QImageIOHandler *handler;
    bool initHandler();
 
    // image options
    QRect clipRect;
    QSize scaledSize;
    QRect scaledClipRect;
    int quality;
    QMap<QString, QString> text;
    void getText();
    enum {
        UsePluginDefault,
        ApplyTransform,
        DoNotApplyTransform
    } autoTransform;
 
    // error
    QImageReader::ImageReaderError imageReaderError;
    QString errorString;
 
    QImageReader *q;
 
    static int maxAlloc;
};
 
int QImageReaderPrivate::maxAlloc = 256; // 256 MB is enough for an 8K 64bpp image
 
QImageReaderPrivate::QImageReaderPrivate(QImageReader *qq)
    : autoDetectImageFormat(true), ignoresFormatAndExtension(false)
{
    device = nullptr;
    deleteDevice = false;
    handler = nullptr;
    quality = -1;
    imageReaderError = QImageReader::UnknownError;
    autoTransform = UsePluginDefault;
 
    q = qq;
}
 
QImageReaderPrivate::~QImageReaderPrivate()
{
    delete handler;
    if (deleteDevice)
        delete device;
}
 
bool QImageReaderPrivate::initHandler()
{
    if (handler)
        return true;
 
    // check some preconditions
    if (!device || (!deleteDevice && !device->isOpen() && !device->open(QIODevice::ReadOnly))) {
        imageReaderError = QImageReader::DeviceError;
        errorString = QImageReader::tr("Invalid device");
        return false;
    }
 
    // probe the file extension
    if (deleteDevice && !device->isOpen() && !device->open(QIODevice::ReadOnly) && autoDetectImageFormat) {
        Q_ASSERT(qobject_cast<QFile*>(device) != nullptr); // future-proofing; for now this should always be the case, so...
        QFile *file = static_cast<QFile *>(device);
 
        if (file->error() == QFileDevice::ResourceError) {
            // this is bad. we should abort the open attempt and note the failure.
            imageReaderError = QImageReader::DeviceError;
            errorString = file->errorString();
            return false;
        }
 
        QList<QByteArray> extensions = QImageReader::supportedImageFormats();
        if (!format.isEmpty()) {
            // Try the most probable extension first
            int currentFormatIndex = extensions.indexOf(format.toLower());
            if (currentFormatIndex > 0)
                extensions.swapItemsAt(0, currentFormatIndex);
        }
 
        int currentExtension = 0;
 
        QString fileName = file->fileName();
 
        do {
            file->setFileName(fileName + u'.'
                    + QLatin1StringView(extensions.at(currentExtension++).constData()));
            file->open(QIODevice::ReadOnly);
        } while (!file->isOpen() && currentExtension < extensions.size());
 
        if (!device->isOpen()) {
            imageReaderError = QImageReader::FileNotFoundError;
            errorString = QImageReader::tr("File not found");
            file->setFileName(fileName); // restore the old file name
            return false;
        }
    }
 
    // assign a handler
    if ((handler = createReadHandlerHelper(device, format, autoDetectImageFormat, ignoresFormatAndExtension)) == nullptr) {
        imageReaderError = QImageReader::UnsupportedFormatError;
        errorString = QImageReader::tr("Unsupported image format");
        return false;
    }
    return true;
}
 
void QImageReaderPrivate::getText()
{
    if (text.isEmpty() && initHandler() && handler->supportsOption(QImageIOHandler::Description))
        text = qt_getImageTextFromDescription(handler->option(QImageIOHandler::Description).toString());
}
 
QImageReader::QImageReader()
    : d(new QImageReaderPrivate(this))
{
}
 
QImageReader::QImageReader(QIODevice *device, const QByteArray &format)
    : d(new QImageReaderPrivate(this))
{
    d->device = device;
    d->format = format;
}
 
QImageReader::QImageReader(const QString &fileName, const QByteArray &format)
    : QImageReader(new QFile(fileName), format)
{
    d->deleteDevice = true;
}
 
QImageReader::~QImageReader()
{
    delete d;
}
 
void QImageReader::setFormat(const QByteArray &format)
{
    d->format = format;
}
 
QByteArray QImageReader::format() const
{
    if (d->format.isEmpty()) {
        if (!d->initHandler())
            return QByteArray();
        return d->handler->canRead() ? d->handler->format() : QByteArray();
    }
 
    return d->format;
}
 
void QImageReader::setAutoDetectImageFormat(bool enabled)
{
    d->autoDetectImageFormat = enabled;
}
 
bool QImageReader::autoDetectImageFormat() const
{
    return d->autoDetectImageFormat;
}
 
 
void QImageReader::setDecideFormatFromContent(bool ignored)
{
    d->ignoresFormatAndExtension = ignored;
}
 
 
bool QImageReader::decideFormatFromContent() const
{
    return d->ignoresFormatAndExtension;
}
 
 
void QImageReader::setDevice(QIODevice *device)
{
    delete d->handler;
    d->handler = nullptr;
    if (d->device && d->deleteDevice)
        delete d->device;
    d->device = device;
    d->deleteDevice = false;
    d->text.clear();
}
 
QIODevice *QImageReader::device() const
{
    return d->device;
}
 
void QImageReader::setFileName(const QString &fileName)
{
    setDevice(new QFile(fileName));
    d->deleteDevice = true;
}
 
QString QImageReader::fileName() const
{
    QFile *file = qobject_cast<QFile *>(d->device);
    return file ? file->fileName() : QString();
}
 
void QImageReader::setQuality(int quality)
{
    d->quality = quality;
}
 
int QImageReader::quality() const
{
    return d->quality;
}
 
 
QSize QImageReader::size() const
{
    if (!d->initHandler())
        return QSize();
 
    if (d->handler->supportsOption(QImageIOHandler::Size))
        return d->handler->option(QImageIOHandler::Size).toSize();
 
    return QSize();
}
 
QImage::Format QImageReader::imageFormat() const
{
    if (!d->initHandler())
        return QImage::Format_Invalid;
 
    if (d->handler->supportsOption(QImageIOHandler::ImageFormat))
        return (QImage::Format)d->handler->option(QImageIOHandler::ImageFormat).toInt();
 
    return QImage::Format_Invalid;
}
 
QStringList QImageReader::textKeys() const
{
    d->getText();
    return d->text.keys();
}
 
QString QImageReader::text(const QString &key) const
{
    d->getText();
    return d->text.value(key);
}
 
void QImageReader::setClipRect(const QRect &rect)
{
    d->clipRect = rect;
}
 
QRect QImageReader::clipRect() const
{
    return d->clipRect;
}
 
void QImageReader::setScaledSize(const QSize &size)
{
    d->scaledSize = size;
}
 
QSize QImageReader::scaledSize() const
{
    return d->scaledSize;
}
 
void QImageReader::setScaledClipRect(const QRect &rect)
{
    d->scaledClipRect = rect;
}
 
QRect QImageReader::scaledClipRect() const
{
    return d->scaledClipRect;
}
 
void QImageReader::setBackgroundColor(const QColor &color)
{
    if (!d->initHandler())
        return;
    if (d->handler->supportsOption(QImageIOHandler::BackgroundColor))
        d->handler->setOption(QImageIOHandler::BackgroundColor, color);
}
 
QColor QImageReader::backgroundColor() const
{
    if (!d->initHandler())
        return QColor();
    if (d->handler->supportsOption(QImageIOHandler::BackgroundColor))
        return qvariant_cast<QColor>(d->handler->option(QImageIOHandler::BackgroundColor));
    return QColor();
}
 
bool QImageReader::supportsAnimation() const
{
    if (!d->initHandler())
        return false;
    if (d->handler->supportsOption(QImageIOHandler::Animation))
        return d->handler->option(QImageIOHandler::Animation).toBool();
    return false;
}
 
QByteArray QImageReader::subType() const
{
    if (!d->initHandler())
        return QByteArray();
 
    if (d->handler->supportsOption(QImageIOHandler::SubType))
        return d->handler->option(QImageIOHandler::SubType).toByteArray();
    return QByteArray();
}
 
QList<QByteArray> QImageReader::supportedSubTypes() const
{
    if (!d->initHandler())
        return QList<QByteArray>();
 
    if (d->handler->supportsOption(QImageIOHandler::SupportedSubTypes))
        return qvariant_cast<QList<QByteArray> >(d->handler->option(QImageIOHandler::SupportedSubTypes));
    return QList<QByteArray>();
}
 
QImageIOHandler::Transformations QImageReader::transformation() const
{
    int option = QImageIOHandler::TransformationNone;
    if (d->initHandler() && d->handler->supportsOption(QImageIOHandler::ImageTransformation))
        option = d->handler->option(QImageIOHandler::ImageTransformation).toInt();
    return QImageIOHandler::Transformations(option);
}
 
void QImageReader::setAutoTransform(bool enabled)
{
    d->autoTransform = enabled ? QImageReaderPrivate::ApplyTransform
                               : QImageReaderPrivate::DoNotApplyTransform;
}
 
bool QImageReader::autoTransform() const
{
    switch (d->autoTransform) {
    case QImageReaderPrivate::ApplyTransform:
        return true;
    case QImageReaderPrivate::DoNotApplyTransform:
        return false;
    case QImageReaderPrivate::UsePluginDefault:
        Q_FALLTHROUGH();
    default:
        break;
    }
    return false;
}
 
bool QImageReader::canRead() const
{
    if (!d->initHandler())
        return false;
 
    return d->handler->canRead();
}
 
QImage QImageReader::read()
{
    // Because failed image reading might have side effects, we explicitly
    // return a null image instead of the image we've just created.
    QImage image;
    return read(&image) ? image : QImage();
}
 
extern void qt_imageTransform(QImage &src, QImageIOHandler::Transformations orient);
 
bool QImageReader::read(QImage *image)
{
    if (!image) {
        qWarning("QImageReader::read: cannot read into null pointer");
        return false;
    }
 
    if (!d->initHandler())
        return false;
 
    // set the handler specific options.
    if (d->handler->supportsOption(QImageIOHandler::ScaledSize) && d->scaledSize.isValid()) {
        if ((d->handler->supportsOption(QImageIOHandler::ClipRect) && !d->clipRect.isNull())
            || d->clipRect.isNull()) {
            // Only enable the ScaledSize option if there is no clip rect, or
            // if the handler also supports ClipRect.
            d->handler->setOption(QImageIOHandler::ScaledSize, d->scaledSize);
        }
    }
    if (d->handler->supportsOption(QImageIOHandler::ClipRect) && !d->clipRect.isNull())
        d->handler->setOption(QImageIOHandler::ClipRect, d->clipRect);
    if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull())
        d->handler->setOption(QImageIOHandler::ScaledClipRect, d->scaledClipRect);
    if (d->handler->supportsOption(QImageIOHandler::Quality))
        d->handler->setOption(QImageIOHandler::Quality, d->quality);
 
    // read the image
    QString filename = fileName();
    if (Q_TRACE_ENABLED(QImageReader_read_before_reading)) {
        Q_TRACE(QImageReader_read_before_reading, this, filename.isEmpty() ? u"unknown"_s : filename);
    }
 
    const bool result = d->handler->read(image);
 
    Q_TRACE(QImageReader_read_after_reading, this, result);
 
    if (!result) {
        d->imageReaderError = InvalidDataError;
        d->errorString = QImageReader::tr("Unable to read image data");
        return false;
    }
 
    // provide default implementations for any unsupported image
    // options
    if (d->handler->supportsOption(QImageIOHandler::ClipRect) && !d->clipRect.isNull()) {
        if (d->handler->supportsOption(QImageIOHandler::ScaledSize) && d->scaledSize.isValid()) {
            if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {
                // all features are supported by the handler; nothing to do.
            } else {
                // the image is already scaled, so apply scaled clipping.
                if (!d->scaledClipRect.isNull())
                    *image = image->copy(d->scaledClipRect);
            }
        } else {
            if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {
                // supports scaled clipping but not scaling, most
                // likely a broken handler.
            } else {
                if (d->scaledSize.isValid()) {
                    *image = image->scaled(d->scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
                }
                if (d->scaledClipRect.isValid()) {
                    *image = image->copy(d->scaledClipRect);
                }
            }
        }
    } else {
        if (d->handler->supportsOption(QImageIOHandler::ScaledSize) && d->scaledSize.isValid() && d->clipRect.isNull()) {
            if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {
                // nothing to do (ClipRect is ignored!)
            } else {
                // provide all workarounds.
                if (d->scaledClipRect.isValid()) {
                    *image = image->copy(d->scaledClipRect);
                }
            }
        } else {
            if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {
                // this makes no sense; a handler that supports
                // ScaledClipRect but not ScaledSize is broken, and we
                // can't work around it.
            } else {
                // provide all workarounds.
                if (d->clipRect.isValid())
                    *image = image->copy(d->clipRect);
                if (d->scaledSize.isValid())
                    *image = image->scaled(d->scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
                if (d->scaledClipRect.isValid())
                    *image = image->copy(d->scaledClipRect);
            }
        }
    }
 
    // successful read; check for "@Nx" file name suffix and set device pixel ratio.
    static bool disableNxImageLoading = !qEnvironmentVariableIsEmpty("QT_HIGHDPI_DISABLE_2X_IMAGE_LOADING");
    if (!disableNxImageLoading) {
        const QByteArray suffix = QFileInfo(filename).baseName().right(3).toLatin1();
        if (suffix.size() == 3 && suffix[0] == '@' && suffix[1] >= '2' && suffix[1] <= '9' && suffix[2] == 'x')
            image->setDevicePixelRatio(suffix[1] - '0');
    }
    if (autoTransform())
        qt_imageTransform(*image, transformation());
 
    return true;
}
 
bool QImageReader::jumpToNextImage()
{
    if (!d->initHandler())
        return false;
    return d->handler->jumpToNextImage();
}
 
bool QImageReader::jumpToImage(int imageNumber)
{
    if (!d->initHandler())
        return false;
    return d->handler->jumpToImage(imageNumber);
}
 
int QImageReader::loopCount() const
{
    if (!d->initHandler())
        return -1;
    return d->handler->loopCount();
}
 
int QImageReader::imageCount() const
{
    if (!d->initHandler())
        return -1;
    return d->handler->imageCount();
}
 
int QImageReader::nextImageDelay() const
{
    if (!d->initHandler())
        return -1;
    return d->handler->nextImageDelay();
}
 
int QImageReader::currentImageNumber() const
{
    if (!d->initHandler())
        return -1;
    return d->handler->currentImageNumber();
}
 
QRect QImageReader::currentImageRect() const
{
    if (!d->initHandler())
        return QRect();
    return d->handler->currentImageRect();
}
 
QImageReader::ImageReaderError QImageReader::error() const
{
    return d->imageReaderError;
}
 
QString QImageReader::errorString() const
{
    if (d->errorString.isEmpty())
        return QImageReader::tr("Unknown error");
    return d->errorString;
}
 
bool QImageReader::supportsOption(QImageIOHandler::ImageOption option) const
{
    if (!d->initHandler())
        return false;
    return d->handler->supportsOption(option);
}
 
QByteArray QImageReader::imageFormat(const QString &fileName)
{
    QFile file(fileName);
    if (!file.open(QFile::ReadOnly))
        return QByteArray();
 
    return imageFormat(&file);
}
 
QByteArray QImageReader::imageFormat(QIODevice *device)
{
    QByteArray format;
    QImageIOHandler *handler = createReadHandlerHelper(device, format, /* autoDetectImageFormat = */ true, false);
    if (handler) {
        if (handler->canRead())
            format = handler->format();
        delete handler;
    }
    return format;
}
 
QList<QByteArray> QImageReader::supportedImageFormats()
{
    return QImageReaderWriterHelpers::supportedImageFormats(QImageReaderWriterHelpers::CanRead);
}
 
QList<QByteArray> QImageReader::supportedMimeTypes()
{
    return QImageReaderWriterHelpers::supportedMimeTypes(QImageReaderWriterHelpers::CanRead);
}
 
QList<QByteArray> QImageReader::imageFormatsForMimeType(const QByteArray &mimeType)
{
    return QImageReaderWriterHelpers::imageFormatsForMimeType(mimeType,
                                                              QImageReaderWriterHelpers::CanRead);
}
 
int QImageReader::allocationLimit()
{
    static int envLimit = []() {
        bool ok = false;
        int res = qEnvironmentVariableIntValue("QT_IMAGEIO_MAXALLOC", &ok);
        return ok ? res : -1;
    }();
 
    return envLimit >= 0 ? envLimit : QImageReaderPrivate::maxAlloc;
}
 
void QImageReader::setAllocationLimit(int mbLimit)
{
    if (mbLimit >= 0)
        QImageReaderPrivate::maxAlloc = mbLimit;
}
 
QT_END_NAMESPACE