diff -r 000000000000 -r 1918ee327afb src/gui/image/qbmphandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/gui/image/qbmphandler.cpp Mon Jan 11 14:00:40 2010 +0000 @@ -0,0 +1,833 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "private/qbmphandler_p.h" + +#ifndef QT_NO_IMAGEFORMAT_BMP + +#include +#include +#include + +QT_BEGIN_NAMESPACE + +static void swapPixel01(QImage *image) // 1-bpp: swap 0 and 1 pixels +{ + int i; + if (image->depth() == 1 && image->numColors() == 2) { + register uint *p = (uint *)image->bits(); + int nbytes = image->numBytes(); + for (i=0; icolor(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; // new Windows BMP size +const int BMP_OS2 = 64; // new OS/2 BMP 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 + + +static QDataStream &operator>>(QDataStream &s, BMP_INFOHDR &bi) +{ + s >> bi.biSize; + if (bi.biSize == BMP_WIN || bi.biSize == BMP_OS2) { + s >> bi.biWidth >> bi.biHeight >> bi.biPlanes >> bi.biBitCount; + s >> bi.biCompression >> bi.biSizeImage; + s >> bi.biXPelsPerMeter >> bi.biYPelsPerMeter; + s >> bi.biClrUsed >> bi.biClrImportant; + } + 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; + return s; +} + +static int calc_shift(int mask) +{ + int result = 0; + while (!(mask & 1)) { + result++; + mask >>= 1; + } + return result; +} + +static bool read_dib_fileheader(QDataStream &s, BMP_FILEHDR &bf) +{ + // read BMP file header + s >> bf; + if (s.status() != QDataStream::Ok) + 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) +{ + s >> bi; // read BMP info header + if (s.status() != QDataStream::Ok) + 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 + + return true; +} + +static bool read_dib_body(QDataStream &s, const BMP_INFOHDR &bi, int offset, int startpos, QImage &image) +{ + QIODevice* d = s.device(); + if (d->atEnd()) // end of stream/file + return false; +#if 0 + qDebug("offset...........%d", offset); + qDebug("startpos.........%d", 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; + int red_mask = 0; + int green_mask = 0; + int blue_mask = 0; + int red_shift = 0; + int green_shift = 0; + int blue_shift = 0; + int red_scale = 0; + int green_scale = 0; + int blue_scale = 0; + + int ncols = 0; + int depth = 0; + QImage::Format format; + switch (nbits) { + case 32: + case 24: + case 16: + depth = 32; + format = QImage::Format_RGB32; + break; + case 8: + case 4: + depth = 8; + format = QImage::Format_Indexed8; + break; + default: + depth = 1; + format = QImage::Format_Mono; + } + + if (bi.biHeight < 0) + h = -h; // support images with negative height + + if (image.size() != QSize(w, h) || image.format() != format) { + image = QImage(w, h, format); + if (image.isNull()) // could not create image + return false; + } + + if (depth != 32) { + ncols = bi.biClrUsed ? bi.biClrUsed : 1 << nbits; + image.setNumColors(ncols); + } + + image.setDotsPerMeterX(bi.biXPelsPerMeter); + image.setDotsPerMeterY(bi.biYPelsPerMeter); + + if (!d->isSequential()) + d->seek(startpos + BMP_FILEHDR_SIZE + bi.biSize); // goto start of colormap + + if (ncols > 0) { // read color table + uchar rgb[4]; + int rgb_len = t == BMP_OLD ? 3 : 4; + for (int i=0; iread((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 (comp == BMP_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; + red_shift = calc_shift(red_mask); + red_scale = 256 / ((red_mask >> red_shift) + 1); + green_shift = calc_shift(green_mask); + green_scale = 256 / ((green_mask >> green_shift) + 1); + blue_shift = calc_shift(blue_mask); + blue_scale = 256 / ((blue_mask >> blue_shift) + 1); + } 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 = 1; + } else if (comp == BMP_RGB && nbits == 16) { + blue_mask = 0x001f; + green_mask = 0x03e0; + red_mask = 0x7c00; + blue_shift = 0; + green_shift = 2; + red_shift = 7; + red_scale = 1; + green_scale = 1; + blue_scale = 8; + } + + // offset can be bogus, be careful + if (offset>=0 && startpos + offset > d->pos()) { + if (!d->isSequential()) + d->seek(startpos + offset); // 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; + register 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; + 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; + d->getChar((char *)&tmp); + *p++ = tmp >> 4; + } + if ((((c & 3) + 1) & 2) == 2) + d->getChar(0); // 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 + memset(data, 0, h*bpl); + while (--h >= 0) { + if (d->read((char*)buf,buflen) != buflen) + break; + register uchar *p = data + h*bpl; + uchar *b = buf; + for (int i=0; i> 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; + register 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) + // Protection + if ((uint)x >= (uint)w) + x = w-1; + if ((uint)y >= (uint)h) + y = h-1; + + { + quint8 tmp; + d->getChar((char *)&tmp); + x += tmp; + d->getChar((char *)&tmp); + y += tmp; + } + 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(0); // align on word boundary + x += b; + p += b; + } + } else { // encoded mode + // Protection + if (p + b > endp) + b = endp-p; + + char tmp; + 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 + register QRgb *p; + QRgb *end; + uchar *buf24 = new uchar[bpl]; + int bpl24 = ((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; + *p++ = qRgb(((c & red_mask) >> red_shift) * red_scale, + ((c & green_mask) >> green_shift) * green_scale, + ((c & blue_mask) >> blue_shift) * blue_scale); + 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; + } + + return true; +} + +// this is also used in qmime_win.cpp +bool qt_write_dib(QDataStream &s, QImage image) +{ + int nbits; + int bpl_bmp; + int bpl = image.bytesPerLine(); + + QIODevice* d = s.device(); + if (!d->isWritable()) + return false; + + if (image.depth() == 8 && image.numColors() <= 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; +#ifdef Q_WS_QWS + } else if (image.depth() == 1 || image.depth() == 8) { + // Qt for Embedded Linux doesn't word align. + bpl_bmp = ((image.width()*image.depth()+31)/32)*4; + nbits = image.depth(); +#endif + } else { + bpl_bmp = bpl; + nbits = image.depth(); + } + + 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.numColors(); + bi.biClrImportant = image.numColors(); + s << bi; // write info header + if (s.status() != QDataStream::Ok) + return false; + + if (image.depth() != 32) { // write color table + uchar *color_table = new uchar[4*image.numColors()]; + uchar *rgb = color_table; + QVector c = image.colorTable(); + for (int i=0; iwrite((char *)color_table, 4*image.numColors()) == -1) { + delete [] color_table; + return false; + } + delete [] color_table; + } + + if (image.format() == QImage::Format_MonoLSB) + image = image.convertToFormat(QImage::Format_Mono); + + int y; + + if (nbits == 1 || nbits == 8) { // direct output +#ifdef Q_WS_QWS + // Qt for Embedded Linux doesn't word align. + int pad = bpl_bmp - bpl; + char padding[4]; +#endif + for (y=image.height()-1; y>=0; y--) { + if (d->write((char*)image.scanLine(y), bpl) == -1) + return false; +#ifdef Q_WS_QWS + if (d->write(padding, pad) == -1) + return false; +#endif + } + return true; + } + + uchar *buf = new uchar[bpl_bmp]; + uchar *b, *end; + register 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.scanLine(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 + QRgb *p = (QRgb *)image.scanLine(y); + 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; +} + +// this is also used in qmime_win.cpp +bool qt_read_dib(QDataStream &s, QImage &image) +{ + BMP_INFOHDR bi; + if (!read_dib_infoheader(s, bi)) + return false; + return read_dib_body(s, bi, -1, -BMP_FILEHDR_SIZE, image); +} + +QBmpHandler::QBmpHandler() + : state(Ready) +{ +} + +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 (!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 (state == Ready) { + if (!canRead(device())) + return false; + setFormat("bmp"); + return true; + } + return state != Error; +} + +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 + if (!read_dib_body(s, infoHeader, fileHeader.bfOffBits, startpos, *image)) + return false; + + state = Ready; + return true; +} + +bool QBmpHandler::write(const QImage &img) +{ + QImage image; + switch (img.format()) { + case QImage::Format_ARGB8565_Premultiplied: + case QImage::Format_ARGB8555_Premultiplied: + case QImage::Format_ARGB6666_Premultiplied: + case QImage::Format_ARGB4444_Premultiplied: + image = img.convertToFormat(QImage::Format_ARGB32); + break; + case QImage::Format_RGB16: + case QImage::Format_RGB888: + case QImage::Format_RGB666: + case QImage::Format_RGB555: + case QImage::Format_RGB444: + image = img.convertToFormat(QImage::Format_RGB32); + break; + default: + image = img; + } + + QIODevice *d = device(); + QDataStream s(d); + BMP_FILEHDR bf; + int bpl_bmp; + int bpl = image.bytesPerLine(); + + // Code partially repeated in qt_write_dib + if (image.depth() == 8 && image.numColors() <= 16) { + bpl_bmp = (((bpl+1)/2+3)/4)*4; + } else if (image.depth() == 32) { + bpl_bmp = ((image.width()*24+31)/32)*4; + } else { + bpl_bmp = bpl; + } + + // 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.numColors() * 4; + bf.bfSize = bf.bfOffBits + bpl_bmp*image.height(); + s << bf; + + // write image + return qt_write_dib(s, image); +} + +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(this)->readHeader()) + return QVariant(); + return QSize(infoHeader.biWidth, infoHeader.biHeight); + } else if (option == ImageFormat) { + if (state == Error) + return QVariant(); + if (state == Ready && !const_cast(this)->readHeader()) + return QVariant(); + QImage::Format format; + switch (infoHeader.biBitCount) { + case 32: + case 24: + case 16: + 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); +} + +QByteArray QBmpHandler::name() const +{ + return "bmp"; +} + +QT_END_NAMESPACE + +#endif // QT_NO_IMAGEFORMAT_BMP