/****************************************************************************

**

** 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 "qimage.h"

#include "qdatastream.h"

#include "qbuffer.h"

#include "qmap.h"

#include "qmatrix.h"

#include "qtransform.h"

#include "qimagereader.h"

#include "qimagewriter.h"

#include "qstringlist.h"

#include "qvariant.h"

#include "qimagepixmapcleanuphooks_p.h"

#include <ctype.h>

#include <stdlib.h>

#include <limits.h>

#include <math.h>

#include <private/qdrawhelper_p.h>

#include <private/qmemrotate_p.h>

#include <private/qpixmapdata_p.h>

#include <private/qimagescale_p.h>

#include <qhash.h>

#include <private/qpaintengine_raster_p.h>

#include <private/qimage_p.h>

QT_BEGIN_NAMESPACE

static inline bool checkPixelSize(const QImage::Format format)

{

    switch (format) {

    case QImage::Format_ARGB8565_Premultiplied:

        return (sizeof(qargb8565) == 3);

    case QImage::Format_RGB666:

        return (sizeof(qrgb666) == 3);

    case QImage::Format_ARGB6666_Premultiplied:

        return (sizeof(qargb6666) == 3);

    case QImage::Format_RGB555:

        return (sizeof(qrgb555) == 2);

    case QImage::Format_ARGB8555_Premultiplied:

        return (sizeof(qargb8555) == 3);

    case QImage::Format_RGB888:

        return (sizeof(qrgb888) == 3);

    case QImage::Format_RGB444:

        return (sizeof(qrgb444) == 2);

    case QImage::Format_ARGB4444_Premultiplied:

        return (sizeof(qargb4444) == 2);

    default:

        return true;

    }

}

#if defined(Q_CC_DEC) && defined(__alpha) && (__DECCXX_VER-0 >= 50190001)

#pragma message disable narrowptr

#endif

#define QIMAGE_SANITYCHECK_MEMORY(image) \

    if ((image).isNull()) { \

        qWarning("QImage: out of memory, returning null image"); \

        return QImage(); \

    }

static QImage rotated90(const QImage &src);

static QImage rotated180(const QImage &src);

static QImage rotated270(const QImage &src);

// ### Qt 5: remove

Q_GUI_EXPORT qint64 qt_image_id(const QImage &image)

{

    return image.cacheKey();

}

const QVector<QRgb> *qt_image_colortable(const QImage &image)

{

    return &image.d->colortable;

}

extern int qt_defaultDpiX();

extern int qt_defaultDpiY();

QBasicAtomicInt qimage_serial_number = Q_BASIC_ATOMIC_INITIALIZER(1);

QImageData::QImageData()

    : ref(0), width(0), height(0), depth(0), nbytes(0), data(0),

#ifdef QT3_SUPPORT

      jumptable(0),

#endif

      format(QImage::Format_ARGB32), bytes_per_line(0),

      ser_no(qimage_serial_number.fetchAndAddRelaxed(1)),

      detach_no(0),

      dpmx(qt_defaultDpiX() * 100 / qreal(2.54)),

      dpmy(qt_defaultDpiY() * 100 / qreal(2.54)),

      offset(0, 0), own_data(true), ro_data(false), has_alpha_clut(false),

      is_cached(false), paintEngine(0)

{

}

static int depthForFormat(QImage::Format format)

{

    int depth = 0;

    switch(format) {

    case QImage::Format_Invalid:

    case QImage::NImageFormats:

        Q_ASSERT(false);

    case QImage::Format_Mono:

    case QImage::Format_MonoLSB:

        depth = 1;

        break;

    case QImage::Format_Indexed8:

        depth = 8;

        break;

    case QImage::Format_RGB32:

    case QImage::Format_ARGB32:

    case QImage::Format_ARGB32_Premultiplied:

        depth = 32;

        break;

    case QImage::Format_RGB555:

    case QImage::Format_RGB16:

    case QImage::Format_RGB444:

    case QImage::Format_ARGB4444_Premultiplied:

        depth = 16;

        break;

    case QImage::Format_RGB666:

    case QImage::Format_ARGB6666_Premultiplied:

    case QImage::Format_ARGB8565_Premultiplied:

    case QImage::Format_ARGB8555_Premultiplied:

    case QImage::Format_RGB888:

        depth = 24;

        break;

    }

    return depth;

}

/*! \fn QImageData * QImageData::create(const QSize &size, QImage::Format format, int numColors)

    \internal

    Creates a new image data.

    Returns 0 if invalid parameters are give or anything else failed.

*/

QImageData * QImageData::create(const QSize &size, QImage::Format format, int numColors)

{

    if (!size.isValid() || numColors < 0 || format == QImage::Format_Invalid)

        return 0;                                // invalid parameter(s)

    if (!checkPixelSize(format)) {

        qWarning("QImageData::create(): Invalid pixel size for format %i",

                 format);

        return 0;

    }

    uint width = size.width();

    uint height = size.height();

    uint depth = depthForFormat(format);

    switch (format) {

    case QImage::Format_Mono:

    case QImage::Format_MonoLSB:

        numColors = 2;

        break;

    case QImage::Format_Indexed8:

        numColors = qBound(0, numColors, 256);

        break;

    default:

        numColors = 0;

        break;

    }

    const int bytes_per_line = ((width * depth + 31) >> 5) << 2; // bytes per scanline (must be multiple of 8)

    // sanity check for potential overflows

    if (INT_MAX/depth < width

        || bytes_per_line <= 0

        || height <= 0

        || INT_MAX/uint(bytes_per_line) < height

        || INT_MAX/sizeof(uchar *) < uint(height))

        return 0;

    QScopedPointer<QImageData> d(new QImageData);

    d->colortable.resize(numColors);

    if (depth == 1) {

        d->colortable[0] = QColor(Qt::black).rgba();

        d->colortable[1] = QColor(Qt::white).rgba();

    } else {

        for (int i = 0; i < numColors; ++i)

            d->colortable[i] = 0;

    }

    d->width = width;

    d->height = height;

    d->depth = depth;

    d->format = format;

    d->has_alpha_clut = false;

    d->is_cached = false;

    d->bytes_per_line = bytes_per_line;

    d->nbytes = d->bytes_per_line*height;

    d->data  = (uchar *)malloc(d->nbytes);

    if (!d->data) {

        return 0;

    }

    d->ref.ref();

    return d.take();

}

QImageData::~QImageData()

{

    if (is_cached)

        QImagePixmapCleanupHooks::executeImageHooks((((qint64) ser_no) << 32) | ((qint64) detach_no));

    delete paintEngine;

    if (data && own_data)

        free(data);

#ifdef QT3_SUPPORT

    if (jumptable)

        free(jumptable);

    jumptable = 0;

#endif

    data = 0;

}

bool QImageData::checkForAlphaPixels() const

{

    bool has_alpha_pixels = false;

    switch (format) {

    case QImage::Format_Indexed8:

        has_alpha_pixels = has_alpha_clut;

        break;

    case QImage::Format_ARGB32:

    case QImage::Format_ARGB32_Premultiplied: {

        uchar *bits = data;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            for (int x=0; x<width; ++x)

                has_alpha_pixels |= (((uint *)bits)[x] & 0xff000000) != 0xff000000;

            bits += bytes_per_line;

        }

    } break;

    case QImage::Format_ARGB8555_Premultiplied:

    case QImage::Format_ARGB8565_Premultiplied: {

        uchar *bits = data;

        uchar *end_bits = data + bytes_per_line;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            while (bits < end_bits) {

                has_alpha_pixels |= bits[0] != 0;

                bits += 3;

            }

            bits = end_bits;

            end_bits += bytes_per_line;

        }

    } break;

    case QImage::Format_ARGB6666_Premultiplied: {

        uchar *bits = data;

        uchar *end_bits = data + bytes_per_line;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            while (bits < end_bits) {

                has_alpha_pixels |= (bits[0] & 0xfc) != 0;

                bits += 3;

            }

            bits = end_bits;

            end_bits += bytes_per_line;

        }

    } break;

    case QImage::Format_ARGB4444_Premultiplied: {

        uchar *bits = data;

        uchar *end_bits = data + bytes_per_line;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            while (bits < end_bits) {

                has_alpha_pixels |= (bits[0] & 0xf0) != 0;

                bits += 2;

            }

            bits = end_bits;

            end_bits += bytes_per_line;

        }

    } break;

    default:

        break;

    }

    return has_alpha_pixels;

}

/*!

    \class QImage

    \ingroup painting

    \ingroup shared

    \reentrant

    \brief The QImage class provides a hardware-independent image

    representation that allows direct access to the pixel data, and

    can be used as a paint device.

    Qt provides four classes for handling image data: QImage, QPixmap,

    QBitmap and QPicture.  QImage is designed and optimized for I/O,

    and for direct pixel access and manipulation, while QPixmap is

    designed and optimized for showing images on screen. QBitmap is

    only a convenience class that inherits QPixmap, ensuring a

    depth of 1. Finally, the QPicture class is a paint device that

    records and replays QPainter commands.

    Because QImage is a QPaintDevice subclass, QPainter can be used to

    draw directly onto images.  When using QPainter on a QImage, the

    painting can be performed in another thread than the current GUI

    thread.

    The QImage class supports several image formats described by the

    \l Format enum. These include monochrome, 8-bit, 32-bit and

    alpha-blended images which are available in all versions of Qt

    4.x.

    QImage provides a collection of functions that can be used to

    obtain a variety of information about the image. There are also

    several functions that enables transformation of the image.

    QImage objects can be passed around by value since the QImage

    class uses \l{Implicit Data Sharing}{implicit data

    sharing}. QImage objects can also be streamed and compared.

    \note If you would like to load QImage objects in a static build of Qt,

    refer to the \l{How To Create Qt Plugins#Static Plugins}{Plugin HowTo}.

    \warning Painting on a QImage with the format

    QImage::Format_Indexed8 is not supported.

    \tableofcontents

    \section1 Reading and Writing Image Files

    QImage provides several ways of loading an image file: The file

    can be loaded when constructing the QImage object, or by using the

    load() or loadFromData() functions later on. QImage also provides

    the static fromData() function, constructing a QImage from the

    given data.  When loading an image, the file name can either refer

    to an actual file on disk or to one of the application's embedded

    resources. See \l{The Qt Resource System} overview for details

    on how to embed images and other resource files in the

    application's executable.

    Simply call the save() function to save a QImage object.

    The complete list of supported file formats are available through

    the QImageReader::supportedImageFormats() and

    QImageWriter::supportedImageFormats() functions. New file formats

    can be added as plugins. By default, Qt supports the following

    formats:

    \table

    \header \o Format \o Description                      \o Qt's support

    \row    \o BMP    \o Windows Bitmap                   \o Read/write

    \row    \o GIF    \o Graphic Interchange Format (optional) \o Read

    \row    \o JPG    \o Joint Photographic Experts Group \o Read/write

    \row    \o JPEG   \o Joint Photographic Experts Group \o Read/write

    \row    \o PNG    \o Portable Network Graphics        \o Read/write

    \row    \o PBM    \o Portable Bitmap                  \o Read

    \row    \o PGM    \o Portable Graymap                 \o Read

    \row    \o PPM    \o Portable Pixmap                  \o Read/write

    \row    \o TIFF   \o Tagged Image File Format         \o Read/write

    \row    \o XBM    \o X11 Bitmap                       \o Read/write

    \row    \o XPM    \o X11 Pixmap                       \o Read/write

    \endtable

    \section1 Image Information

    QImage provides a collection of functions that can be used to

    obtain a variety of information about the image:

    \table

    \header

    \o \o Available Functions

    \row

    \o Geometry

    \o

    The size(), width(), height(), dotsPerMeterX(), and

    dotsPerMeterY() functions provide information about the image size

    and aspect ratio.

    The rect() function returns the image's enclosing rectangle. The

    valid() function tells if a given pair of coordinates is within

    this rectangle. The offset() function returns the number of pixels

    by which the image is intended to be offset by when positioned

    relative to other images, which also can be manipulated using the

    setOffset() function.

    \row

    \o Colors

    \o

    The color of a pixel can be retrieved by passing its coordinates

    to the pixel() function.  The pixel() function returns the color

    as a QRgb value indepedent of the image's format.

    In case of monochrome and 8-bit images, the colorCount() and

    colorTable() functions provide information about the color

    components used to store the image data: The colorTable() function

    returns the image's entire color table. To obtain a single entry,

    use the pixelIndex() function to retrieve the pixel index for a

    given pair of coordinates, then use the color() function to

    retrieve the color. Note that if you create an 8-bit image

    manually, you have to set a valid color table on the image as

    well.

    The hasAlphaChannel() function tells if the image's format

    respects the alpha channel, or not. The allGray() and

    isGrayscale() functions tell whether an image's colors are all

    shades of gray.

    See also the \l {QImage#Pixel Manipulation}{Pixel Manipulation}

    and \l {QImage#Image Transformations}{Image Transformations}

    sections.

    \row

    \o Text

    \o

    The text() function returns the image text associated with the

    given text key. An image's text keys can be retrieved using the

    textKeys() function. Use the setText() function to alter an

    image's text.

    \row

    \o Low-level information

    \o

    The depth() function returns the depth of the image. The supported

    depths are 1 (monochrome), 8 and 32 (for more information see the

    \l {QImage#Image Formats}{Image Formats} section).

    The format(), bytesPerLine(), and byteCount() functions provide

    low-level information about the data stored in the image.

    The cacheKey() function returns a number that uniquely

    identifies the contents of this QImage object.

    \endtable

    \section1 Pixel Manipulation

    The functions used to manipulate an image's pixels depend on the

    image format. The reason is that monochrome and 8-bit images are

    index-based and use a color lookup table, while 32-bit images

    store ARGB values directly. For more information on image formats,

    see the \l {Image Formats} section.

    In case of a 32-bit image, the setPixel() function can be used to

    alter the color of the pixel at the given coordinates to any other

    color specified as an ARGB quadruplet. To make a suitable QRgb

    value, use the qRgb() (adding a default alpha component to the

    given RGB values, i.e. creating an opaque color) or qRgba()

    function. For example:

    \table

    \row

    \o \inlineimage qimage-32bit_scaled.png

    \o

    \snippet doc/src/snippets/code/src_gui_image_qimage.cpp 0

    \header

    \o {2,1}32-bit

    \endtable

    In case of a 8-bit and monchrome images, the pixel value is only

    an index from the image's color table. So the setPixel() function

    can only be used to alter the color of the pixel at the given

    coordinates to a predefined color from the image's color table,

    i.e. it can only change the pixel's index value. To alter or add a

    color to an image's color table, use the setColor() function.

    An entry in the color table is an ARGB quadruplet encoded as an

    QRgb value. Use the qRgb() and qRgba() functions to make a

    suitable QRgb value for use with the setColor() function. For