qwbmphandler.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
// Qt-Security score:critical reason:data-parser
 
#include "qwbmphandler_p.h"
 
/*!
    \class QWbmpHandler
    \since 5.0
    \brief The QWbmpHandler class provides support for the WBMP image format.
    \internal
*/
 
#include <qimage.h>
#include <qvariant.h>
 
QT_BEGIN_NAMESPACE
 
// This struct represents header of WBMP image file
struct WBMPHeader
{
    quint8 type;              // Type of WBMP image (always equal to 0)
    quint8 format;            // Format of WBMP image
    quint32 width;            // Width of the image already decoded from multibyte integer
    quint32 height;           // Height of the image already decoded from multibyte integer
};
#define WBMPFIXEDHEADER_SIZE 2
 
// Data renderers and writers which takes care of data alignment endiness and stuff
static bool readMultiByteInt(QIODevice *iodev, quint32 *num)
{
    quint32 res = 0;
 
    quint8 c;
    unsigned int count = 0;
    do {
        // Do not allow to read longer
        // then we can store in num
        if (++count > sizeof(*num))
            return false;
 
        if (!iodev->getChar(reinterpret_cast<char *>(&c)))
            return false;
 
        res = (res << 7) | (c & 0x7F);
 
    } while (c & 0x80);
 
    *num = res;
    return true;
}
 
static bool writeMultiByteInt(QIODevice *iodev, quint32 num)
{
    quint64 tmp = num & 0x7F;
    num >>= 7;
 
    while (num) {
        quint8 c = num & 0x7F;
        num = num >> 7;
        tmp = (tmp << 8) | (c | 0x80);
    }
 
    while (tmp) {
        quint8 c = tmp & 0xFF;
        if (!iodev->putChar(c))
            return false;
        tmp >>= 8;
    }
    return true;
}
 
static bool readWBMPHeader(QIODevice *iodev, WBMPHeader *hdr)
{
    if (!iodev)
        return false;
 
    uchar tmp[WBMPFIXEDHEADER_SIZE];
    if (iodev->read(reinterpret_cast<char *>(tmp), WBMPFIXEDHEADER_SIZE) == WBMPFIXEDHEADER_SIZE) {
        hdr->type = tmp[0];
        hdr->format = tmp[1];
    } else {
        return false;
    }
 
    if (readMultiByteInt(iodev, &hdr->width)
        && readMultiByteInt(iodev, &hdr->height)) {
        return true;
    }
    return false;
}
 
static bool writeWBMPHeader(QIODevice *iodev, const WBMPHeader &hdr)
{
    if (iodev) {
        uchar tmp[WBMPFIXEDHEADER_SIZE];
        tmp[0] = hdr.type;
        tmp[1] = hdr.format;
        if (iodev->write(reinterpret_cast<char *>(tmp),  WBMPFIXEDHEADER_SIZE) != WBMPFIXEDHEADER_SIZE)
            return false;
 
        if (writeMultiByteInt(iodev, hdr.width) &&
            writeMultiByteInt(iodev, hdr.height))
            return true;
    }
    return false;
}
 
static bool writeWBMPData(QIODevice *iodev, const QImage &image)
{
    if (iodev) {
        int h = image.height();
        int bpl = (image.width() + 7) / 8;
 
        for (int l=0; l<h; l++) {
            if (iodev->write(reinterpret_cast<const char *>(image.constScanLine(l)), bpl) != bpl)
                return false;
        }
        return true;
    }
    return false;
}
 
static bool readWBMPData(QIODevice *iodev, QImage &image)
{
    if (iodev) {
        int h = image.height();
        int bpl = (image.width() + 7) / 8;
 
        for (int l = 0; l < h; l++) {
            if (iodev->read(reinterpret_cast<char *>(image.scanLine(l)), bpl) != bpl)
                return false;
        }
        return true;
    }
    return false;
}
 
class WBMPReader
{
public:
    WBMPReader(QIODevice *iodevice);
 
    QImage readImage();
    bool writeImage(QImage image);
 
    static bool canRead(QIODevice *iodevice);
 
private:
    QIODevice *iodev;
    WBMPHeader hdr;
};
 
// WBMP common reader and writer implementation
WBMPReader::WBMPReader(QIODevice *iodevice) : iodev(iodevice)
{
    memset(&hdr, 0, sizeof(hdr));
}
 
QImage WBMPReader::readImage()
{
    if (!readWBMPHeader(iodev, &hdr))
        return QImage();
 
    QImage image;
    if (!QImageIOHandler::allocateImage(QSize(hdr.width, hdr.height), QImage::Format_Mono, &image))
        return QImage();
    if (!readWBMPData(iodev, image))
        return QImage();
 
    return image;
}
 
bool WBMPReader::writeImage(QImage image)
{
    if (image.format() != QImage::Format_Mono)
        image = image.convertToFormat(QImage::Format_Mono);
 
    if (image.colorTable().at(0) == image.colorTable().at(1)) {
        // degenerate image: actually blank.
        image.fill((qGray(image.colorTable().at(0)) < 128) ? 0 : 1);
    } else if (qGray(image.colorTable().at(0)) > qGray(image.colorTable().at(1))) {
        // Conform to WBMP's convention about black and white
        image.invertPixels();
    }
 
    hdr.type = 0;
    hdr.format = 0;
    hdr.width = image.width();
    hdr.height = image.height();
 
    if (!writeWBMPHeader(iodev, hdr))
        return false;
 
    if (!writeWBMPData(iodev, image))
        return false;
 
    return true;
}
 
bool WBMPReader::canRead(QIODevice *device)
{
    if (device) {
 
        if (device->isSequential())
            return false;
 
        // Save previous position
        qint64 oldPos = device->pos();
 
        WBMPHeader hdr;
        if (readWBMPHeader(device, &hdr)) {
            if ((hdr.type == 0) && (hdr.format == 0)) {
                const qint64 imageSize = hdr.height * ((qint64(hdr.width) + 7) / 8);
                qint64 available = device->bytesAvailable();
                device->seek(oldPos);
                return (imageSize == available);
            }
        }
        device->seek(oldPos);
    }
    return false;
}
 
/*!
    Constructs an instance of QWbmpHandler initialized to use \a device.
*/
QWbmpHandler::QWbmpHandler(QIODevice *device) :
    m_reader(new WBMPReader(device))
{
}
 
/*!
    Destructor for QWbmpHandler.
*/
QWbmpHandler::~QWbmpHandler()
{
    delete m_reader;
}
 
/*!
 * Verifies if some values (magic bytes) are set as expected in the header of the file.
 * If the magic bytes were found, it is assumed that the QWbmpHandler can read the file.
 */
bool QWbmpHandler::canRead() const
{
    bool bCanRead = false;
 
    QIODevice *device = QImageIOHandler::device();
    if (device) {
        bCanRead = QWbmpHandler::canRead(device);
        if (bCanRead)
            setFormat("wbmp");
 
    } else {
        qWarning("QWbmpHandler::canRead() called with no device");
    }
 
    return bCanRead;
}
 
/*! \reimp
*/
bool QWbmpHandler::read(QImage *image)
{
    QImage img = m_reader->readImage();
    if (img.isNull())
        return false;
    *image = std::move(img);
    return true;
}
 
/*! \reimp
*/
bool QWbmpHandler::write(const QImage &image)
{
    if (image.isNull())
        return false;
 
    return m_reader->writeImage(image);
}
 
/*!
    Only Size option is supported
*/
QVariant QWbmpHandler::option(ImageOption option) const
{
    if (option == QImageIOHandler::Size) {
        QIODevice *device = QImageIOHandler::device();
        if (device->isSequential())
            return QVariant();
 
        // Save old position
        qint64 oldPos = device->pos();
 
        WBMPHeader hdr;
        if (readWBMPHeader(device, &hdr)) {
            device->seek(oldPos);
            return QSize(hdr.width, hdr.height);
        }
 
        device->seek(oldPos);
 
    } else if (option == QImageIOHandler::ImageFormat) {
        return QVariant(QImage::Format_Mono);
    }
 
    return QVariant();
}
 
bool QWbmpHandler::supportsOption(ImageOption option) const
{
    return (option == QImageIOHandler::Size) ||
           (option == QImageIOHandler::ImageFormat);
}
 
bool QWbmpHandler::canRead(QIODevice *device)
{
    return WBMPReader::canRead(device);
}
 
QT_END_NAMESPACE