qimageiohandler.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 "qimageiohandler.h"
#include "qimage_p.h"
 
#include <qbytearray.h>
#include <qimagereader.h>
#include <qloggingcategory.h>
#include <qvariant.h>
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(lcImageIo, "qt.gui.imageio")
 
class QIODevice;
 
class QImageIOHandlerPrivate
{
    Q_DECLARE_PUBLIC(QImageIOHandler)
public:
    QImageIOHandlerPrivate(QImageIOHandler *q);
    virtual ~QImageIOHandlerPrivate();
 
    QIODevice *device;
    mutable QByteArray format;
 
    QImageIOHandler *q_ptr;
};
 
QImageIOHandlerPrivate::QImageIOHandlerPrivate(QImageIOHandler *q)
{
    device = nullptr;
    q_ptr = q;
}
 
QImageIOHandlerPrivate::~QImageIOHandlerPrivate()
{
}
 
QImageIOHandler::QImageIOHandler()
    : d_ptr(new QImageIOHandlerPrivate(this))
{
}
 
QImageIOHandler::QImageIOHandler(QImageIOHandlerPrivate &dd)
    : d_ptr(&dd)
{
}
 
QImageIOHandler::~QImageIOHandler()
{
}
 
void QImageIOHandler::setDevice(QIODevice *device)
{
    Q_D(QImageIOHandler);
    d->device = device;
}
 
QIODevice *QImageIOHandler::device() const
{
    Q_D(const QImageIOHandler);
    return d->device;
}
 
void QImageIOHandler::setFormat(const QByteArray &format)
{
    Q_D(QImageIOHandler);
    d->format = format;
}
 
void QImageIOHandler::setFormat(const QByteArray &format) const
{
    Q_D(const QImageIOHandler);
    d->format = format;
}
 
QByteArray QImageIOHandler::format() const
{
    Q_D(const QImageIOHandler);
    return d->format;
}
 
bool QImageIOHandler::write(const QImage &image)
{
    Q_UNUSED(image);
    return false;
}
 
void QImageIOHandler::setOption(ImageOption option, const QVariant &value)
{
    Q_UNUSED(option);
    Q_UNUSED(value);
}
 
QVariant QImageIOHandler::option(ImageOption option) const
{
    Q_UNUSED(option);
    return QVariant();
}
 
bool QImageIOHandler::supportsOption(ImageOption option) const
{
    Q_UNUSED(option);
    return false;
}
 
int QImageIOHandler::currentImageNumber() const
{
    return 0;
}
 
QRect QImageIOHandler::currentImageRect() const
{
    return QRect();
}
 
int QImageIOHandler::imageCount() const
{
    return canRead() ? 1 : 0;
}
 
bool QImageIOHandler::jumpToNextImage()
{
    return false;
}
 
bool QImageIOHandler::jumpToImage(int imageNumber)
{
    Q_UNUSED(imageNumber);
    return false;
}
 
int QImageIOHandler::loopCount() const
{
    return 0;
}
 
int QImageIOHandler::nextImageDelay() const
{
    return 0;
}
 
bool QImageIOHandler::allocateImage(QSize size, QImage::Format format, QImage *image)
{
    Q_ASSERT(image);
    if (size.isEmpty() || format <= QImage::Format_Invalid || format >= QImage::NImageFormats)
        return false;
 
    if (image->size() == size && image->format() == format) {
        image->detach();
    } else {
        if (const int mbLimit = QImageReader::allocationLimit()) {
            qsizetype depth = qMax(qt_depthForFormat(format), 32); // Effective gui depth = 32
            QImageData::ImageSizeParameters szp =
                    QImageData::calculateImageParameters(size.width(), size.height(), depth);
            if (!szp.isValid())
                return false;
            const qsizetype mb = szp.totalSize >> 20;
            if (mb > mbLimit || (mb == mbLimit && szp.totalSize % (1 << 20))) {
                qCWarning(lcImageIo, "QImageIOHandler: Rejecting image as it exceeds the current "
                                     "allocation limit of %i megabytes", mbLimit);
                return false;
            }
        }
        *image = QImage(size, format);
    }
    return !image->isNull();
}
 
#ifndef QT_NO_IMAGEFORMATPLUGIN
 
QImageIOPlugin::QImageIOPlugin(QObject *parent)
    : QObject(parent)
{
}
 
QImageIOPlugin::~QImageIOPlugin()
{
}
 
#endif // QT_NO_IMAGEFORMATPLUGIN
 
QT_END_NAMESPACE
 
#include "moc_qimageiohandler.cpp"