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

**

** Copyright (C) 2010 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$

**

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

#ifndef QDRAWHELPER_P_H

#define QDRAWHELPER_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "QtCore/qglobal.h"

#include "QtGui/qcolor.h"

#include "QtGui/qpainter.h"

#include "QtGui/qimage.h"

#ifndef QT_FT_BEGIN_HEADER

#define QT_FT_BEGIN_HEADER

#define QT_FT_END_HEADER

#endif

#include "private/qrasterdefs_p.h"

#ifdef Q_WS_QWS

#include "QtGui/qscreen_qws.h"

#endif

#undef QT_HAVE_SSE

#undef QT_HAVE_3DNOW

#endif

#if defined(Q_CC_MSVC) && _MSCVER <= 1300 && !defined(Q_CC_INTEL)

#define Q_STATIC_TEMPLATE_SPECIALIZATION static

#else

#define Q_STATIC_TEMPLATE_SPECIALIZATION

#endif

#if defined(Q_CC_RVCT)

// RVCT doesn't like static template functions

#  define Q_STATIC_TEMPLATE_FUNCTION

#  define Q_STATIC_INLINE_FUNCTION static __forceinline

#else

#  define Q_STATIC_TEMPLATE_FUNCTION static

#  define Q_STATIC_INLINE_FUNCTION static inline

#endif

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

 * QSpan

 *

 * duplicate definition of FT_Span

 */

typedef QT_FT_Span QSpan;

struct QSolidData;

struct QTextureData;

struct QGradientData;

struct QLinearGradientData;

struct QRadialGradientData;

struct QConicalGradientData;

struct QSpanData;

class QGradient;

class QRasterBuffer;

class QClipData;

class QRasterPaintEngineState;

typedef QT_FT_SpanFunc ProcessSpans;

typedef void (*BitmapBlitFunc)(QRasterBuffer *rasterBuffer,

                               int x, int y, quint32 color,

                               const uchar *bitmap,

                               int mapWidth, int mapHeight, int mapStride);

typedef void (*AlphamapBlitFunc)(QRasterBuffer *rasterBuffer,

                                 int x, int y, quint32 color,

                                 const uchar *bitmap,

                                 int mapWidth, int mapHeight, int mapStride,

                                 const QClipData *clip);

typedef void (*AlphaRGBBlitFunc)(QRasterBuffer *rasterBuffer,

                                 int x, int y, quint32 color,

                                 const uint *rgbmask,

                                 int mapWidth, int mapHeight, int mapStride,

                                 const QClipData *clip);

typedef void (*RectFillFunc)(QRasterBuffer *rasterBuffer,

                             int x, int y, int width, int height,

                             quint32 color);

typedef void (*SrcOverBlendFunc)(uchar *destPixels, int dbpl,

                                 const uchar *src, int spbl,

                                 int w, int h,

                                 int const_alpha);

typedef void (*SrcOverScaleFunc)(uchar *destPixels, int dbpl,

                                 const uchar *src, int spbl,

                                 const QRectF &targetRect,

                                 const QRectF &sourceRect,

                                 const QRect &clipRect,

                                 int const_alpha);

typedef void (*SrcOverTransformFunc)(uchar *destPixels, int dbpl,

                                     const uchar *src, int spbl,

                                     const QRectF &targetRect,

                                     const QRectF &sourceRect,

                                     const QRect &clipRect,

                                     const QTransform &targetRectTransform,

                                     int const_alpha);

struct DrawHelper {

    ProcessSpans blendColor;

    ProcessSpans blendGradient;

    BitmapBlitFunc bitmapBlit;

    AlphamapBlitFunc alphamapBlit;

    AlphaRGBBlitFunc alphaRGBBlit;

    RectFillFunc fillRect;

};

extern SrcOverBlendFunc qBlendFunctions[QImage::NImageFormats][QImage::NImageFormats];

extern SrcOverScaleFunc qScaleFunctions[QImage::NImageFormats][QImage::NImageFormats];

extern SrcOverTransformFunc qTransformFunctions[QImage::NImageFormats][QImage::NImageFormats];

extern DrawHelper qDrawHelper[QImage::NImageFormats];

void qBlendTexture(int count, const QSpan *spans, void *userData);

#if defined(Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)

extern DrawHelper qDrawHelperCallback[QImage::NImageFormats];

void qBlendTextureCallback(int count, const QSpan *spans, void *userData);

#endif

typedef void (QT_FASTCALL *CompositionFunction)(uint *dest, const uint *src, int length, uint const_alpha);

typedef void (QT_FASTCALL *CompositionFunctionSolid)(uint *dest, int length, uint color, uint const_alpha);

void qInitDrawhelperAsm();

class QRasterPaintEngine;

struct QSolidData

{

    uint color;

};

struct QLinearGradientData

{

    struct {

        qreal x;

        qreal y;

    } origin;

    struct {

        qreal x;

        qreal y;

    } end;

};

struct QRadialGradientData

{

    struct {

        qreal x;

        qreal y;

    } center;

    struct {

        qreal x;

        qreal y;

    } focal;

    qreal radius;

};

struct QConicalGradientData

{

    struct {

        qreal x;

        qreal y;

    } center;

    qreal angle;

};

struct QGradientData

{

    QGradient::Spread spread;

    union {

        QLinearGradientData linear;

        QRadialGradientData radial;

        QConicalGradientData conical;

    };

#ifdef Q_WS_QWS

#define GRADIENT_STOPTABLE_SIZE 256

#else

#define GRADIENT_STOPTABLE_SIZE 1024

#endif

    uint* colorTable; //[GRADIENT_STOPTABLE_SIZE];

    uint alphaColor : 1;

};

struct QTextureData

{

    const uchar *imageData;

    const uchar *scanLine(int y) const { return imageData + y*bytesPerLine; }

    int width;

    int height;

    // clip rect

    int x1;

    int y1;

    int x2;

    int y2;

    int bytesPerLine;

    QImage::Format format;

    const QVector<QRgb> *colorTable;

    bool hasAlpha;

    enum Type {

        Plain,

        Tiled

    };

    Type type;

    int const_alpha;

};

struct QSpanData

{

    QSpanData() : tempImage(0) {}

    ~QSpanData() { delete tempImage; }

    QRasterBuffer *rasterBuffer;

#ifdef Q_WS_QWS

    QRasterPaintEngine *rasterEngine;

#endif

    ProcessSpans blend;

    ProcessSpans unclipped_blend;

    BitmapBlitFunc bitmapBlit;

    AlphamapBlitFunc alphamapBlit;

    AlphaRGBBlitFunc alphaRGBBlit;

    RectFillFunc fillRect;

    qreal m11, m12, m13, m21, m22, m23, m33, dx, dy;   // inverse xform matrix

    const QClipData *clip;

    enum Type {

        None,

        Solid,

        LinearGradient,

        RadialGradient,

        ConicalGradient,

        Texture

    } type : 8;

    int txop : 8;

    int fast_matrix : 1;

    bool bilinear;

    QImage *tempImage;

    union {

        QSolidData solid;

        QGradientData gradient;

        QTextureData texture;

    };

    void init(QRasterBuffer *rb, const QRasterPaintEngine *pe);

    void setup(const QBrush &brush, int alpha, QPainter::CompositionMode compositionMode);

    void setupMatrix(const QTransform &matrix, int bilinear);

    void initTexture(const QImage *image, int alpha, QTextureData::Type = QTextureData::Plain, const QRect &sourceRect = QRect());

    void adjustSpanMethods();

};

Q_STATIC_INLINE_FUNCTION uint BYTE_MUL_RGB16(uint x, uint a) {

    a += 1;

    uint t = (((x & 0x07e0)*a) >> 8) & 0x07e0;

    t |= (((x & 0xf81f)*(a>>2)) >> 6) & 0xf81f;

    return t;

}

Q_STATIC_INLINE_FUNCTION uint BYTE_MUL_RGB16_32(uint x, uint a) {

    uint t = (((x & 0xf81f07e0) >> 5)*a) & 0xf81f07e0;

    t |= (((x & 0x07e0f81f)*a) >> 5) & 0x07e0f81f;

    return t;

}

#if defined(Q_CC_RVCT)

#  pragma push

#  pragma arm

#endif

Q_STATIC_INLINE_FUNCTION uint BYTE_MUL(uint x, uint a) {

    uint t = (x & 0xff00ff) * a;

    t = (t + ((t >> 8) & 0xff00ff) + 0x800080) >> 8;

    t &= 0xff00ff;

    x = ((x >> 8) & 0xff00ff) * a;

    x = (x + ((x >> 8) & 0xff00ff) + 0x800080);

    x &= 0xff00ff00;

    x |= t;

    return x;

}

#if defined(Q_CC_RVCT)

#  pragma pop

#endif

Q_STATIC_INLINE_FUNCTION uint PREMUL(uint x) {

    uint a = x >> 24;

    uint t = (x & 0xff00ff) * a;

    t = (t + ((t >> 8) & 0xff00ff) + 0x800080) >> 8;

    t &= 0xff00ff;

    x = ((x >> 8) & 0xff) * a;

    x = (x + ((x >> 8) & 0xff) + 0x80);

    x &= 0xff00;

    x |= t | (a << 24);

    return x;

}

#define INV_PREMUL(p)                                   \

    (qAlpha(p) == 0 ? 0 :                               \

    ((qAlpha(p) << 24)                                  \

     | (((255*qRed(p))/ qAlpha(p)) << 16)               \

     | (((255*qGreen(p)) / qAlpha(p))  << 8)            \

     | ((255*qBlue(p)) / qAlpha(p))))

template <class DST, class SRC>

inline DST qt_colorConvert(SRC color, DST dummy)

{

    Q_UNUSED(dummy);

    return DST(color);

}

template <>

inline quint32 qt_colorConvert(quint16 color, quint32 dummy)

{

    Q_UNUSED(dummy);

    const int r = (color & 0xf800);

    const int g = (color & 0x07e0);

    const int b = (color & 0x001f);

    const int tr = (r >> 8) | (r >> 13);

    const int tg = (g >> 3) | (g >> 9);

    const int tb = (b << 3) | (b >> 2);

    return qRgb(tr, tg, tb);

}

template <>

inline quint16 qt_colorConvert(quint32 color, quint16 dummy)

{

    Q_UNUSED(dummy);

    const int r = qRed(color) << 8;

    const int g = qGreen(color) << 3;

    const int b = qBlue(color) >> 3;

    return (r & 0xf800) | (g & 0x07e0)| (b & 0x001f);

}

class quint32p

{

public:

    inline quint32p(quint32 v) : data(PREMUL(v)) {}

    inline operator quint32() const { return data; }

    inline operator quint16() const

    {

        return qt_colorConvert<quint16, quint32>(data, 0);

    }

    Q_STATIC_INLINE_FUNCTION quint32p fromRawData(quint32 v)

    {

        quint32p p;

        p.data = v;

        return p;

    }

private:

    quint32p() {}

    quint32 data;

} Q_PACKED;

class qabgr8888

{

public:

    inline qabgr8888(quint32 v)

    {

        data = qRgba(qBlue(v), qGreen(v), qRed(v), qAlpha(v));

    }

    inline bool operator==(const qabgr8888 &v) const { return data == v.data; }

private:

    quint32 data;

} Q_PACKED;

class qrgb565;

class qargb8565

{

public:

    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return true; }

    inline qargb8565() {}

    inline qargb8565(quint32 v);

    inline explicit qargb8565(quint32p v);

    inline qargb8565(const qargb8565 &v);

    inline qargb8565(const qrgb565 &v);

    inline operator quint32() const;

    inline operator quint16() const;

    inline quint8 alpha() const { return data[0]; }

    inline qargb8565 truncedAlpha() {

        data[0] &= 0xf8;

        data[1] &= 0xdf;

        return *this;

    }

    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 3; }

    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 0x20 - alpha(a); }

    inline qargb8565 byte_mul(quint8 a) const;

    inline qargb8565 operator+(qargb8565 v) const;

    inline bool operator==(const qargb8565 &v) const;

    inline quint32 rawValue() const;

    inline quint16 rawValue16() const;

private:

    friend class qrgb565;

    quint8 data[3];

} Q_PACKED;

class qrgb565

{

public:

    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }

    qrgb565(int v = 0) : data(v) {}

    inline explicit qrgb565(quint32p v);

    inline explicit qrgb565(quint32 v);

    inline explicit qrgb565(const qargb8565 &v);

    inline operator quint32() const;

    inline operator quint16() const;

    inline qrgb565 operator+(qrgb565 v) const;

    inline quint8 alpha() const { return 0xff; }

    inline qrgb565 truncedAlpha() { return *this; }

    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 3; }

    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 0x20 - alpha(a); }

    inline qrgb565 byte_mul(quint8 a) const;

    inline bool operator==(const qrgb565 &v) const;

    inline quint16 rawValue() const { return data; }

private:

    friend class qargb8565;

    quint16 data;

} Q_PACKED;

qargb8565::qargb8565(quint32 v)

{

    *this = qargb8565(quint32p(v));

}

qargb8565::qargb8565(quint32p v)

{

    data[0] = qAlpha(v);

    const int r = qRed(v);

    const int g = qGreen(v);

    const int b = qBlue(v);

    data[1] = ((g << 3) & 0xe0) | (b >> 3);

    data[2] = (r & 0xf8) | (g >> 5);

}

qargb8565::qargb8565(const qargb8565 &v)

{

    data[0] = v.data[0];

    data[1] = v.data[1];

    data[2] = v.data[2];

}

qargb8565::qargb8565(const qrgb565 &v)

{