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

**

** 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/qdrawhelper_p.h>

#include <private/qpaintengine_raster_p.h>

#include <private/qpainter_p.h>

#include <private/qdrawhelper_x86_p.h>

#include <private/qdrawhelper_armv6_p.h>

#include <private/qmath_p.h>

#include <qmath.h>

QT_BEGIN_NAMESPACE

#define MASK(src, a) src = BYTE_MUL(src, a)

#if defined(Q_OS_IRIX) && defined(Q_CC_GNU) && __GNUC__ == 3 && __GNUC__ < 4 && QT_POINTER_SIZE == 8

#define Q_IRIX_GCC3_3_WORKAROUND

//

// work around http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14484

//

static uint gccBug(uint value) __attribute__((noinline));

static uint gccBug(uint value)

{

    return value;

}

#endif

/*

  constants and structures

*/

static const int fixed_scale = 1 << 16;

static const int half_point = 1 << 15;

static const int buffer_size = 2048;

struct LinearGradientValues

{

    qreal dx;

    qreal dy;

    qreal l;

    qreal off;

};

struct RadialGradientValues

{

    qreal dx;

    qreal dy;

    qreal a;

};

struct Operator;

typedef uint* (QT_FASTCALL *DestFetchProc)(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length);

typedef void (QT_FASTCALL *DestStoreProc)(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length);

typedef const uint* (QT_FASTCALL *SourceFetchProc)(uint *buffer, const Operator *o, const QSpanData *data, int y, int x, int length);

struct Operator

{

    QPainter::CompositionMode mode;

    DestFetchProc dest_fetch;

    DestStoreProc dest_store;

    SourceFetchProc src_fetch;

    CompositionFunctionSolid funcSolid;

    CompositionFunction func;

    union {

        LinearGradientValues linear;

        RadialGradientValues radial;

//        TextureValues texture;

    };

};

/*

  Destination fetch. This is simple as we don't have to do bounds checks or

  transformations

*/

static uint * QT_FASTCALL destFetchMono(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)

{

    uchar *data = (uchar *)rasterBuffer->scanLine(y);

    uint *start = buffer;

    const uint *end = buffer + length;

    while (buffer < end) {

        *buffer = data[x>>3] & (0x80 >> (x & 7)) ? rasterBuffer->destColor1 : rasterBuffer->destColor0;

        ++buffer;

        ++x;

    }

    return start;

}

static uint * QT_FASTCALL destFetchMonoLsb(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)

{

    uchar *data = (uchar *)rasterBuffer->scanLine(y);

    uint *start = buffer;

    const uint *end = buffer + length;

    while (buffer < end) {

        *buffer = data[x>>3] & (0x1 << (x & 7)) ? rasterBuffer->destColor1 : rasterBuffer->destColor0;

        ++buffer;

        ++x;

    }

    return start;

}

static uint * QT_FASTCALL destFetchARGB32(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)

{

    const uint *data = (const uint *)rasterBuffer->scanLine(y) + x;

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

        buffer[i] = PREMUL(data[i]);

    return buffer;

}

static uint * QT_FASTCALL destFetchARGB32P(uint *, QRasterBuffer *rasterBuffer, int x, int y, int)

{

    return (uint *)rasterBuffer->scanLine(y) + x;

}

static uint * QT_FASTCALL destFetchRGB16(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)

{

    const ushort *data = (const ushort *)rasterBuffer->scanLine(y) + x;

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

        buffer[i] = qConvertRgb16To32(data[i]);

    return buffer;

}

template <class DST>

Q_STATIC_TEMPLATE_FUNCTION uint * QT_FASTCALL destFetch(uint *buffer, QRasterBuffer *rasterBuffer,

                                    int x, int y, int length)

{

    const DST *src = reinterpret_cast<DST*>(rasterBuffer->scanLine(y)) + x;

    quint32 *dest = reinterpret_cast<quint32*>(buffer);

    while (length--)

        *dest++ = *src++;

    return buffer;

}

# define SPANFUNC_POINTER_DESTFETCH(Arg) destFetch<Arg>

static const DestFetchProc destFetchProc[QImage::NImageFormats] =

{

    0, // Format_Invalid

    destFetchMono, // Format_Mono,

    destFetchMonoLsb, // Format_MonoLSB

    0, // Format_Indexed8

    destFetchARGB32P, // Format_RGB32

    destFetchARGB32, // Format_ARGB32,

    destFetchARGB32P, // Format_ARGB32_Premultiplied

    destFetchRGB16,   // Format_RGB16

    SPANFUNC_POINTER_DESTFETCH(qargb8565), // Format_ARGB8565_Premultiplied

    SPANFUNC_POINTER_DESTFETCH(qrgb666),   // Format_RGB666

    SPANFUNC_POINTER_DESTFETCH(qargb6666), // Format_ARGB6666_Premultiplied

    SPANFUNC_POINTER_DESTFETCH(qrgb555),   // Format_RGB555

    SPANFUNC_POINTER_DESTFETCH(qargb8555), // Format_ARGB8555_Premultiplied

    SPANFUNC_POINTER_DESTFETCH(qrgb888),   // Format_RGB888

    SPANFUNC_POINTER_DESTFETCH(qrgb444),   // Format_RGB444

    SPANFUNC_POINTER_DESTFETCH(qargb4444)  // Format_ARGB4444_Premultiplied

};

/*

   Returns the color in the mono destination color table

   that is the "nearest" to /color/.

*/

static inline QRgb findNearestColor(QRgb color, QRasterBuffer *rbuf)

{

    QRgb color_0 = PREMUL(rbuf->destColor0);

    QRgb color_1 = PREMUL(rbuf->destColor1);

    color = PREMUL(color);

    int r = qRed(color);

    int g = qGreen(color);

    int b = qBlue(color);

    int rx, gx, bx;

    int dist_0, dist_1;

    rx = r - qRed(color_0);

    gx = g - qGreen(color_0);

    bx = b - qBlue(color_0);

    dist_0 = rx*rx + gx*gx + bx*bx;

    rx = r - qRed(color_1);

    gx = g - qGreen(color_1);

    bx = b - qBlue(color_1);

    dist_1 = rx*rx + gx*gx + bx*bx;

    if (dist_0 < dist_1)

        return color_0;

    return color_1;

}

/*

  Destination store.

*/

static void QT_FASTCALL destStoreMono(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)

{

    uchar *data = (uchar *)rasterBuffer->scanLine(y);

    if (rasterBuffer->monoDestinationWithClut) {

        for (int i = 0; i < length; ++i) {

            if (buffer[i] == rasterBuffer->destColor0) {

                data[x >> 3] &= ~(0x80 >> (x & 7));

            } else if (buffer[i] == rasterBuffer->destColor1) {

                data[x >> 3] |= 0x80 >> (x & 7);

            } else if (findNearestColor(buffer[i], rasterBuffer) == rasterBuffer->destColor0) {

                data[x >> 3] &= ~(0x80 >> (x & 7));

            } else {

                data[x >> 3] |= 0x80 >> (x & 7);

            }

            ++x;

        }

    } else {

        for (int i = 0; i < length; ++i) {

            if (qGray(buffer[i]) < int(qt_bayer_matrix[y & 15][x & 15]))

                data[x >> 3] |= 0x80 >> (x & 7);

            else

                data[x >> 3] &= ~(0x80 >> (x & 7));

            ++x;

        }

    }

}

static void QT_FASTCALL destStoreMonoLsb(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)

{

    uchar *data = (uchar *)rasterBuffer->scanLine(y);

    if (rasterBuffer->monoDestinationWithClut) {

        for (int i = 0; i < length; ++i) {

            if (buffer[i] == rasterBuffer->destColor0) {

                data[x >> 3] &= ~(1 << (x & 7));

            } else if (buffer[i] == rasterBuffer->destColor1) {

                data[x >> 3] |= 1 << (x & 7);

            } else if (findNearestColor(buffer[i], rasterBuffer) == rasterBuffer->destColor0) {

                data[x >> 3] &= ~(1 << (x & 7));

            } else {

                data[x >> 3] |= 1 << (x & 7);

            }

            ++x;

        }

    } else {

        for (int i = 0; i < length; ++i) {

            if (qGray(buffer[i]) < int(qt_bayer_matrix[y & 15][x & 15]))

                data[x >> 3] |= 1 << (x & 7);

            else

                data[x >> 3] &= ~(1 << (x & 7));

            ++x;

        }

    }

}

static void QT_FASTCALL destStoreARGB32(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)

{

    uint *data = (uint *)rasterBuffer->scanLine(y) + x;

    for (int i = 0; i < length; ++i) {

        int p = buffer[i];

        int alpha = qAlpha(p);

        if (alpha == 255)

            data[i] = p;

        else if (alpha == 0)

            data[i] = 0;

        else {

            int inv_alpha = 0xff0000/qAlpha(buffer[i]);

            data[i] = (p & 0xff000000)

                      | ((qRed(p)*inv_alpha) & 0xff0000)

                      | (((qGreen(p)*inv_alpha) >> 8) & 0xff00)

                      | ((qBlue(p)*inv_alpha) >> 16);

        }

    }

}

static void QT_FASTCALL destStoreRGB16(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)

{

    quint16 *data = (quint16*)rasterBuffer->scanLine(y) + x;

    qt_memconvert<quint16, quint32>(data, buffer, length);

}

template <class DST>

Q_STATIC_TEMPLATE_FUNCTION void QT_FASTCALL destStore(QRasterBuffer *rasterBuffer,

                                  int x, int y,

                                  const uint *buffer, int length)

{

    DST *dest = reinterpret_cast<DST*>(rasterBuffer->scanLine(y)) + x;

    const quint32p *src = reinterpret_cast<const quint32p*>(buffer);

    while (length--)

        *dest++ = DST(*src++);

}

# define SPANFUNC_POINTER_DESTSTORE(DEST) destStore<DEST>

static const DestStoreProc destStoreProc[QImage::NImageFormats] =

{

    0, // Format_Invalid

    destStoreMono, // Format_Mono,

    destStoreMonoLsb, // Format_MonoLSB

    0, // Format_Indexed8

    0, // Format_RGB32

    destStoreARGB32, // Format_ARGB32,

    0, // Format_ARGB32_Premultiplied

    destStoreRGB16, // Format_RGB16

    SPANFUNC_POINTER_DESTSTORE(qargb8565), // Format_ARGB8565_Premultiplied

    SPANFUNC_POINTER_DESTSTORE(qrgb666),   // Format_RGB666

    SPANFUNC_POINTER_DESTSTORE(qargb6666), // Format_ARGB6666_Premultiplied

    SPANFUNC_POINTER_DESTSTORE(qrgb555),   // Format_RGB555

    SPANFUNC_POINTER_DESTSTORE(qargb8555), // Format_ARGB8555_Premultiplied

    SPANFUNC_POINTER_DESTSTORE(qrgb888),   // Format_RGB888

    SPANFUNC_POINTER_DESTSTORE(qrgb444),   // Format_RGB444

    SPANFUNC_POINTER_DESTSTORE(qargb4444)  // Format_ARGB4444_Premultiplied

};

/*

  Source fetches

  This is a bit more complicated, as we need several fetch routines for every surface type

  We need 5 fetch methods per surface type:

  untransformed

  transformed (tiled and not tiled)

  transformed bilinear (tiled and not tiled)

  We don't need bounds checks for untransformed, but we need them for the other ones.

  The generic implementation does pixel by pixel fetches

*/

template <QImage::Format format>

Q_STATIC_TEMPLATE_FUNCTION uint QT_FASTCALL qt_fetchPixel(const uchar *scanLine, int x, const QVector<QRgb> *rgb);

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_Mono>(const uchar *scanLine,

                                                 int x, const QVector<QRgb> *rgb)

{

    bool pixel = scanLine[x>>3] & (0x80 >> (x & 7));

    if (rgb) return PREMUL(rgb->at(pixel ? 1 : 0));

    return pixel ? 0xff000000 : 0xffffffff;

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_MonoLSB>(const uchar *scanLine,

                                                    int x, const QVector<QRgb> *rgb)

{

    bool pixel = scanLine[x>>3] & (0x1 << (x & 7));

    if (rgb) return PREMUL(rgb->at(pixel ? 1 : 0));

    return pixel ? 0xff000000 : 0xffffffff;

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_Indexed8>(const uchar *scanLine,

                                                     int x, const QVector<QRgb> *rgb)

{

    return PREMUL(rgb->at(scanLine[x]));

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB32>(const uchar *scanLine,

                                                   int x, const QVector<QRgb> *)

{

    return PREMUL(((const uint *)scanLine)[x]);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB32_Premultiplied>(const uchar *scanLine,

                                                                 int x, const QVector<QRgb> *)

{

    return ((const uint *)scanLine)[x];

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB16>(const uchar *scanLine,

                                                  int x, const QVector<QRgb> *)

{

    return qConvertRgb16To32(((const ushort *)scanLine)[x]);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB8565_Premultiplied>(const uchar *scanLine,

                                                     int x,

                                                     const QVector<QRgb> *)

{

    const qargb8565 color = reinterpret_cast<const qargb8565*>(scanLine)[x];

    return qt_colorConvert<quint32, qargb8565>(color, 0);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB666>(const uchar *scanLine,

                                                   int x,

                                                   const QVector<QRgb> *)

{

    const qrgb666 color = reinterpret_cast<const qrgb666*>(scanLine)[x];

    return qt_colorConvert<quint32, qrgb666>(color, 0);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB6666_Premultiplied>(const uchar *scanLine,

                                                   int x,

                                                   const QVector<QRgb> *)

{

    const qargb6666 color = reinterpret_cast<const qargb6666*>(scanLine)[x];

    return qt_colorConvert<quint32, qargb6666>(color, 0);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB555>(const uchar *scanLine,

                                                   int x,

                                                   const QVector<QRgb> *)

{

    const qrgb555 color = reinterpret_cast<const qrgb555*>(scanLine)[x];

    return qt_colorConvert<quint32, qrgb555>(color, 0);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB8555_Premultiplied>(const uchar *scanLine,

                                                     int x,

                                                     const QVector<QRgb> *)

{

    const qargb8555 color = reinterpret_cast<const qargb8555*>(scanLine)[x];

    return qt_colorConvert<quint32, qargb8555>(color, 0);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB888>(const uchar *scanLine,

                                                   int x,

                                                   const QVector<QRgb> *)

{

    const qrgb888 color = reinterpret_cast<const qrgb888*>(scanLine)[x];

    return qt_colorConvert<quint32, qrgb888>(color, 0);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB444>(const uchar *scanLine,

                                                   int x,

                                                   const QVector<QRgb> *)

{

    const qrgb444 color = reinterpret_cast<const qrgb444*>(scanLine)[x];

    return qt_colorConvert<quint32, qrgb444>(color, 0);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB4444_Premultiplied>(const uchar *scanLine,

                                                     int x,

                                                     const QVector<QRgb> *)

{

    const qargb4444 color = reinterpret_cast<const qargb4444*>(scanLine)[x];

    return qt_colorConvert<quint32, qargb4444>(color, 0);

}

template<>

Q_STATIC_TEMPLATE_SPECIALIZATION

uint QT_FASTCALL qt_fetchPixel<QImage::Format_Invalid>(const uchar *,

                                                     int ,

                                                     const QVector<QRgb> *)

{

    return 0;

}

typedef uint (QT_FASTCALL *FetchPixelProc)(const uchar *scanLine, int x, const QVector<QRgb> *);

#define SPANFUNC_POINTER_FETCHPIXEL(Arg) qt_fetchPixel<QImage::Arg>

static const FetchPixelProc fetchPixelProc[QImage::NImageFormats] =

{

    0,

    SPANFUNC_POINTER_FETCHPIXEL(Format_Mono),

    SPANFUNC_POINTER_FETCHPIXEL(Format_MonoLSB),

    SPANFUNC_POINTER_FETCHPIXEL(Format_Indexed8),

    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB32_Premultiplied),

    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB32),

    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB32_Premultiplied),

    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB16),

    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB8565_Premultiplied),

    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB666),

    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB6666_Premultiplied),

    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB555),

    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB8555_Premultiplied),

    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB888),

    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB444),

    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB4444_Premultiplied)

};

enum TextureBlendType {