ICOReader Class Reference

Classes
struct	IcoAttrib

Public Functions
int	count ()
QImage	iconAt (int index)
	ICOReader (QIODevice *iodevice)

Static Public Functions
static bool	canRead (QIODevice *iodev)
static QList< QImage >	read (QIODevice *device)
	Reads all the icons from the given device, and returns them as a list of QImage objects. More...
static bool	write (QIODevice *device, const QList< QImage > &images)
	Writes all the QImages in the images list to the given device. More...

Private Functions
void	findColorInfo (QImage &image)
void	read16_24_32BMP (QImage &image)
void	read1BitBMP (QImage &image)
void	read4BitBMP (QImage &image)
void	read8BitBMP (QImage &image)
void	readBMP (QImage &image)
bool	readBMPHeader (quint32 imageOffset, BMP_INFOHDR *header)
void	readColorTable (QImage &image)
bool	readHeader ()
bool	readIconEntry (int index, ICONDIRENTRY *iconEntry)

Properties
bool	headerRead
struct ICOReader::IcoAttrib	icoAttrib
ICONDIR	iconDir
QIODevice *	iod
qint64	startpos

Detailed Description

Definition at line 102 of file qicohandler.cpp.

Constructors and Destructors

ICOReader()

ICOReader::ICOReader

(

QIODevice *

iodevice

)

Definition at line 253 of file qicohandler.cpp.

Referenced by QtIcoHandler::QtIcoHandler().

: iod(iodevice)
, startpos(0)
, headerRead(false)
{
}

Functions

canRead()

bool ICOReader::canRead ( QIODevice *  iodev )

static

Definition at line 268 of file qicohandler.cpp.

Referenced by QtIcoHandler::canRead().

{
    bool isProbablyICO = false;
    if (iodev) {
        qint64 oldPos = iodev->pos();

        ICONDIR ikonDir;
        if (readIconDir(iodev, &ikonDir)) {
            qint64 readBytes = ICONDIR_SIZE;
            if (readIconDirEntry(iodev, &ikonDir.idEntries[0])) {
                readBytes += ICONDIRENTRY_SIZE;
                // ICO format does not have a magic identifier, so we read 6 different values, which will hopefully be enough to identify the file.
                if (   ikonDir.idReserved == 0
                    && ikonDir.idType == 1
                    && ikonDir.idEntries[0].bReserved == 0
                    && ikonDir.idEntries[0].wPlanes <= 1
                    && ikonDir.idEntries[0].wBitCount <= 32     // Bits per pixel
                    && ikonDir.idEntries[0].dwBytesInRes >= 40  // Must be over 40, since sizeof (infoheader) == 40
                    ) {
                    isProbablyICO = true;
                }

                if (iodev->isSequential()) {
                    // Our structs might be padded due to alignment, so we need to fetch each member before we ungetChar() !
                    quint32 tmp = ikonDir.idEntries[0].dwImageOffset;
                    iodev->ungetChar((tmp >> 24) & 0xff);
                    iodev->ungetChar((tmp >> 16) & 0xff);
                    iodev->ungetChar((tmp >>  8) & 0xff);
                    iodev->ungetChar(tmp & 0xff);

                    tmp = ikonDir.idEntries[0].dwBytesInRes;
                    iodev->ungetChar((tmp >> 24) & 0xff);
                    iodev->ungetChar((tmp >> 16) & 0xff);
                    iodev->ungetChar((tmp >>  8) & 0xff);
                    iodev->ungetChar(tmp & 0xff);

                    tmp = ikonDir.idEntries[0].wBitCount;
                    iodev->ungetChar((tmp >>  8) & 0xff);
                    iodev->ungetChar(tmp & 0xff);

                    tmp = ikonDir.idEntries[0].wPlanes;
                    iodev->ungetChar((tmp >>  8) & 0xff);
                    iodev->ungetChar(tmp & 0xff);

                    iodev->ungetChar(ikonDir.idEntries[0].bReserved);
                    iodev->ungetChar(ikonDir.idEntries[0].bColorCount);
                    iodev->ungetChar(ikonDir.idEntries[0].bHeight);
                    iodev->ungetChar(ikonDir.idEntries[0].bWidth);
                }
            }

            if (iodev->isSequential()) {
                // Our structs might be padded due to alignment, so we need to fetch each member before we ungetChar() !
                quint32 tmp = ikonDir.idCount;
                iodev->ungetChar((tmp >>  8) & 0xff);
                iodev->ungetChar(tmp & 0xff);

                tmp = ikonDir.idType;
                iodev->ungetChar((tmp >>  8) & 0xff);
                iodev->ungetChar(tmp & 0xff);

                tmp = ikonDir.idReserved;
                iodev->ungetChar((tmp >>  8) & 0xff);
                iodev->ungetChar(tmp & 0xff);
            }
        }
        if (!iodev->isSequential()) iodev->seek(oldPos);
    }

    return isProbablyICO;
}

count()

int ICOReader::count

(

)

Definition at line 261 of file qicohandler.cpp.

Referenced by iconAt(), and read().

{
    if (readHeader())
        return iconDir.idCount;
    return 0;
}

findColorInfo()

void ICOReader::findColorInfo ( QImage &  image )

private

Definition at line 377 of file qicohandler.cpp.

Referenced by iconAt().

{
    if (icoAttrib.ncolors > 0) {                // set color table
        readColorTable(image);
    } else if (icoAttrib.nbits == 16) { // don't support RGB values for 15/16 bpp
        image = QImage();
    }
}

iconAt()

QImage ICOReader::iconAt

(

int

index

)

Definition at line 523 of file qicohandler.cpp.

Referenced by read().

{
    QImage img;

    if (count() > index) { // forces header to be read

        ICONDIRENTRY iconEntry;
        if (readIconEntry(index, &iconEntry)) {

            static const uchar pngMagicData[] = { 137, 80, 78, 71, 13, 10, 26, 10 };

            iod->seek(iconEntry.dwImageOffset);

            const QByteArray pngMagic = QByteArray::fromRawData((char*)pngMagicData, sizeof(pngMagicData));
            const bool isPngImage = (iod->read(pngMagic.size()) == pngMagic);

            if (isPngImage) {
                iod->seek(iconEntry.dwImageOffset);
                return QImage::fromData(iod->read(iconEntry.dwBytesInRes), "png");
            }

            BMP_INFOHDR header;
            if (readBMPHeader(iconEntry.dwImageOffset, &header)) {
                icoAttrib.nbits = header.biBitCount ? header.biBitCount : iconEntry.wBitCount;

                switch (icoAttrib.nbits) {
                case 32:
                case 24:
                case 16:
                    icoAttrib.depth = 32;
                    break;
                case 8:
                case 4:
                    icoAttrib.depth = 8;
                    break;
                default:
                    icoAttrib.depth = 1;
                }
                if (icoAttrib.depth == 32)                // there's no colormap
                    icoAttrib.ncolors = 0;
                else                    // # colors used
                    icoAttrib.ncolors = header.biClrUsed ? header.biClrUsed : 1 << icoAttrib.nbits;
                if (icoAttrib.ncolors > 256) //color table can't be more than 256
                    return img;
                icoAttrib.w = iconEntry.bWidth;
                if (icoAttrib.w == 0)
                    icoAttrib.w = header.biWidth;
                icoAttrib.h = iconEntry.bHeight;
                if (icoAttrib.h == 0)
                    icoAttrib.h = header.biHeight/2;

                QImage::Format format = QImage::Format_ARGB32;
                if (icoAttrib.nbits == 24)
                    format = QImage::Format_RGB32;
                else if (icoAttrib.ncolors == 2)
                    format = QImage::Format_Mono;
                else if (icoAttrib.ncolors > 0)
                    format = QImage::Format_Indexed8;

                QImage image(icoAttrib.w, icoAttrib.h, format);
                if (!image.isNull()) {
                    findColorInfo(image);
                    if (!image.isNull()) {
                        readBMP(image);
                        if (!image.isNull()) {
                            QImage mask(image.width(), image.height(), QImage::Format_Mono);
                            if (!mask.isNull()) {
                                mask.setColorCount(2);
                                mask.setColor(0, qRgba(255,255,255,0xff));
                                mask.setColor(1, qRgba(0  ,0  ,0  ,0xff));
                                read1BitBMP(mask);
                                if (!mask.isNull()) {
                                    img = QImage(image.width(), image.height(), QImage::Format_ARGB32 );
                                    img = image;
                                    img.setAlphaChannel(mask);
                                    // (Luckily, it seems that setAlphaChannel() does not ruin the alpha values
                                    // of partially transparent pixels in those icons that have that)
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    return img;
}

read()

QList< QImage > ICOReader::read ( QIODevice *  device )

static

Reads all the icons from the given device, and returns them as a list of QImage objects.

Each image has an alpha channel that represents the mask from the corresponding icon.

See also

write()

Definition at line 622 of file qicohandler.cpp.

{
    QList<QImage> images;

    ICOReader reader(device);
    for (int i = 0; i < reader.count(); i++)
        images += reader.iconAt(i);

    return images;
}

read16_24_32BMP()

void ICOReader::read16_24_32BMP ( QImage &  image )

private

Definition at line 489 of file qicohandler.cpp.

Referenced by readBMP().

{
    if (iod) {
        int h = icoAttrib.h;
        register QRgb *p;
        QRgb  *end;
        uchar *buf = new uchar[image.bytesPerLine()];
        int    bpl = ((icoAttrib.w*icoAttrib.nbits+31)/32)*4;
        uchar *b;

        while (--h >= 0) {
            p = (QRgb *)image.scanLine(h);
            end = p + icoAttrib.w;
            if (iod->read((char *)buf, bpl) != bpl) {
                image = QImage();
                break;
            }
            b = buf;
            while (p < end) {
                if (icoAttrib.nbits == 24)
                    *p++ = qRgb(*(b+2), *(b+1), *b);
                else if (icoAttrib.nbits == 32)
                    *p++ = qRgba(*(b+2), *(b+1), *b, *(b+3));
                b += icoAttrib.nbits/8;
            }
        }

        delete[] buf;

    } else {
        image = QImage();
    }
}

read1BitBMP()

void ICOReader::read1BitBMP ( QImage &  image )

private

NOTE: A 1 bit BMP is only flipped vertically, and not horizontally like all other color depths! (This is the same with the bitmask)

Definition at line 422 of file qicohandler.cpp.

Referenced by iconAt(), and readBMP().

{
    if (iod) {

        int h = image.height();
        int bpl = image.bytesPerLine();

        while (--h >= 0) {
            if (iod->read((char*)image.scanLine(h),bpl) != bpl) {
                image = QImage();
                break;
            }
        }
    } else {
        image = QImage();
    }
}

read4BitBMP()

void ICOReader::read4BitBMP ( QImage &  image )

private

Definition at line 440 of file qicohandler.cpp.

Referenced by readBMP().

{
    if (iod) {

        int h = icoAttrib.h;
        int buflen = ((icoAttrib.w+7)/8)*4;
        uchar *buf = new uchar[buflen];
        Q_CHECK_PTR(buf);

        while (--h >= 0) {
            if (iod->read((char*)buf,buflen) != buflen) {
                image = QImage();
                break;
            }
            register uchar *p = image.scanLine(h);
            uchar *b = buf;
            for (int i=0; i<icoAttrib.w/2; i++) {   // convert nibbles to bytes
                *p++ = *b >> 4;
                *p++ = *b++ & 0x0f;
            }
            if (icoAttrib.w & 1)                    // the last nibble
                *p = *b >> 4;
        }

        delete [] buf;

    } else {
        image = QImage();
    }
}

read8BitBMP()

void ICOReader::read8BitBMP ( QImage &  image )

private

Definition at line 471 of file qicohandler.cpp.

Referenced by readBMP().

{
    if (iod) {

        int h = icoAttrib.h;
        int bpl = image.bytesPerLine();

        while (--h >= 0) {
            if (iod->read((char *)image.scanLine(h), bpl) != bpl) {
                image = QImage();
                break;
            }
        }
    } else {
        image = QImage();
    }
}

readBMP()

void ICOReader::readBMP ( QImage &  image )

private

Definition at line 403 of file qicohandler.cpp.

Referenced by iconAt().

{
    if (icoAttrib.nbits == 1) {                // 1 bit BMP image
        read1BitBMP(image);
    } else if (icoAttrib.nbits == 4) {            // 4 bit BMP image
        read4BitBMP(image);
    } else if (icoAttrib.nbits == 8) {
        read8BitBMP(image);
    } else if (icoAttrib.nbits == 16 || icoAttrib.nbits == 24 || icoAttrib.nbits == 32 ) { // 16,24,32 bit BMP image
        read16_24_32BMP(image);
    }
}

readBMPHeader()

bool ICOReader::readBMPHeader ( quint32  imageOffset, BMP_INFOHDR *  header  )

private

Definition at line 365 of file qicohandler.cpp.

Referenced by iconAt().

{
    if (iod) {
        if (iod->seek(startpos + imageOffset)) {
            if (readBMPInfoHeader(iod, header)) {
                return TRUE;
            }
        }
    }
    return FALSE;
}

readColorTable()

void ICOReader::readColorTable ( QImage &  image )

private

Definition at line 386 of file qicohandler.cpp.

Referenced by findColorInfo().

{
    if (iod) {
        image.setColorCount(icoAttrib.ncolors);
        uchar rgb[4];
        for (int i=0; i<icoAttrib.ncolors; i++) {
            if (iod->read((char*)rgb, 4) != 4) {
            image = QImage();
            break;
            }
            image.setColor(i, qRgb(rgb[2],rgb[1],rgb[0]));
        }
    } else {
        image = QImage();
    }
}

readHeader()

bool ICOReader::readHeader ( )

private

Definition at line 340 of file qicohandler.cpp.

Referenced by count().

{
    if (iod && !headerRead) {
        startpos = iod->pos();
        if (readIconDir(iod, &iconDir)) {
            if (iconDir.idReserved == 0 || iconDir.idType == 1)
            headerRead = true;
        }
    }

    return headerRead;
}

readIconEntry()

bool ICOReader::readIconEntry ( int  index, ICONDIRENTRY *  iconEntry  )

private

Definition at line 353 of file qicohandler.cpp.

Referenced by iconAt().

{
    if (iod) {
        if (iod->seek(startpos + ICONDIR_SIZE + (index * ICONDIRENTRY_SIZE))) {
            return readIconDirEntry(iod, iconEntry);
        }
    }
    return false;
}

write()

bool ICOReader::write ( QIODevice *  device, const QList< QImage > &  images  )

static

Writes all the QImages in the images list to the given device.

Returns true if the images are written successfully; otherwise returns false.

The first image in the list is stored as the first icon in the device, and is therefore used as the default icon by applications. The alpha channel of each image is converted to a mask for each corresponding icon.

See also

read()

Definition at line 646 of file qicohandler.cpp.

Referenced by QtIcoHandler::write().

{
    bool retValue = false;

    if (images.count()) {

        qint64 origOffset = device->pos();

        ICONDIR id;
        id.idReserved = 0;
        id.idType = 1;
        id.idCount = images.count();

        ICONDIRENTRY * entries = new ICONDIRENTRY[id.idCount];
        BMP_INFOHDR * bmpHeaders = new BMP_INFOHDR[id.idCount];
        QByteArray * imageData = new QByteArray[id.idCount];

        for (int i=0; i<id.idCount; i++) {

            QImage image = images[i];
            // Scale down the image if it is larger than 128 pixels in either width or height
            if (image.width() > 128 || image.height() > 128)
            {
                image = image.scaled(128, 128, Qt::KeepAspectRatio, Qt::SmoothTransformation);
            }
            QImage maskImage(image.width(), image.height(), QImage::Format_Mono);
            image = image.convertToFormat(QImage::Format_ARGB32);

            if (image.hasAlphaChannel()) {
                maskImage = image.createAlphaMask();
            } else {
                maskImage.fill(0xff);
            }
            maskImage = maskImage.convertToFormat(QImage::Format_Mono);

            int    nbits = 32;
            int    bpl_bmp = ((image.width()*nbits+31)/32)*4;

            entries[i].bColorCount = 0;
            entries[i].bReserved = 0;
            entries[i].wBitCount = nbits;
            entries[i].bHeight = image.height();
            entries[i].bWidth = image.width();
            entries[i].dwBytesInRes = BMP_INFOHDR_SIZE + (bpl_bmp * image.height())
                + (maskImage.bytesPerLine() * maskImage.height());
            entries[i].wPlanes = 1;
            if (i == 0)
                entries[i].dwImageOffset = origOffset + ICONDIR_SIZE
                + (id.idCount * ICONDIRENTRY_SIZE);
            else
                entries[i].dwImageOffset = entries[i-1].dwImageOffset + entries[i-1].dwBytesInRes;

            bmpHeaders[i].biBitCount = entries[i].wBitCount;
            bmpHeaders[i].biClrImportant = 0;
            bmpHeaders[i].biClrUsed = entries[i].bColorCount;
            bmpHeaders[i].biCompression = 0;
            bmpHeaders[i].biHeight = entries[i].bHeight * 2; // 2 is for the mask
            bmpHeaders[i].biPlanes = entries[i].wPlanes;
            bmpHeaders[i].biSize = BMP_INFOHDR_SIZE;
            bmpHeaders[i].biSizeImage = entries[i].dwBytesInRes - BMP_INFOHDR_SIZE;
            bmpHeaders[i].biWidth = entries[i].bWidth;
            bmpHeaders[i].biXPelsPerMeter = 0;
            bmpHeaders[i].biYPelsPerMeter = 0;

            QBuffer buffer(&imageData[i]);
            buffer.open(QIODevice::WriteOnly);

            uchar *buf = new uchar[bpl_bmp];
            uchar *b;
            memset( buf, 0, bpl_bmp );
            int y;
            for (y = image.height() - 1; y >= 0; y--) {    // write the image bits
                // 32 bits
                QRgb *p   = (QRgb *)image.scanLine(y);
                QRgb *end = p + image.width();
                b = buf;
                int x = 0;
                while (p < end) {
                    *b++ = qBlue(*p);
                    *b++ = qGreen(*p);
                    *b++ = qRed(*p);
                    *b++ = qAlpha(*p);
                    if (qAlpha(*p) > 0)   // Even mostly transparent pixels must not be masked away
                        maskImage.setPixel(x, y, Qt::color1);  // (i.e. createAlphaMask() takes away too much)
                    p++;
                    x++;
                }
                buffer.write((char*)buf, bpl_bmp);
            }
            delete[] buf;

            maskImage.invertPixels();   // seems as though it needs this
            // NOTE! !! The mask is only flipped vertically - not horizontally !!
            for (y = maskImage.height() - 1; y >= 0; y--)
                buffer.write((char*)maskImage.scanLine(y), maskImage.bytesPerLine());
        }

        if (writeIconDir(device, id)) {
            int i;
            bool bOK = true;
            for (i = 0; i < id.idCount && bOK; i++) {
                bOK = writeIconDirEntry(device, entries[i]);
            }
            if (bOK) {
                for (i = 0; i < id.idCount && bOK; i++) {
                    bOK = writeBMPInfoHeader(device, bmpHeaders[i]);
                    bOK &= (device->write(imageData[i]) == (int) imageData[i].size());
                }
                retValue = bOK;
            }
        }

        delete [] entries;
        delete [] bmpHeaders;
        delete [] imageData;

    }
    return retValue;
}

Properties

headerRead

bool ICOReader::headerRead

private

Definition at line 139 of file qicohandler.cpp.

Referenced by readHeader().

icoAttrib

struct ICOReader::IcoAttrib ICOReader::icoAttrib

private

Referenced by findColorInfo(), iconAt(), read16_24_32BMP(), read4BitBMP(), read8BitBMP(), readBMP(), and readColorTable().

iconDir

ICONDIR ICOReader::iconDir

private

Definition at line 140 of file qicohandler.cpp.

Referenced by count(), and readHeader().

iod

QIODevice* ICOReader::iod

private

Definition at line 137 of file qicohandler.cpp.

Referenced by iconAt(), read16_24_32BMP(), read1BitBMP(), read4BitBMP(), read8BitBMP(), readBMPHeader(), readColorTable(), readHeader(), and readIconEntry().

startpos

qint64 ICOReader::startpos

private

Definition at line 138 of file qicohandler.cpp.

Referenced by readBMPHeader(), readHeader(), and readIconEntry().

---

The documentation for this class was generated from the following file:

• /src/plugins/imageformats/ico/qicohandler.cpp