qbmphandler.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 "private/qbmphandler_p.h"
 
#ifndef QT_NO_IMAGEFORMAT_BMP
 
#include <qimage.h>
#include <qlist.h>
#include <qvariant.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
static void swapPixel01(QImage *image)        // 1-bpp: swap 0 and 1 pixels
{
    qsizetype i;
    if (image->depth() == 1 && image->colorCount() == 2) {
        uint *p = (uint *)image->bits();
        qsizetype nbytes = static_cast<qsizetype>(image->sizeInBytes());
        for (i=0; i<nbytes/4; i++) {
            *p = ~*p;
            p++;
        }
        uchar *p2 = (uchar *)p;
        for (i=0; i<(nbytes&3); i++) {
            *p2 = ~*p2;
            p2++;
        }
        QRgb t = image->color(0);                // swap color 0 and 1
        image->setColor(0, image->color(1));
        image->setColor(1, t);
    }
}
 
/*
    QImageIO::defineIOHandler("BMP", "^BM", 0,
                               read_bmp_image, write_bmp_image);
*/
 
/*****************************************************************************
  BMP (DIB) image read/write functions
 *****************************************************************************/
 
const int BMP_FILEHDR_SIZE = 14;                // size of BMP_FILEHDR data
 
static QDataStream &operator>>(QDataStream &s, BMP_FILEHDR &bf)
{                                                // read file header
    s.readRawData(bf.bfType, 2);
    s >> bf.bfSize >> bf.bfReserved1 >> bf.bfReserved2 >> bf.bfOffBits;
    return s;
}
 
static QDataStream &operator<<(QDataStream &s, const BMP_FILEHDR &bf)
{                                                // write file header
    s.writeRawData(bf.bfType, 2);
    s << bf.bfSize << bf.bfReserved1 << bf.bfReserved2 << bf.bfOffBits;
    return s;
}
 
 
const int BMP_OLD  = 12;                        // old Windows/OS2 BMP size
const int BMP_WIN  = 40;                        // Windows BMP v3 size
const int BMP_OS2  = 64;                        // new OS/2 BMP size
const int BMP_WIN4 = 108;                       // Windows BMP v4 size
const int BMP_WIN5 = 124;                       // Windows BMP v5 size
 
const int BMP_RGB  = 0;                                // no compression
const int BMP_RLE8 = 1;                                // run-length encoded, 8 bits
const int BMP_RLE4 = 2;                                // run-length encoded, 4 bits
const int BMP_BITFIELDS = 3;                        // RGB values encoded in data as bit-fields
const int BMP_ALPHABITFIELDS = 4;                   // RGBA values encoded in data as bit-fields
 
 
static QDataStream &operator>>(QDataStream &s, BMP_INFOHDR &bi)
{
    s >> bi.biSize;
    if (bi.biSize == BMP_WIN || bi.biSize == BMP_OS2 || bi.biSize == BMP_WIN4 || bi.biSize == BMP_WIN5) {
        s >> bi.biWidth >> bi.biHeight >> bi.biPlanes >> bi.biBitCount;
        s >> bi.biCompression >> bi.biSizeImage;
        s >> bi.biXPelsPerMeter >> bi.biYPelsPerMeter;
        s >> bi.biClrUsed >> bi.biClrImportant;
        if (bi.biSize >= BMP_WIN4) {
            s >> bi.biRedMask >> bi.biGreenMask >> bi.biBlueMask >> bi.biAlphaMask;
            s >> bi.biCSType;
            for (int i = 0; i < 9; ++i)
                s >> bi.biEndpoints[i];
            s >> bi.biGammaRed >> bi.biGammaGreen >> bi.biGammaBlue;
            if (bi.biSize == BMP_WIN5)
                s >> bi.biIntent >> bi.biProfileData >> bi.biProfileSize >> bi.biReserved;
        }
    }
    else {                                        // probably old Windows format
        qint16 w, h;
        s >> w >> h >> bi.biPlanes >> bi.biBitCount;
        bi.biWidth  = w;
        bi.biHeight = h;
        bi.biCompression = BMP_RGB;                // no compression
        bi.biSizeImage = 0;
        bi.biXPelsPerMeter = bi.biYPelsPerMeter = 0;
        bi.biClrUsed = bi.biClrImportant = 0;
    }
    return s;
}
 
static QDataStream &operator<<(QDataStream &s, const BMP_INFOHDR &bi)
{
    s << bi.biSize;
    s << bi.biWidth << bi.biHeight;
    s << bi.biPlanes;
    s << bi.biBitCount;
    s << bi.biCompression;
    s << bi.biSizeImage;
    s << bi.biXPelsPerMeter << bi.biYPelsPerMeter;
    s << bi.biClrUsed << bi.biClrImportant;
 
    if (bi.biSize >= BMP_WIN4) {
        s << bi.biRedMask << bi.biGreenMask << bi.biBlueMask << bi.biAlphaMask;
        s << bi.biCSType;
 
        for (int i = 0; i < 9; i++)
            s << bi.biEndpoints[i];
 
        s << bi.biGammaRed;
        s << bi.biGammaGreen;
        s << bi.biGammaBlue;
    }
 
    if (bi.biSize >= BMP_WIN5) {
        s << bi.biIntent;
        s << bi.biProfileData;
        s << bi.biProfileSize;
        s << bi.biReserved;
    }
 
    return s;
}
 
static uint calc_shift(uint mask)
{
    uint result = 0;
    while ((mask >= 0x100) || (!(mask & 1) && mask)) {
        result++;
        mask >>= 1;
    }
    return result;
}
 
static uint calc_scale(uint low_mask)
{
    uint result = 8;
    while (low_mask && result) {
        result--;
        low_mask >>= 1;
    }
    return result;
}
 
static inline uint apply_scale(uint value, uint scale)
{
    if (!(scale & 0x07)) // return immediately if scale == 8 or 0
        return value;
 
    uint filled = 8 - scale;
    uint result = value << scale;
 
    do {
        result |= result >> filled;
        filled <<= 1;
    } while (filled < 8);
 
    return result;
}
 
static bool read_dib_fileheader(QDataStream &s, BMP_FILEHDR &bf)
{
    // read BMP file header
    if (!(s >> bf))
        return false;
 
    // check header
    if (qstrncmp(bf.bfType,"BM",2) != 0)
        return false;
 
    return true;
}
 
static bool read_dib_infoheader(QDataStream &s, BMP_INFOHDR &bi)
{
    if (!(s >> bi))                                       // read BMP info header
        return false;
 
    int nbits = bi.biBitCount;
    int comp = bi.biCompression;
    if (!(nbits == 1 || nbits == 4 || nbits == 8 || nbits == 16 || nbits == 24 || nbits == 32) ||
        bi.biPlanes != 1 || comp > BMP_BITFIELDS)
        return false;                                        // weird BMP image
    if (!(comp == BMP_RGB || (nbits == 4 && comp == BMP_RLE4) ||
        (nbits == 8 && comp == BMP_RLE8) || ((nbits == 16 || nbits == 32) && comp == BMP_BITFIELDS)))
         return false;                                // weird compression type
    if (bi.biHeight == INT_MIN)
        return false; // out of range for positive int
    if (bi.biWidth <= 0 || !bi.biHeight || quint64(bi.biWidth) * qAbs(bi.biHeight) > 16384 * 16384)
        return false;
 
    return true;
}
 
static bool read_dib_body(QDataStream &s, const BMP_INFOHDR &bi, qint64 datapos, qint64 startpos, QImage &image)
{
    QIODevice* d = s.device();
    if (d->atEnd())                                // end of stream/file
        return false;
#if 0
    qDebug("offset...........%lld", datapos);
    qDebug("startpos.........%lld", startpos);
    qDebug("biSize...........%d", bi.biSize);
    qDebug("biWidth..........%d", bi.biWidth);
    qDebug("biHeight.........%d", bi.biHeight);
    qDebug("biPlanes.........%d", bi.biPlanes);
    qDebug("biBitCount.......%d", bi.biBitCount);
    qDebug("biCompression....%d", bi.biCompression);
    qDebug("biSizeImage......%d", bi.biSizeImage);
    qDebug("biXPelsPerMeter..%d", bi.biXPelsPerMeter);
    qDebug("biYPelsPerMeter..%d", bi.biYPelsPerMeter);
    qDebug("biClrUsed........%d", bi.biClrUsed);
    qDebug("biClrImportant...%d", bi.biClrImportant);
#endif
    int w = bi.biWidth,         h = bi.biHeight,  nbits = bi.biBitCount;
    int t = bi.biSize,         comp = bi.biCompression;
    uint red_mask = 0;
    uint green_mask = 0;
    uint blue_mask = 0;
    uint alpha_mask = 0;
    uint red_shift = 0;
    uint green_shift = 0;
    uint blue_shift = 0;
    uint alpha_shift = 0;
    uint red_scale = 0;
    uint green_scale = 0;
    uint blue_scale = 0;
    uint alpha_scale = 0;
    bool bitfields = comp == BMP_BITFIELDS || comp == BMP_ALPHABITFIELDS;
 
    if (!d->isSequential())
        d->seek(startpos + bi.biSize); // goto start of colormap or masks
 
    if (bi.biSize >= BMP_WIN4) {
        red_mask = bi.biRedMask;
        green_mask = bi.biGreenMask;
        blue_mask = bi.biBlueMask;
        alpha_mask = bi.biAlphaMask;
    } else if (bitfields && (nbits == 16 || nbits == 32)) {
        if (d->read((char *)&red_mask, sizeof(red_mask)) != sizeof(red_mask))
            return false;
        if (d->read((char *)&green_mask, sizeof(green_mask)) != sizeof(green_mask))
            return false;
        if (d->read((char *)&blue_mask, sizeof(blue_mask)) != sizeof(blue_mask))
            return false;
        if (comp == BMP_ALPHABITFIELDS && d->read((char *)&alpha_mask, sizeof(alpha_mask)) != sizeof(alpha_mask))
            return false;
    }
 
    bool transp = bitfields || (comp == BMP_RGB && nbits == 32 && alpha_mask == 0xff000000);
    transp = transp && alpha_mask;
 
    int ncols = 0;
    int depth = 0;
    QImage::Format format;
    switch (nbits) {
        case 32:
        case 24:
        case 16:
            depth = 32;
            format = transp ? QImage::Format_ARGB32 : QImage::Format_RGB32;
            break;
        case 8:
        case 4:
            depth = 8;
            format = QImage::Format_Indexed8;
            break;
        case 1:
            depth = 1;
            format = QImage::Format_Mono;
            break;
        default:
            return false;
            break;
    }
 
    if (depth != 32) {
        ncols = bi.biClrUsed ? bi.biClrUsed : 1 << nbits;
        if (ncols < 1 || ncols > 256) // sanity check - don't run out of mem if color table is broken
            return false;
    }
 
    if (bi.biHeight < 0)
        h = -h;                  // support images with negative height
 
    if (!QImageIOHandler::allocateImage(QSize(w, h), format, &image))
        return false;
    image.fill(0);
    if (ncols > 0) {                                // read color table
        image.setColorCount(ncols);
        uchar rgb[4];
        int   rgb_len = t == BMP_OLD ? 3 : 4;
        for (int i=0; i<ncols; i++) {
            if (d->read((char *)rgb, rgb_len) != rgb_len)
                return false;
            image.setColor(i, qRgb(rgb[2],rgb[1],rgb[0]));
            if (d->atEnd())                        // truncated file
                return false;
        }
    } else if (bitfields && (nbits == 16 || nbits == 32)) {
        red_shift = calc_shift(red_mask);
        if (((red_mask >> red_shift) + 1) == 0)
            return false;
        red_scale = calc_scale(red_mask >> red_shift);
        green_shift = calc_shift(green_mask);
        if (((green_mask >> green_shift) + 1) == 0)
            return false;
        green_scale = calc_scale(green_mask >> green_shift);
        blue_shift = calc_shift(blue_mask);
        if (((blue_mask >> blue_shift) + 1) == 0)
            return false;
        blue_scale = calc_scale(blue_mask >> blue_shift);
        alpha_shift = calc_shift(alpha_mask);
        if (((alpha_mask >> alpha_shift) + 1) == 0)
            return false;
        alpha_scale = calc_scale(alpha_mask >> alpha_shift);
    } else if (comp == BMP_RGB && (nbits == 24 || nbits == 32)) {
        blue_mask = 0x000000ff;
        green_mask = 0x0000ff00;
        red_mask = 0x00ff0000;
        blue_shift = 0;
        green_shift = 8;
        red_shift = 16;
        blue_scale = green_scale = red_scale = 0;
        if (transp) {
            alpha_shift = calc_shift(alpha_mask);
            if (((alpha_mask >> alpha_shift) + 1) == 0)
                return false;
            alpha_scale = calc_scale(alpha_mask >> alpha_shift);
        }
    } else if (comp == BMP_RGB && nbits == 16) {
        blue_mask = 0x001f;
        green_mask = 0x03e0;
        red_mask = 0x7c00;
        blue_shift = 0;
        green_shift = 5;
        red_shift = 10;
        blue_scale = green_scale = red_scale = 3;
    }
 
    image.setDotsPerMeterX(bi.biXPelsPerMeter);
    image.setDotsPerMeterY(bi.biYPelsPerMeter);
 
#if 0
    qDebug("Rmask: %08x Rshift: %08x Rscale:%08x", red_mask, red_shift, red_scale);
    qDebug("Gmask: %08x Gshift: %08x Gscale:%08x", green_mask, green_shift, green_scale);
    qDebug("Bmask: %08x Bshift: %08x Bscale:%08x", blue_mask, blue_shift, blue_scale);
    qDebug("Amask: %08x Ashift: %08x Ascale:%08x", alpha_mask, alpha_shift, alpha_scale);
#endif
 
    if (datapos >= 0 && datapos > d->pos()) {
        if (!d->isSequential())
            d->seek(datapos); // start of image data
    }
 
    int             bpl = image.bytesPerLine();
    uchar *data = image.bits();
 
    if (nbits == 1) {                                // 1 bit BMP image
        while (--h >= 0) {
            if (d->read((char*)(data + h*bpl), bpl) != bpl)
                break;
        }
        if (ncols == 2 && qGray(image.color(0)) < qGray(image.color(1)))
            swapPixel01(&image);                // pixel 0 is white!
    }
 
    else if (nbits == 4) {                        // 4 bit BMP image
        int    buflen = ((w+7)/8)*4;
        uchar *buf    = new uchar[buflen];
        if (comp == BMP_RLE4) {                // run length compression
            int x=0, y=0, c, i;
            quint8 b;
            uchar *p = data + (h-1)*bpl;
            const uchar *endp = p + w;
            while (y < h) {
                if (!d->getChar((char *)&b))
                    break;
                if (b == 0) {                        // escape code
                    if (!d->getChar((char *)&b) || b == 1) {
                        y = h;                // exit loop
                    } else switch (b) {
                        case 0:                        // end of line
                            x = 0;
                            y++;
                            p = data + (h-y-1)*bpl;
                            break;
                        case 2:                        // delta (jump)
                        {
                            quint8 tmp = 0;
                            d->getChar((char *)&tmp);
                            x += tmp;
                            d->getChar((char *)&tmp);
                            y += tmp;
                        }
 
                            // Protection
                            if ((uint)x >= (uint)w)
                                x = w-1;
                            if ((uint)y >= (uint)h)
                                y = h-1;
 
                            p = data + (h-y-1)*bpl + x;
                            break;
                        default:                // absolute mode
                            // Protection
                            if (p + b > endp)
                                b = endp-p;
 
                            i = (c = b)/2;
                            while (i--) {
                                d->getChar((char *)&b);
                                *p++ = b >> 4;
                                *p++ = b & 0x0f;
                            }
                            if (c & 1) {
                                unsigned char tmp = 0;
                                d->getChar((char *)&tmp);
                                *p++ = tmp >> 4;
                            }
                            if ((((c & 3) + 1) & 2) == 2)
                                d->getChar(nullptr);        // align on word boundary
                            x += c;
                    }
                } else {                        // encoded mode
                    // Protection
                    if (p + b > endp)
                        b = endp-p;
 
                    i = (c = b)/2;
                    d->getChar((char *)&b);                // 2 pixels to be repeated
                    while (i--) {
                        *p++ = b >> 4;
                        *p++ = b & 0x0f;
                    }
                    if (c & 1)
                        *p++ = b >> 4;
                    x += c;
                }
            }
        } else if (comp == BMP_RGB) {                // no compression
            while (--h >= 0) {
                if (d->read((char*)buf,buflen) != buflen)
                    break;
                uchar *p = data + h*bpl;
                uchar *b = buf;
                for (int i=0; i<w/2; i++) {        // convert nibbles to bytes
                    *p++ = *b >> 4;
                    *p++ = *b++ & 0x0f;
                }
                if (w & 1)                        // the last nibble
                    *p = *b >> 4;
            }
        }
        delete [] buf;
    }
 
    else if (nbits == 8) {                        // 8 bit BMP image
        if (comp == BMP_RLE8) {                // run length compression
            int x=0, y=0;
            quint8 b;
            uchar *p = data + (h-1)*bpl;
            const uchar *endp = p + w;
            while (y < h) {
                if (!d->getChar((char *)&b))
                    break;
                if (b == 0) {                        // escape code
                    if (!d->getChar((char *)&b) || b == 1) {
                            y = h;                // exit loop
                    } else switch (b) {
                        case 0:                        // end of line
                            x = 0;
                            y++;
                            p = data + (h-y-1)*bpl;
                            break;
                        case 2:                        // delta (jump)
                            {
                                quint8 tmp = 0;
                                d->getChar((char *)&tmp);
                                x += tmp;
                                d->getChar((char *)&tmp);
                                y += tmp;
                            }
 
                            // Protection
                            if ((uint)x >= (uint)w)
                                x = w-1;
                            if ((uint)y >= (uint)h)
                                y = h-1;
 
                            p = data + (h-y-1)*bpl + x;
                            break;
                        default:                // absolute mode
                            // Protection
                            if (p + b > endp)
                                b = endp-p;
 
                            if (d->read((char *)p, b) != b)
                                return false;
                            if ((b & 1) == 1)
                                d->getChar(nullptr);        // align on word boundary
                            x += b;
                            p += b;
                    }
                } else {                        // encoded mode
                    // Protection
                    if (p + b > endp)
                        b = endp-p;
 
                    char tmp = 0;
                    d->getChar(&tmp);
                    memset(p, tmp, b); // repeat pixel
                    x += b;
                    p += b;
                }
            }
        } else if (comp == BMP_RGB) {                // uncompressed
            while (--h >= 0) {
                if (d->read((char *)data + h*bpl, bpl) != bpl)
                    break;
            }
        }
    }
 
    else if (nbits == 16 || nbits == 24 || nbits == 32) { // 16,24,32 bit BMP image
        QRgb *p;
        QRgb  *end;
        uchar *buf24 = new uchar[bpl];
        qint64 bpl24 = ((qint64(w)*nbits+31)/32)*4;
        uchar *b;
        int c;
 
        while (--h >= 0) {
            p = (QRgb *)(data + h*bpl);
            end = p + w;
            if (d->read((char *)buf24,bpl24) != bpl24)
                break;
            b = buf24;
            while (p < end) {
                c = *(uchar*)b | (*(uchar*)(b+1)<<8);
                if (nbits > 16)
                    c |= *(uchar*)(b+2)<<16;
                if (nbits > 24)
                    c |= *(uchar*)(b+3)<<24;
                *p++ = qRgba(apply_scale((c & red_mask) >> red_shift, red_scale),
                             apply_scale((c & green_mask) >> green_shift, green_scale),
                             apply_scale((c & blue_mask) >> blue_shift, blue_scale),
                             transp ? apply_scale((c & alpha_mask) >> alpha_shift, alpha_scale) : 0xff);
                b += nbits/8;
            }
        }
        delete[] buf24;
    }
 
    if (bi.biHeight < 0) {
        // Flip the image
        uchar *buf = new uchar[bpl];
        h = -bi.biHeight;
        for (int y = 0; y < h/2; ++y) {
            memcpy(buf, data + y*bpl, bpl);
            memcpy(data + y*bpl, data + (h-y-1)*bpl, bpl);
            memcpy(data + (h-y-1)*bpl, buf, bpl);
        }
        delete [] buf;
    }
 
    if (ncols > 0 && ncols < (1 << nbits)) {
        // The pixel data can hold values the color table has no entry for.
        // Give them one (opaque black), so the color table covers every pixel.
        int maxIndex = 1;
        if (depth == 8) {
            maxIndex = 0;
            for (int y = 0; y < image.height() && maxIndex < 255; ++y) {
                const uchar *p = image.constScanLine(y);
                maxIndex = qMax(maxIndex, int(*std::max_element(p, p + image.width())));
            }
        }
        if (maxIndex >= ncols) {
            image.setColorCount(maxIndex + 1);
            for (int i = ncols; i <= maxIndex; ++i)
                image.setColor(i, qRgb(0, 0, 0));
        }
    }
 
    return true;
}
 
bool qt_write_dib(QDataStream &s, const QImage &image, int bpl, int bpl_bmp, int nbits)
{
    QIODevice* d = s.device();
    if (!d->isWritable())
        return false;
 
    BMP_INFOHDR bi = { };
    bi.biSize               = BMP_WIN;                // build info header
    bi.biWidth               = image.width();
    bi.biHeight               = image.height();
    bi.biPlanes               = 1;
    bi.biBitCount      = nbits;
    bi.biCompression   = BMP_RGB;
    bi.biSizeImage     = bpl_bmp*image.height();
    bi.biXPelsPerMeter = image.dotsPerMeterX() ? image.dotsPerMeterX()
                                                : 2834; // 72 dpi default
    bi.biYPelsPerMeter = image.dotsPerMeterY() ? image.dotsPerMeterY() : 2834;
    bi.biClrUsed       = image.colorCount();
    bi.biClrImportant  = image.colorCount();
    if (!(s << bi))                                        // write info header
        return false;
 
    if (image.depth() != 32) {                // write color table
        uchar *color_table = new uchar[4*image.colorCount()];
        uchar *rgb = color_table;
        const QList<QRgb> c = image.colorTable();
        for (int i = 0; i < image.colorCount(); i++) {
            *rgb++ = qBlue (c[i]);
            *rgb++ = qGreen(c[i]);
            *rgb++ = qRed  (c[i]);
            *rgb++ = 0;
        }
        if (d->write((char *)color_table, 4*image.colorCount()) == -1) {
            delete [] color_table;
            return false;
        }
        delete [] color_table;
    }
 
    int y;
 
    if (nbits == 1 || nbits == 8) {                // direct output
        for (y=image.height()-1; y>=0; y--) {
            if (d->write((const char*)image.constScanLine(y), bpl) == -1)
                return false;
        }
        return true;
    }
 
    uchar *buf        = new uchar[bpl_bmp];
    uchar *b, *end;
    const uchar *p;
 
    memset(buf, 0, bpl_bmp);
    for (y=image.height()-1; y>=0; y--) {        // write the image bits
        if (nbits == 4) {                        // convert 8 -> 4 bits
            p = image.constScanLine(y);
            b = buf;
            end = b + image.width()/2;
            while (b < end) {
                *b++ = (*p << 4) | (*(p+1) & 0x0f);
                p += 2;
            }
            if (image.width() & 1)
                *b = *p << 4;
        } else {                                // 32 bits
            const QRgb *p   = (const QRgb *)image.constScanLine(y);
            const QRgb *end = p + image.width();
            b = buf;
            while (p < end) {
                *b++ = qBlue(*p);
                *b++ = qGreen(*p);
                *b++ = qRed(*p);
                p++;
            }
        }
        if (bpl_bmp != d->write((char*)buf, bpl_bmp)) {
            delete[] buf;
            return false;
        }
    }
    delete[] buf;
    return true;
}
 
QBmpHandler::QBmpHandler(InternalFormat fmt) :
    m_format(fmt), state(Ready)
{
}
 
QByteArray QBmpHandler::formatName() const
{
    return m_format == BmpFormat ? "bmp" : "dib";
}
 
bool QBmpHandler::readHeader()
{
    state = Error;
 
    QIODevice *d = device();
    QDataStream s(d);
    startpos = d->pos();
 
    // Intel byte order
    s.setByteOrder(QDataStream::LittleEndian);
 
    // read BMP file header
    if (m_format == BmpFormat && !read_dib_fileheader(s, fileHeader))
        return false;
 
    // read BMP info header
    if (!read_dib_infoheader(s, infoHeader))
        return false;
 
    state = ReadHeader;
    return true;
}
 
bool QBmpHandler::canRead() const
{
    if (m_format == BmpFormat && state == Ready && !canRead(device()))
        return false;
 
    if (state != Error) {
        setFormat(formatName());
        return true;
    }
 
    return false;
}
 
bool QBmpHandler::canRead(QIODevice *device)
{
    if (!device) {
        qWarning("QBmpHandler::canRead() called with 0 pointer");
        return false;
    }
 
    char head[2];
    if (device->peek(head, sizeof(head)) != sizeof(head))
        return false;
 
    return (qstrncmp(head, "BM", 2) == 0);
}
 
bool QBmpHandler::read(QImage *image)
{
    if (state == Error)
        return false;
 
    if (!image) {
        qWarning("QBmpHandler::read: cannot read into null pointer");
        return false;
    }
 
    if (state == Ready && !readHeader()) {
        state = Error;
        return false;
    }
 
    QIODevice *d = device();
    QDataStream s(d);
 
    // Intel byte order
    s.setByteOrder(QDataStream::LittleEndian);
 
    // read image
    qint64 datapos = startpos;
    if (m_format == BmpFormat) {
        datapos += fileHeader.bfOffBits;
    } else {
        // QTBUG-100351: We have no file header when reading dib format so we have to depend on the size of the
        // buffer and the biSizeImage value to find where the pixel data starts since there's sometimes optional
        // color mask values after biSize, like for example when pasting from the windows snipping tool.
        if (infoHeader.biSizeImage > 0 && infoHeader.biSizeImage < d->size()) {
            datapos = d->size() - infoHeader.biSizeImage;
        } else {
            // And sometimes biSizeImage is not filled in like when pasting from Microsoft Edge, so then we just
            // have to assume the optional color mask values are there.
            datapos += infoHeader.biSize;
 
            if (infoHeader.biBitCount == 16 || infoHeader.biBitCount == 32) {
                if (infoHeader.biCompression == BMP_BITFIELDS) {
                    datapos += 12;
                } else if (infoHeader.biCompression == BMP_ALPHABITFIELDS) {
                    datapos += 16;
                }
            }
        }
    }
    const bool readSuccess = m_format == BmpFormat ?
        read_dib_body(s, infoHeader, datapos, startpos + BMP_FILEHDR_SIZE, *image) :
        read_dib_body(s, infoHeader, datapos, startpos, *image);
    if (!readSuccess)
        return false;
 
    state = Ready;
    return true;
}
 
bool QBmpHandler::write(const QImage &img)
{
    QImage image;
    switch (img.format()) {
    case QImage::Format_Mono:
    case QImage::Format_Indexed8:
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32:
        image = img;
        break;
    case QImage::Format_MonoLSB:
        image = img.convertToFormat(QImage::Format_Mono);
        break;
    case QImage::Format_Alpha8:
    case QImage::Format_Grayscale8:
        image = img.convertToFormat(QImage::Format_Indexed8);
        break;
    default:
        if (img.hasAlphaChannel())
            image = img.convertToFormat(QImage::Format_ARGB32);
        else
            image = img.convertToFormat(QImage::Format_RGB32);
        break;
    }
 
    int nbits;
    qsizetype bpl_bmp;
    // Calculate a minimum bytes-per-line instead of using whatever value this QImage is using internally.
    qsizetype bpl = ((image.width() * image.depth() + 31) >> 5) << 2;
 
    if (image.depth() == 8 && image.colorCount() <= 16) {
        bpl_bmp = (((bpl+1)/2+3)/4)*4;
        nbits = 4;
   } else if (image.depth() == 32) {
        bpl_bmp = ((image.width()*24+31)/32)*4;
        nbits = 24;
    } else {
        bpl_bmp = bpl;
        nbits = image.depth();
    }
    if (qsizetype(int(bpl_bmp)) != bpl_bmp)
        return false;
 
    if (m_format == DibFormat) {
        QDataStream dibStream(device());
        dibStream.setByteOrder(QDataStream::LittleEndian); // Intel byte order
        return qt_write_dib(dibStream, img, bpl, bpl_bmp, nbits);
    }
 
    QIODevice *d = device();
    QDataStream s(d);
    BMP_FILEHDR bf;
 
    // Intel byte order
    s.setByteOrder(QDataStream::LittleEndian);
 
    // build file header
    memcpy(bf.bfType, "BM", 2);
 
    // write file header
    bf.bfReserved1 = 0;
    bf.bfReserved2 = 0;
    bf.bfOffBits = BMP_FILEHDR_SIZE + BMP_WIN + image.colorCount() * 4;
    bf.bfSize = bf.bfOffBits + bpl_bmp*image.height();
    if (qsizetype(bf.bfSize) != bf.bfOffBits + bpl_bmp*image.height())
        return false;
    s << bf;
 
    // write image
    return qt_write_dib(s, image, bpl, bpl_bmp, nbits);
}
 
bool QBmpHandler::supportsOption(ImageOption option) const
{
    return option == Size
            || option == ImageFormat;
}
 
QVariant QBmpHandler::option(ImageOption option) const
{
    if (option == Size) {
        if (state == Error)
            return QVariant();
        if (state == Ready && !const_cast<QBmpHandler*>(this)->readHeader())
            return QVariant();
        return QSize(infoHeader.biWidth, infoHeader.biHeight);
    } else if (option == ImageFormat) {
        if (state == Error)
            return QVariant();
        if (state == Ready && !const_cast<QBmpHandler*>(this)->readHeader())
            return QVariant();
        QImage::Format format;
        switch (infoHeader.biBitCount) {
            case 32:
            case 24:
            case 16:
                if ((infoHeader.biCompression == BMP_BITFIELDS || infoHeader.biCompression == BMP_ALPHABITFIELDS) && infoHeader.biSize >= BMP_WIN4 && infoHeader.biAlphaMask)
                    format = QImage::Format_ARGB32;
                else
                    format = QImage::Format_RGB32;
                break;
            case 8:
            case 4:
                format = QImage::Format_Indexed8;
                break;
            default:
                format = QImage::Format_Mono;
            }
        return format;
    }
    return QVariant();
}
 
void QBmpHandler::setOption(ImageOption option, const QVariant &value)
{
    Q_UNUSED(option);
    Q_UNUSED(value);
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_IMAGEFORMAT_BMP