/* * kimgio import filter for MS Windows .ico files * * Distributed under the terms of the LGPL * Copyright (c) 2000 Malte Starostik <malte@kde.org> * */#include "ICOHandler.h"#include <cstring>#include <cstdlib>#include <algorithm>#include <vector>#include <QtGui/QImage>#include <QtGui/QBitmap>#include <QtGui/QApplication>#include <QtCore/QVector>#include <QtGui/QDesktopWidget>namespace{    // Global header (see http://www.daubnet.com/formats/ICO.html)    struct IcoHeader    {        enum Type { Icon = 1, Cursor };        quint16 reserved;        quint16 type;        quint16 count;    };    inline QDataStream& operator >>( QDataStream& s, IcoHeader& h )    {        return s >> h.reserved >> h.type >> h.count;    }    // Based on qt_read_dib et al. from qimage.cpp    // (c) 1992-2002 Nokia Corporation and/or its subsidiary(-ies).    struct BMP_INFOHDR    {        static const quint32 Size = 40;        quint32  biSize;                // size of this struct        quint32  biWidth;               // pixmap width        quint32  biHeight;              // pixmap height        quint16  biPlanes;              // should be 1        quint16  biBitCount;            // number of bits per pixel        enum Compression { RGB = 0 };        quint32  biCompression;         // compression method        quint32  biSizeImage;           // size of image        quint32  biXPelsPerMeter;       // horizontal resolution        quint32  biYPelsPerMeter;       // vertical resolution        quint32  biClrUsed;             // number of colors used        quint32  biClrImportant;        // number of important colors    };    const quint32 BMP_INFOHDR::Size;    QDataStream& operator >>( QDataStream &s, BMP_INFOHDR &bi )    {        s >> bi.biSize;        if ( bi.biSize == BMP_INFOHDR::Size )        {            s >> bi.biWidth >> bi.biHeight >> bi.biPlanes >> bi.biBitCount;            s >> bi.biCompression >> bi.biSizeImage;            s >> bi.biXPelsPerMeter >> bi.biYPelsPerMeter;            s >> bi.biClrUsed >> bi.biClrImportant;        }        return s;    }#if 0    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;    }#endif    // Header for every icon in the file    struct IconRec    {        unsigned char width;        unsigned char height;        quint16 colors;        quint16 hotspotX;        quint16 hotspotY;        quint32 size;        quint32 offset;    };    inline QDataStream& operator >>( QDataStream& s, IconRec& r )    {        return s >> r.width >> r.height >> r.colors                 >> r.hotspotX >> r.hotspotY >> r.size >> r.offset;    }    struct LessDifference    {        LessDifference( unsigned s, unsigned c )            : size( s ), colors( c ) {}        bool operator ()( const IconRec& lhs, const IconRec& rhs ) const        {            // closest size match precedes everything else            if ( std::abs( int( lhs.width - size ) ) <                 std::abs( int( rhs.width - size ) ) ) return true;            else if ( std::abs( int( lhs.width - size ) ) >                 std::abs( int( rhs.width - size ) ) ) return false;            else if ( colors == 0 )            {                // high/true color requested                if ( lhs.colors == 0 ) return true;                else if ( rhs.colors == 0 ) return false;                else return lhs.colors > rhs.colors;            }            else            {                // indexed icon requested                if ( lhs.colors == 0 && rhs.colors == 0 ) return false;                else if ( lhs.colors == 0 ) return false;                else return std::abs( int( lhs.colors - colors ) ) <                            std::abs( int( rhs.colors - colors ) );            }        }        unsigned size;        unsigned colors;    };    bool loadFromDIB( QDataStream& stream, const IconRec& rec, QImage& icon )    {        BMP_INFOHDR header;        stream >> header;        if ( stream.atEnd() || header.biSize != BMP_INFOHDR::Size ||             header.biSize > rec.size ||             header.biCompression != BMP_INFOHDR::RGB ||             ( header.biBitCount != 1 && header.biBitCount != 4 &&               header.biBitCount != 8 && header.biBitCount != 24 &&               header.biBitCount != 32 ) ) return false;        unsigned paletteSize, paletteEntries;        if (header.biBitCount > 8)        {            paletteEntries = 0;            paletteSize    = 0;        }        else        {            paletteSize    = (1 << header.biBitCount);            paletteEntries = paletteSize;            if (header.biClrUsed && header.biClrUsed < paletteSize)                paletteEntries = header.biClrUsed;        }        // Always create a 32-bit image to get the mask right        // Note: this is safe as rec.width, rec.height are bytes        icon = QImage( rec.width, rec.height, QImage::Format_ARGB32 );        if ( icon.isNull() ) return false;        QVector< QRgb > colorTable( paletteSize );        colorTable.fill( QRgb( 0 ) );        for ( unsigned i = 0; i < paletteEntries; ++i )        {            unsigned char rgb[ 4 ];            stream.readRawData( reinterpret_cast< char* >( &rgb ),                                 sizeof( rgb ) );            colorTable[ i ] = qRgb( rgb[ 2 ], rgb[ 1 ], rgb[ 0 ] );        }        unsigned bpl = ( rec.width * header.biBitCount + 31 ) / 32 * 4;        unsigned char* buf = new unsigned char[ bpl ];        for ( unsigned y = rec.height; !stream.atEnd() && y--; )        {            stream.readRawData( reinterpret_cast< char* >( buf ), bpl );            unsigned char* pixel = buf;            QRgb* p = reinterpret_cast< QRgb* >( icon.scanLine( y ) );            switch ( header.biBitCount )            {                case 1:                    for ( unsigned x = 0; x < rec.width; ++x )                        *p++ = colorTable[                            ( pixel[ x / 8 ] >> ( 7 - ( x & 0x07 ) ) ) & 1 ];                    break;                case 4:                    for ( unsigned x = 0; x < rec.width; ++x )                        if ( x & 1 ) *p++ = colorTable[ pixel[ x / 2 ] & 0x0f ];                        else *p++ = colorTable[ pixel[ x / 2 ] >> 4 ];                    break;                case 8:                    for ( unsigned x = 0; x < rec.width; ++x )                        *p++ = colorTable[ pixel[ x ] ];                    break;                case 24:                    for ( unsigned x = 0; x < rec.width; ++x )                        *p++ = qRgb( pixel[ 3 * x + 2 ],                                     pixel[ 3 * x + 1 ],                                     pixel[ 3 * x ] );                    break;                case 32:                    for ( unsigned x = 0; x < rec.width; ++x )                        *p++ = qRgba( pixel[ 4 * x + 2 ],                                      pixel[ 4 * x + 1 ],                                      pixel[ 4 * x ],                                      pixel[ 4 * x  + 3] );                    break;            }        }        delete[] buf;        if ( header.biBitCount < 32 )        {            // Traditional 1-bit mask            bpl = ( rec.width + 31 ) / 32 * 4;            buf = new unsigned char[ bpl ];            for ( unsigned y = rec.height; y--; )            {                stream.readRawData( reinterpret_cast< char* >( buf ), bpl );                QRgb* p = reinterpret_cast< QRgb* >( icon.scanLine( y ) );                for ( unsigned x = 0; x < rec.width; ++x, ++p )                    if ( ( ( buf[ x / 8 ] >> ( 7 - ( x & 0x07 ) ) ) & 1 ) )                        *p &= RGB_MASK;            }            delete[] buf;        }        return true;    }}ICOHandler::ICOHandler(){}bool ICOHandler::canRead() const{    return canRead(device());}bool ICOHandler::read(QImage *outImage){    qint64 offset = device()->pos();    QDataStream stream( device() );    stream.setByteOrder( QDataStream::LittleEndian );    IcoHeader header;    stream >> header;    if ( stream.atEnd() || !header.count ||         ( header.type != IcoHeader::Icon && header.type != IcoHeader::Cursor) )        return false;    unsigned requestedSize = 32;    unsigned requestedColors =  QApplication::desktop()->depth() > 8 ? 0 : QApplication::desktop()->depth();    int requestedIndex = -1;#if 0    if ( io->parameters() )    {        QStringList params = QString(io->parameters()).split( ';', QString::SkipEmptyParts );        QMap< QString, QString > options;        for ( QStringList::ConstIterator it = params.begin();              it != params.end(); ++it )        {            QStringList tmp = (*it).split( '=', QString::SkipEmptyParts );            if ( tmp.count() == 2 ) options[ tmp[ 0 ] ] = tmp[ 1 ];        }        if ( options[ "index" ].toUInt() )            requestedIndex = options[ "index" ].toUInt();        if ( options[ "size" ].toUInt() )            requestedSize = options[ "size" ].toUInt();        if ( options[ "colors" ].toUInt() )            requestedColors = options[ "colors" ].toUInt();    }#endif    typedef std::vector< IconRec > IconList;    IconList icons;    for ( unsigned i = 0; i < header.count; ++i )    {        if ( stream.atEnd() )            return false;        IconRec rec;        stream >> rec;        icons.push_back( rec );    }    IconList::const_iterator selected;    if (requestedIndex >= 0) {        selected = std::min( icons.begin() + requestedIndex, icons.end() );    } else {        selected = std::min_element( icons.begin(), icons.end(),                                     LessDifference( requestedSize, requestedColors ) );    }    if ( stream.atEnd() || selected == icons.end() ||         offset + selected->offset > device()->size() )        return false;    device()->seek( offset + selected->offset );    QImage icon;    if ( loadFromDIB( stream, *selected, icon ) )    {#ifndef QT_NO_IMAGE_TEXT        icon.setText( "X-Index", 0, QString::number( selected - icons.begin() ) );        if ( header.type == IcoHeader::Cursor )        {            icon.setText( "X-HotspotX", 0, QString::number( selected->hotspotX ) );            icon.setText( "X-HotspotY", 0, QString::number( selected->hotspotY ) );        }#endif        *outImage = icon;        return true;    }    return false;}bool ICOHandler::write(const QImage &/*image*/){#if 0    if (image.isNull())        return;    QByteArray dibData;    QDataStream dib(dibData, QIODevice::ReadWrite);    dib.setByteOrder(QDataStream::LittleEndian);    QImage pixels = image;    QImage mask;    if (io->image().hasAlphaBuffer())        mask = image.createAlphaMask();    else        mask = image.createHeuristicMask();    mask.invertPixels();    for ( int y = 0; y < pixels.height(); ++y )        for ( int x = 0; x < pixels.width(); ++x )            if ( mask.pixel( x, y ) == 0 ) pixels.setPixel( x, y, 0 );    if (!qt_write_dib(dib, pixels))        return;   uint hdrPos = dib.device()->at();    if (!qt_write_dib(dib, mask))        return;    memmove(dibData.data() + hdrPos, dibData.data() + hdrPos + BMP_WIN + 8, dibData.size() - hdrPos - BMP_WIN - 8);    dibData.resize(dibData.size() - BMP_WIN - 8);    QDataStream ico(device());    ico.setByteOrder(QDataStream::LittleEndian);    IcoHeader hdr;    hdr.reserved = 0;    hdr.type = Icon;    hdr.count = 1;    ico << hdr.reserved << hdr.type << hdr.count;    IconRec rec;    rec.width = image.width();    rec.height = image.height();    if (image.numColors() <= 16)        rec.colors = 16;    else if (image.depth() <= 8)        rec.colors = 256;    else        rec.colors = 0;    rec.hotspotX = 0;    rec.hotspotY = 0;    rec.dibSize = dibData.size();    ico << rec.width << rec.height << rec.colors        << rec.hotspotX << rec.hotspotY << rec.dibSize;    rec.dibOffset = ico.device()->at() + sizeof(rec.dibOffset);    ico << rec.dibOffset;    BMP_INFOHDR dibHeader;    dib.device()->at(0);    dib >> dibHeader;    dibHeader.biHeight = image.height() << 1;    dib.device()->at(0);    dib << dibHeader;    ico.writeRawBytes(dibData.data(), dibData.size());    return true;#endif    return false;}QByteArray ICOHandler::name() const{    return "ico";}bool ICOHandler::canRead(QIODevice *device){    if (!device) {        qWarning("ICOHandler::canRead() called with no device");        return false;    }    const qint64 oldPos = device->pos();    char head[8];    qint64 readBytes = device->read(head, sizeof(head));    const bool readOk = readBytes == sizeof(head);    if (device->isSequential()) {        while (readBytes > 0)            device->ungetChar(head[readBytes-- - 1]);    } else {        device->seek(oldPos);    }    if ( !readOk )        return false;    return head[2] == '\001' && head[3] == '\000' && // type should be 1        ( head[6] == 16 || head[6] == 32 || head[6] == 64 ) && // width can only be one of those        ( head[7] == 16 || head[7] == 32 || head[7] == 64 );   // same for height}class ICOPlugin : public QImageIOPlugin{public:    QStringList keys() const;    Capabilities capabilities(QIODevice *device, const QByteArray &format) const;    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;};QStringList ICOPlugin::keys() const{    return QStringList() << "ico" << "ICO";}QImageIOPlugin::Capabilities ICOPlugin::capabilities(QIODevice *device, const QByteArray &format) const{    if (format == "ico" || format == "ICO")        return Capabilities(CanRead);    if (!format.isEmpty())        return 0;    if (!device->isOpen())        return 0;    Capabilities cap;    if (device->isReadable() && ICOHandler::canRead(device))        cap |= CanRead;    return cap;}QImageIOHandler *ICOPlugin::create(QIODevice *device, const QByteArray &format) const{    QImageIOHandler *handler = new ICOHandler;    handler->setDevice(device);    handler->setFormat(format);    return handler;}Q_EXPORT_STATIC_PLUGIN(ICOPlugin)Q_EXPORT_PLUGIN2(qtwebico, ICOPlugin)