Source code
Revision control
Copy as Markdown
// 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
// Qt-Security score:significant reason:default
#include "qsvgiohandler.h"
#ifndef QT_NO_SVGRENDERER
#include "qsvgrenderer.h"
#include "private/qsvgdocument_p.h"
#include "qimage.h"
#include "qpixmap.h"
#include "qpainter.h"
#include "qvariant.h"
#include "qbuffer.h"
#include "qdebug.h"
QT_BEGIN_NAMESPACE
class QSvgIOHandlerPrivate
{
public:
QSvgIOHandlerPrivate(QSvgIOHandler *qq)
: q(qq)
{}
bool load(QIODevice *device);
QSvgIOHandler *q{nullptr};
QSvgRenderer r;
QXmlStreamReader xmlReader;
QSize defaultSize;
QRect clipRect;
QSize scaledSize;
QRect scaledClipRect;
bool loadAttempted{false};
bool loadStatus{false};
bool readDone{false};
int currentFrame{0};
int frameCount{0};
int frameDelay{0};
QColor backColor{Qt::transparent};
};
bool QSvgIOHandlerPrivate::load(QIODevice *device)
{
if (loadAttempted)
return loadStatus;
if (q->format().isEmpty())
q->canRead();
loadAttempted = true;
// # The SVG renderer doesn't handle trailing, unrelated data, so we must
// assume that all available data in the device is to be read.
bool res = false;
QBuffer *buf = qobject_cast<QBuffer *>(device);
if (buf) {
const QByteArray &ba = buf->data();
res = r.load(QByteArray::fromRawData(ba.constData() + buf->pos(), ba.size() - buf->pos()));
buf->seek(ba.size());
#ifndef QT_NO_COMPRESS
} else if (q->format() == "svgz") {
res = r.load(device->readAll());
#endif
} else {
xmlReader.setDevice(device);
res = r.load(&xmlReader);
}
if (res) {
defaultSize = r.defaultSize();
loadStatus = true;
if (r.animated()) {
const int duration = r.animationDuration();
const int fps = r.framesPerSecond();
frameCount = qMax(1, static_cast<int>(qint64(duration) * fps / 1000));
frameDelay = fps > 0 ? 1000 / fps : 0;
}
}
return loadStatus;
}
QSvgIOHandler::QSvgIOHandler()
: d(new QSvgIOHandlerPrivate(this))
{
}
QSvgIOHandler::~QSvgIOHandler()
{
delete d;
}
bool QSvgIOHandler::canRead() const
{
if (!device())
return false;
if (d->loadAttempted) {
if (!d->loadStatus)
return false;
if (d->r.animated())
return d->currentFrame < d->frameCount;
return !d->readDone;
}
// Not yet loaded — probe the device to determine format
bool isCompressed = false;
if (QSvgDocument::isLikelySvg(device(), &isCompressed)) {
setFormat(isCompressed ? "svgz" : "svg");
return true;
}
return false;
}
bool QSvgIOHandler::read(QImage *image)
{
if (!d->load(device()))
return false;
// For non-animated SVGs, preserve original single-read behavior
if (!d->r.animated()) {
if (d->readDone)
return false;
} else {
// For animated SVGs, set the current frame on the renderer
if (d->currentFrame >= d->frameCount)
return false;
d->r.setCurrentFrame(d->currentFrame);
}
bool xform = (d->clipRect.isValid() || d->scaledSize.isValid() || d->scaledClipRect.isValid());
QSize finalSize = d->defaultSize;
QRectF bounds;
if (xform && !d->defaultSize.isEmpty()) {
bounds = QRectF(QPointF(0,0), QSizeF(d->defaultSize));
QPoint tr1, tr2;
QSizeF sc(1, 1);
if (d->clipRect.isValid()) {
tr1 = -d->clipRect.topLeft();
finalSize = d->clipRect.size();
}
if (d->scaledSize.isValid()) {
sc = QSizeF(qreal(d->scaledSize.width()) / finalSize.width(),
qreal(d->scaledSize.height()) / finalSize.height());
finalSize = d->scaledSize;
}
if (d->scaledClipRect.isValid()) {
tr2 = -d->scaledClipRect.topLeft();
finalSize = d->scaledClipRect.size();
}
QTransform t;
t.translate(tr2.x(), tr2.y());
t.scale(sc.width(), sc.height());
t.translate(tr1.x(), tr1.y());
bounds = t.mapRect(bounds);
}
if (finalSize.isEmpty()) {
*image = QImage();
} else {
if (qMax(finalSize.width(), finalSize.height()) > 0xffff)
return false; // Assume corrupted file
if (!QImageIOHandler::allocateImage(finalSize, QImage::Format_ARGB32_Premultiplied, image))
return false;
image->fill(d->backColor.rgba());
QPainter p(image);
d->r.render(&p, bounds);
p.end();
}
d->readDone = true;
if (d->r.animated())
++d->currentFrame;
return true;
}
QVariant QSvgIOHandler::option(ImageOption option) const
{
switch(option) {
case ImageFormat:
return QImage::Format_ARGB32_Premultiplied;
break;
case Size:
d->load(device());
return d->defaultSize;
break;
case ClipRect:
return d->clipRect;
break;
case ScaledSize:
return d->scaledSize;
break;
case ScaledClipRect:
return d->scaledClipRect;
break;
case BackgroundColor:
return d->backColor;
break;
case Animation:
d->load(device());
return d->r.animated();
break;
default:
break;
}
return QVariant();
}
void QSvgIOHandler::setOption(ImageOption option, const QVariant & value)
{
switch(option) {
case ClipRect:
d->clipRect = value.toRect();
break;
case ScaledSize:
d->scaledSize = value.toSize();
break;
case ScaledClipRect:
d->scaledClipRect = value.toRect();
break;
case BackgroundColor:
d->backColor = value.value<QColor>();
break;
default:
break;
}
}
bool QSvgIOHandler::supportsOption(ImageOption option) const
{
switch(option)
{
case ImageFormat:
case Size:
case ClipRect:
case ScaledSize:
case ScaledClipRect:
case BackgroundColor:
case Animation:
return true;
default:
break;
}
return false;
}
bool QSvgIOHandler::jumpToNextImage()
{
return jumpToImage(d->currentFrame + 1);
}
bool QSvgIOHandler::jumpToImage(int imageNumber)
{
if (!d->load(device()) || !d->r.animated())
return false;
if (imageNumber < 0 || imageNumber >= d->frameCount)
return false;
d->currentFrame = imageNumber;
return true;
}
int QSvgIOHandler::loopCount() const
{
return 0;
}
int QSvgIOHandler::imageCount() const
{
if (!d->load(device()))
return 0;
if (d->r.animated())
return d->frameCount;
return 1;
}
int QSvgIOHandler::nextImageDelay() const
{
if (d->load(device()) && d->r.animated())
return d->frameDelay;
return 0;
}
int QSvgIOHandler::currentImageNumber() const
{
if (d->load(device()) && d->r.animated())
return d->currentFrame - 1; // currentFrame is the *next* frame to read
return 0;
}
bool QSvgIOHandler::canRead(QIODevice *device)
{
return QSvgDocument::isLikelySvg(device);
}
QT_END_NAMESPACE
#endif // QT_NO_SVGRENDERER