/*

 * 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 Trolltech AS.

    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)