1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #ifndef QDRAWHELPER_P_H

    43 #define QDRAWHELPER_P_H

    44 

    45 //

    46 //  W A R N I N G

    47 //  -------------

    48 //

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

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

    51 // version without notice, or even be removed.

    52 //

    53 // We mean it.

    54 //

    55 

    56 #include "QtCore/qglobal.h"

    57 #include "QtGui/qcolor.h"

    58 #include "QtGui/qpainter.h"

    59 #include "QtGui/qimage.h"

    60 #ifndef QT_FT_BEGIN_HEADER

    61 #define QT_FT_BEGIN_HEADER

    62 #define QT_FT_END_HEADER

    63 #endif

    64 #include "private/qrasterdefs_p.h"

    65 

    66 #ifdef Q_WS_QWS

    67 #include "QtGui/qscreen_qws.h"

    68 #endif

    69 

    70 // Disable MMX and SSE on Mac/PPC builds, or if the compiler

    71 // does not support -Xarch argument passing

    72 #if defined(QT_NO_MAC_XARCH) || (defined(Q_OS_DARWIN) && (defined(__ppc__) || defined(__ppc64__)))

    73 #undef QT_HAVE_SSE2

    74 #undef QT_HAVE_SSE

    75 #undef QT_HAVE_3DNOW

    76 #undef QT_HAVE_MMX

    77 #endif

    78 

    79 QT_BEGIN_NAMESPACE

    80 

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

    82 #define Q_STATIC_TEMPLATE_SPECIALIZATION static

    83 #else

    84 #define Q_STATIC_TEMPLATE_SPECIALIZATION

    85 #endif

    86 

    87 #if defined(Q_CC_RVCT)

    88 // RVCT doesn't like static template functions

    89 #  define Q_STATIC_TEMPLATE_FUNCTION

    90 #  define Q_STATIC_INLINE_FUNCTION static __forceinline

    91 #else

    92 #  define Q_STATIC_TEMPLATE_FUNCTION static

    93 #  define Q_STATIC_INLINE_FUNCTION static inline

    94 #endif

    95 

    96 /*******************************************************************************

    97  * QSpan

    98  *

    99  * duplicate definition of FT_Span

   100  */

   101 typedef QT_FT_Span QSpan;

   102 

   103 struct QSolidData;

   104 struct QTextureData;

   105 struct QGradientData;

   106 struct QLinearGradientData;

   107 struct QRadialGradientData;

   108 struct QConicalGradientData;

   109 struct QSpanData;

   110 class QGradient;

   111 class QRasterBuffer;

   112 class QClipData;

   113 class QRasterPaintEngineState;

   114 

   115 typedef QT_FT_SpanFunc ProcessSpans;

   116 typedef void (*BitmapBlitFunc)(QRasterBuffer *rasterBuffer,

   117                                int x, int y, quint32 color,

   118                                const uchar *bitmap,

   119                                int mapWidth, int mapHeight, int mapStride);

   120 

   121 typedef void (*AlphamapBlitFunc)(QRasterBuffer *rasterBuffer,

   122                                  int x, int y, quint32 color,

   123                                  const uchar *bitmap,

   124                                  int mapWidth, int mapHeight, int mapStride,

   125                                  const QClipData *clip);

   126 

   127 typedef void (*AlphaRGBBlitFunc)(QRasterBuffer *rasterBuffer,

   128                                  int x, int y, quint32 color,

   129                                  const uint *rgbmask,

   130                                  int mapWidth, int mapHeight, int mapStride,

   131                                  const QClipData *clip);

   132 

   133 typedef void (*RectFillFunc)(QRasterBuffer *rasterBuffer,

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

   135                              quint32 color);

   136 

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

   138                                  const uchar *src, int spbl,

   139                                  int w, int h,

   140                                  int const_alpha);

   141 

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

   143                                  const uchar *src, int spbl,

   144                                  const QRectF &targetRect,

   145                                  const QRectF &sourceRect,

   146                                  const QRect &clipRect,

   147                                  int const_alpha);

   148 

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

   150                                      const uchar *src, int spbl,

   151                                      const QRectF &targetRect,

   152                                      const QRectF &sourceRect,

   153                                      const QRect &clipRect,

   154                                      const QTransform &targetRectTransform,

   155                                      int const_alpha);

   156 

   157 

   158 struct DrawHelper {

   159     ProcessSpans blendColor;

   160     ProcessSpans blendGradient;

   161     BitmapBlitFunc bitmapBlit;

   162     AlphamapBlitFunc alphamapBlit;

   163     AlphaRGBBlitFunc alphaRGBBlit;

   164     RectFillFunc fillRect;

   165 };

   166 

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

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

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

   170 

   171 extern DrawHelper qDrawHelper[QImage::NImageFormats];

   172 

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

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

   175 extern DrawHelper qDrawHelperCallback[QImage::NImageFormats];

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

   177 #endif

   178 

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

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

   181 

   182 void qInitDrawhelperAsm();

   183 

   184 class QRasterPaintEngine;

   185 

   186 struct QSolidData

   187 {

   188     uint color;

   189 };

   190 

   191 struct QLinearGradientData

   192 {

   193     struct {

   194         qreal x;

   195         qreal y;

   196     } origin;

   197     struct {

   198         qreal x;

   199         qreal y;

   200     } end;

   201 };

   202 

   203 struct QRadialGradientData

   204 {

   205     struct {

   206         qreal x;

   207         qreal y;

   208     } center;

   209     struct {

   210         qreal x;

   211         qreal y;

   212     } focal;

   213     qreal radius;

   214 };

   215 

   216 struct QConicalGradientData

   217 {

   218     struct {

   219         qreal x;

   220         qreal y;

   221     } center;

   222     qreal angle;

   223 };

   224 

   225 struct QGradientData

   226 {

   227     QGradient::Spread spread;

   228 

   229     union {

   230         QLinearGradientData linear;

   231         QRadialGradientData radial;

   232         QConicalGradientData conical;

   233     };

   234 

   235 #ifdef Q_WS_QWS

   236 #define GRADIENT_STOPTABLE_SIZE 256

   237 #else

   238 #define GRADIENT_STOPTABLE_SIZE 1024

   239 #endif

   240 

   241     uint* colorTable; //[GRADIENT_STOPTABLE_SIZE];

   242 

   243     uint alphaColor : 1;

   244 };

   245 

   246 struct QTextureData

   247 {

   248     const uchar *imageData;

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

   250 

   251     int width;

   252     int height;

   253     // clip rect

   254     int x1;

   255     int y1;

   256     int x2;

   257     int y2;

   258     int bytesPerLine;

   259     QImage::Format format;

   260     const QVector<QRgb> *colorTable;

   261     bool hasAlpha;

   262     enum Type {

   263         Plain,

   264         Tiled

   265     };

   266     Type type;

   267     int const_alpha;

   268 };

   269 

   270 struct QSpanData

   271 {

   272     QSpanData() : tempImage(0) {}

   273     ~QSpanData() { delete tempImage; }

   274 

   275     QRasterBuffer *rasterBuffer;

   276 #ifdef Q_WS_QWS

   277     QRasterPaintEngine *rasterEngine;

   278 #endif

   279     ProcessSpans blend;

   280     ProcessSpans unclipped_blend;

   281     BitmapBlitFunc bitmapBlit;

   282     AlphamapBlitFunc alphamapBlit;

   283     AlphaRGBBlitFunc alphaRGBBlit;

   284     RectFillFunc fillRect;

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

   286     const QClipData *clip;

   287     enum Type {

   288         None,

   289         Solid,

   290         LinearGradient,

   291         RadialGradient,

   292         ConicalGradient,

   293         Texture

   294     } type : 8;

   295     int txop : 8;

   296     int fast_matrix : 1;

   297     bool bilinear;

   298     QImage *tempImage;

   299     union {

   300         QSolidData solid;

   301         QGradientData gradient;

   302         QTextureData texture;

   303     };

   304 

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

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

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

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

   309     void adjustSpanMethods();

   310 };

   311 

   312 

   313 Q_STATIC_INLINE_FUNCTION uint BYTE_MUL_RGB16(uint x, uint a) {

   314     a += 1;

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

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

   317     return t;

   318 }

   319 

   320 Q_STATIC_INLINE_FUNCTION uint BYTE_MUL_RGB16_32(uint x, uint a) {

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

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

   323     return t;

   324 }

   325 

   326 #if defined(Q_CC_RVCT)

   327 #  pragma push

   328 #  pragma arm

   329 #endif

   330 Q_STATIC_INLINE_FUNCTION uint BYTE_MUL(uint x, uint a) {

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

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

   333     t &= 0xff00ff;

   334 

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

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

   337     x &= 0xff00ff00;

   338     x |= t;

   339     return x;

   340 }

   341 #if defined(Q_CC_RVCT)

   342 #  pragma pop

   343 #endif

   344 

   345 Q_STATIC_INLINE_FUNCTION uint PREMUL(uint x) {

   346     uint a = x >> 24;

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

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

   349     t &= 0xff00ff;

   350 

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

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

   353     x &= 0xff00;

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

   355     return x;

   356 }

   357 

   358 #define INV_PREMUL(p)                                   \

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

   360     ((qAlpha(p) << 24)                                  \

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

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

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

   364 

   365 template <class DST, class SRC>

   366 inline DST qt_colorConvert(SRC color, DST dummy)

   367 {

   368     Q_UNUSED(dummy);

   369     return DST(color);

   370 }

   371 

   372 

   373 template <>

   374 inline quint32 qt_colorConvert(quint16 color, quint32 dummy)

   375 {

   376     Q_UNUSED(dummy);

   377     const int r = (color & 0xf800);

   378     const int g = (color & 0x07e0);

   379     const int b = (color & 0x001f);

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

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

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

   383 

   384     return qRgb(tr, tg, tb);

   385 }

   386 

   387 template <>

   388 inline quint16 qt_colorConvert(quint32 color, quint16 dummy)

   389 {

   390     Q_UNUSED(dummy);

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

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

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

   394 

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

   396 }

   397 

   398 class quint32p

   399 {

   400 public:

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

   402 

   403     inline operator quint32() const { return data; }

   404 

   405     inline operator quint16() const

   406     {

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

   408     }

   409 

   410     Q_STATIC_INLINE_FUNCTION quint32p fromRawData(quint32 v)

   411     {

   412         quint32p p;

   413         p.data = v;

   414         return p;

   415     }

   416 

   417 private:

   418     quint32p() {}

   419     quint32 data;

   420 } Q_PACKED;

   421 

   422 class qabgr8888

   423 {

   424 public:

   425     inline qabgr8888(quint32 v)

   426     {

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

   428     }

   429 

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

   431 

   432 private:

   433     quint32 data;

   434 } Q_PACKED;

   435 

   436 class qrgb565;

   437 

   438 class qargb8565

   439 {

   440 public:

   441     Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return true; }

   442 

   443     inline qargb8565() {}

   444     inline qargb8565(quint32 v);

   445     inline explicit qargb8565(quint32p v);

   446     inline qargb8565(const qargb8565 &v);

   447     inline qargb8565(const qrgb565 &v);

   448 

   449     inline operator quint32() const;

   450     inline operator quint16() const;

   451 

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

   453     inline qargb8565 truncedAlpha() {

   454         data[0] &= 0xf8;

   455         data[1] &= 0xdf;

   456         return *this;

   457     }

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

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

   460 

   461     inline qargb8565 byte_mul(quint8 a) const;

   462     inline qargb8565 operator+(qargb8565 v) const;

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

   464 

   465     inline quint32 rawValue() const;

   466     inline quint16 rawValue16() const;

   467 

   468 private:

   469     friend class qrgb565;

   470 

   471     quint8 data[3];

   472 } Q_PACKED;

   473 

   474 class qrgb565

   475 {

   476 public:

   477     Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }

   478 

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

   480 

   481     inline explicit qrgb565(quint32p v);

   482     inline explicit qrgb565(quint32 v);

   483     inline explicit qrgb565(const qargb8565 &v);

   484 

   485     inline operator quint32() const;

   486     inline operator quint16() const;

   487 

   488     inline qrgb565 operator+(qrgb565 v) const;

   489 

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

   491     inline qrgb565 truncedAlpha() { return *this; }

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

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

   494 

   495     inline qrgb565 byte_mul(quint8 a) const;

   496 

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

   498     inline quint16 rawValue() const { return data; }

   499 

   500 private:

   501     friend class qargb8565;

   502 

   503     quint16 data;

   504 } Q_PACKED;

   505 

   506 qargb8565::qargb8565(quint32 v)

   507 {

   508     *this = qargb8565(quint32p(v));

   509 }

   510 

   511 qargb8565::qargb8565(quint32p v)

   512 {

   513     data[0] = qAlpha(v);

   514     const int r = qRed(v);

   515     const int g = qGreen(v);

   516     const int b = qBlue(v);

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

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

   519 }

   520 

   521 qargb8565::qargb8565(const qargb8565 &v)

   522 {

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

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

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

   526 }

   527 

   528 qargb8565::qargb8565(const qrgb565 &v)

   529 {

   530     data[0] = 0xff;

   531     data[1] = v.data & 0xff;

   532     data[2] = v.data >> 8;

   533 }

   534 

   535 qargb8565::operator quint32() const

   536 {

   537     const quint16 rgb = (data[2] << 8) | data[1];

   538     const int a = data[0];

   539     const int r = (rgb & 0xf800);

   540     const int g = (rgb & 0x07e0);

   541     const int b = (rgb & 0x001f);

   542     const int tr = qMin(a, (r >> 8) | (r >> 13));

   543     const int tg = qMin(a, (g >> 3) | (g >> 9));

   544     const int tb = qMin(a, (b << 3) | (b >> 2));

   545     return qRgba(tr, tg, tb, data[0]);

   546 }

   547 

   548 qargb8565::operator quint16() const

   549 {

   550     return (data[2] << 8) | data[1];

   551 }

   552 

   553 qargb8565 qargb8565::operator+(qargb8565 v) const

   554 {

   555     qargb8565 t;

   556     t.data[0] = data[0] + v.data[0];

   557     const quint16 rgb =  ((data[2] + v.data[2]) << 8)

   558                          + (data[1] + v.data[1]);

   559     t.data[1] = rgb & 0xff;

   560     t.data[2] = rgb >> 8;

   561     return t;

   562 }

   563 

   564 qargb8565 qargb8565::byte_mul(quint8 a) const

   565 {

   566     qargb8565 result;

   567     result.data[0] = (data[0] * a) >> 5;

   568 

   569     const quint16 x = (data[2] << 8) | data[1];

   570     const quint16 t = ((((x & 0x07e0) >> 5) * a) & 0x07e0) |

   571                       ((((x & 0xf81f) * a) >> 5) & 0xf81f);

   572     result.data[1] = t & 0xff;

   573     result.data[2] = t >> 8;

   574     return result;

   575 }

   576 

   577 bool qargb8565::operator==(const qargb8565 &v) const

   578 {

   579     return data[0] == v.data[0]

   580         && data[1] == v.data[1]

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

   582 }

   583 

   584 quint32 qargb8565::rawValue() const

   585 {

   586     return (data[2] << 16) | (data[1] << 8) | data[0];

   587 }

   588 

   589 quint16 qargb8565::rawValue16() const

   590 {

   591     return (data[2] << 8) | data[1];

   592 }

   593 

   594 qrgb565::qrgb565(quint32p v)

   595 {

   596     *this = qrgb565(quint32(v));

   597 }

   598 

   599 qrgb565::qrgb565(quint32 v)

   600 {

   601     const int r = qRed(v) << 8;

   602     const int g = qGreen(v) << 3;

   603     const int b = qBlue(v) >> 3;

   604 

   605     data = (r & 0xf800) | (g & 0x07e0)| (b & 0x001f);

   606 }

   607 

   608 qrgb565::qrgb565(const qargb8565 &v)

   609 {

   610     data = (v.data[2] << 8) | v.data[1];

   611 }

   612 

   613 qrgb565::operator quint32() const

   614 {

   615     const int r = (data & 0xf800);

   616     const int g = (data & 0x07e0);

   617     const int b = (data & 0x001f);

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

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

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

   621     return qRgb(tr, tg, tb);

   622 }

   623 

   624 qrgb565::operator quint16() const

   625 {

   626     return data;

   627 }

   628 

   629 qrgb565 qrgb565::operator+(qrgb565 v) const

   630 {

   631     qrgb565 t;

   632     t.data = data + v.data;

   633     return t;

   634 }

   635 

   636 qrgb565 qrgb565::byte_mul(quint8 a) const

   637 {

   638     qrgb565 result;

   639     result.data = ((((data & 0x07e0) >> 5) * a) & 0x07e0) |

   640                   ((((data & 0xf81f) * a) >> 5) & 0xf81f);

   641     return result;

   642 }

   643 

   644 bool qrgb565::operator==(const qrgb565 &v) const

   645 {

   646     return data == v.data;

   647 }

   648 

   649 class qbgr565

   650 {

   651 public:

   652     inline qbgr565(quint16 v)

   653     {

   654         data = ((v & 0x001f) << 11) |

   655                (v & 0x07e0) |

   656                ((v & 0xf800) >> 11);

   657     }

   658 

   659     inline bool operator==(const qbgr565 &v) const

   660     {

   661         return data == v.data;

   662     }

   663 

   664 private:

   665     quint16 data;

   666 } Q_PACKED;

   667 

   668 class qrgb555;

   669 

   670 class qargb8555

   671 {

   672 public:

   673     Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return true; }

   674 

   675     qargb8555() {}

   676     inline qargb8555(quint32 v);

   677     inline explicit qargb8555(quint32p v);

   678     inline qargb8555(const qargb8555 &v);

   679     inline qargb8555(const qrgb555 &v);

   680 

   681     inline operator quint32() const;

   682 

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

   684     inline qargb8555 truncedAlpha() { data[0] &= 0xf8; return *this; }

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

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

   687 

   688     inline qargb8555 operator+(qargb8555 v) const;

   689     inline qargb8555 byte_mul(quint8 a) const;

   690 

   691     inline bool operator==(const qargb8555 &v) const;

   692 

   693     inline quint32 rawValue() const;

   694 

   695 private:

   696     friend class qrgb555;

   697     quint8 data[3];

   698 } Q_PACKED;

   699 

   700 class qrgb555

   701 {

   702 public:

   703     Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }

   704 

   705     inline qrgb555(int v = 0) : data(v) {}

   706 

   707     inline explicit qrgb555(quint32p v) { *this = qrgb555(quint32(v)); }

   708 

   709     inline explicit qrgb555(quint32 v)

   710     {

   711         const int r = qRed(v) << 7;

   712         const int g = qGreen(v) << 2;

   713         const int b = qBlue(v) >> 3;

   714 

   715         data = (r & 0x7c00) | (g & 0x03e0) | (b & 0x001f);

   716     }

   717 

   718     inline explicit qrgb555(quint16 v)

   719     {

   720         data = ((v >> 1) & (0x7c00 | 0x03e0)) |

   721                (v & 0x001f);

   722     }

   723 

   724     inline explicit qrgb555(const qargb8555 &v);

   725 

   726     inline operator quint32() const

   727     {

   728         const int r = (data & 0x7c00);

   729         const int g = (data & 0x03e0);

   730         const int b = (data & 0x001f);

   731         const int tr = (r >> 7) | (r >> 12);

   732         const int tg = (g >> 2) | (g >> 7);

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

   734 

   735         return qRgb(tr, tg, tb);

   736     }

   737 

   738     inline operator quint16() const

   739     {

   740         const int r = ((data & 0x7c00) << 1) & 0xf800;

   741         const int g = (((data & 0x03e0) << 1) | ((data >> 4) & 0x0020)) & 0x07e0;

   742         const int b = (data & 0x001f);

   743 

   744         return r | g | b;

   745     }

   746 

   747     inline qrgb555 operator+(qrgb555 v) const;

   748     inline qrgb555 byte_mul(quint8 a) const;

   749 

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

   751     inline qrgb555 truncedAlpha() { return *this; }

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

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

   754 

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

   756     inline bool operator!=(const qrgb555 &v) const { return v.data != data; }

   757 

   758     inline quint16 rawValue() const { return data; }

   759 

   760 private:

   761     friend class qargb8555;

   762     friend class qbgr555;

   763     quint16 data;

   764 

   765 } Q_PACKED;

   766 

   767 qrgb555::qrgb555(const qargb8555 &v)

   768 {

   769     data = (v.data[2] << 8) | v.data[1];

   770 }

   771 

   772 qrgb555 qrgb555::operator+(qrgb555 v) const

   773 {

   774     qrgb555 t;

   775     t.data = data + v.data;

   776     return t;

   777 }

   778 

   779 qrgb555 qrgb555::byte_mul(quint8 a) const

   780 {

   781     quint16 t = (((data & 0x3e0) * a) >> 5) & 0x03e0;

   782     t |= (((data & 0x7c1f) * a) >> 5) & 0x7c1f;

   783 

   784     qrgb555 result;

   785     result.data = t;

   786     return result;

   787 }

   788 

   789 class qbgr555

   790 {

   791 public:

   792     inline qbgr555(quint32 v) { *this = qbgr555(qrgb555(v)); }

   793 

   794     inline qbgr555(qrgb555 v)

   795     {

   796         data = ((v.data & 0x001f) << 10) |

   797                (v.data & 0x03e0) |

   798                ((v.data & 0x7c00) >> 10);

   799     }

   800 

   801     inline bool operator==(const qbgr555 &v) const

   802     {

   803         return data == v.data;

   804     }

   805 

   806 private:

   807     quint16 data;

   808 } Q_PACKED;

   809 

   810 qargb8555::qargb8555(quint32 v)

   811 {

   812     v = quint32p(v);

   813     data[0] = qAlpha(v);

   814     const int r = qRed(v);

   815     const int g = qGreen(v);

   816     const int b = qBlue(v);

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

   818     data[2] = ((r >> 1) & 0x7c) | (g >> 6);

   819 

   820 }

   821 

   822 qargb8555::qargb8555(quint32p v)

   823 {

   824     data[0] = qAlpha(v);

   825     const int r = qRed(v);

   826     const int g = qGreen(v);

   827     const int b = qBlue(v);

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

   829     data[2] = ((r >> 1) & 0x7c) | (g >> 6);

   830 }

   831 

   832 qargb8555::qargb8555(const qargb8555 &v)

   833 {

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

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

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

   837 }

   838 

   839 qargb8555::qargb8555(const qrgb555 &v)

   840 {

   841     data[0] = 0xff;

   842     data[1] = v.data & 0xff;

   843     data[2] = v.data >> 8;

   844 }

   845 

   846 qargb8555::operator quint32() const

   847 {

   848     const quint16 rgb = (data[2] << 8) | data[1];

   849     const int r = (rgb & 0x7c00);

   850     const int g = (rgb & 0x03e0);

   851     const int b = (rgb & 0x001f);

   852     const int tr = (r >> 7) | (r >> 12);

   853     const int tg = (g >> 2) | (g >> 7);

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

   855 

   856     return qRgba(tr, tg, tb, data[0]);

   857 }

   858 

   859 bool qargb8555::operator==(const qargb8555 &v) const

   860 {

   861     return data[0] == v.data[0]

   862         && data[1] == v.data[1]

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

   864 }

   865 

   866 quint32 qargb8555::rawValue() const

   867 {

   868     return (data[2] << 16) | (data[1] << 8) | data[0];

   869 }

   870 

   871 qargb8555 qargb8555::operator+(qargb8555 v) const

   872 {

   873     qargb8555 t;

   874     t.data[0] = data[0] + v.data[0];

   875     const quint16 rgb =  ((data[2] + v.data[2]) << 8)

   876                          + (data[1] + v.data[1]);

   877     t.data[1] = rgb & 0xff;

   878     t.data[2] = rgb >> 8;

   879     return t;

   880 }

   881 

   882 qargb8555 qargb8555::byte_mul(quint8 a) const

   883 {

   884     qargb8555 result;

   885     result.data[0] = (data[0] * a) >> 5;

   886 

   887     const quint16 x = (data[2] << 8) | data[1];

   888     quint16 t = (((x & 0x3e0) * a) >> 5) & 0x03e0;

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

   890     result.data[1] = t & 0xff;

   891     result.data[2] = t >> 8;

   892     return result;

   893 

   894 }

   895 

   896 class qrgb666;

   897 

   898 class qargb6666

   899 {

   900 public:

   901     Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return true; }

   902 

   903     inline qargb6666() {}

   904     inline qargb6666(quint32 v) { *this = qargb6666(quint32p(v)); }

   905     inline explicit qargb6666(quint32p v);

   906     inline qargb6666(const qargb6666 &v);

   907     inline qargb6666(const qrgb666 &v);

   908 

   909     inline operator quint32 () const;

   910 

   911     inline quint8 alpha() const;

   912     inline qargb6666 truncedAlpha() { return *this; }

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

   914     Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return (255 - a + 1) >> 2; }

   915 

   916     inline qargb6666 byte_mul(quint8 a) const;

   917     inline qargb6666 operator+(qargb6666 v) const;

   918     inline bool operator==(const qargb6666 &v) const;

   919 

   920     inline quint32 rawValue() const;

   921 

   922 private:

   923     friend class qrgb666;

   924     quint8 data[3];

   925 

   926 } Q_PACKED;

   927 

   928 class qrgb666

   929 {

   930 public:

   931     Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }

   932 

   933     inline qrgb666() {}

   934     inline qrgb666(quint32 v);

   935     inline qrgb666(const qargb6666 &v);

   936 

   937     inline operator quint32 () const;

   938 

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

   940     inline qrgb666 truncedAlpha() { return *this; }

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

   942     Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return (255 - a + 1) >> 2; }

   943 

   944     inline qrgb666 operator+(qrgb666 v) const;

   945     inline qrgb666 byte_mul(quint8 a) const;

   946 

   947     inline bool operator==(const qrgb666 &v) const;

   948     inline bool operator!=(const qrgb666 &v) const { return !(*this == v); }

   949 

   950     inline quint32 rawValue() const

   951     {

   952         return (data[2] << 16) | (data[1] << 8) | data[0];

   953     }

   954 

   955 private:

   956     friend class qargb6666;

   957 

   958     quint8 data[3];

   959 } Q_PACKED;

   960 

   961 qrgb666::qrgb666(quint32 v)

   962 {

   963     const uchar b = qBlue(v);

   964     const uchar g = qGreen(v);

   965     const uchar r = qRed(v);

   966     const uint p = (b >> 2) | ((g >> 2) << 6) | ((r >> 2) << 12);

   967     data[0] = qBlue(p);

   968     data[1] = qGreen(p);

   969     data[2] = qRed(p);

   970 }

   971 

   972 qrgb666::qrgb666(const qargb6666 &v)

   973 {

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

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

   976     data[2] = v.data[2] & 0x03;

   977 }

   978 

   979 qrgb666::operator quint32 () const

   980 {

   981     const uchar r = (data[2] << 6) | ((data[1] & 0xf0) >> 2) | (data[2] & 0x3);

   982     const uchar g = (data[1] << 4) | ((data[0] & 0xc0) >> 4) | ((data[1] & 0x0f) >> 2);

   983     const uchar b = (data[0] << 2) | ((data[0] & 0x3f) >> 4);

   984     return qRgb(r, g, b);

   985 }

   986 

   987 qrgb666 qrgb666::operator+(qrgb666 v) const

   988 {

   989     const quint32 x1 = (data[2] << 16) | (data[1] << 8) | data[0];

   990     const quint32 x2 = (v.data[2] << 16) | (v.data[1] << 8) | v.data[0];

   991     const quint32 t = x1 + x2;

   992     qrgb666 r;

   993     r.data[0] = t & 0xff;

   994     r.data[1] = (t >> 8) & 0xff;

   995     r.data[2] = (t >> 16) & 0xff;

   996     return r;

   997 }

   998 

   999 qrgb666 qrgb666::byte_mul(quint8 a) const

  1000 {

  1001     const quint32 x = (data[2] << 16) | (data[1] << 8) | data[0];

  1002     const quint32 t = ((((x & 0x03f03f) * a) >> 6) & 0x03f03f) |

  1003                       ((((x & 0x000fc0) * a) >> 6) & 0x000fc0);

  1004 

  1005     qrgb666 r;

  1006     r.data[0] = t & 0xff;

  1007     r.data[1] = (t >> 8) & 0xff;

  1008     r.data[2] = (t >> 16) & 0xff;

  1009     return r;

  1010 }

  1011 

  1012 bool qrgb666::operator==(const qrgb666 &v) const

  1013 {

  1014     return (data[0] == v.data[0] &&

  1015             data[1] == v.data[1] &&

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

  1017 }

  1018 

  1019 qargb6666::qargb6666(quint32p v)

  1020 {

  1021     const quint8 b = qBlue(v) >> 2;

  1022     const quint8 g = qGreen(v) >> 2;

  1023     const quint8 r = qRed(v) >> 2;

  1024     const quint8 a = qAlpha(v) >> 2;

  1025     const uint p = (a << 18) | (r << 12) | (g << 6) | b;

  1026     data[0] = qBlue(p);

  1027     data[1] = qGreen(p);

  1028     data[2] = qRed(p);

  1029 }

  1030 

  1031 qargb6666::qargb6666(const qargb6666 &v)

  1032 {

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

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

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

  1036 }

  1037 

  1038 qargb6666::qargb6666(const qrgb666 &v)

  1039 {

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

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

  1042     data[2] = (v.data[2] | 0xfc);

  1043 }

  1044 

  1045 qargb6666::operator quint32 () const

  1046 {

  1047     const quint8 r = (data[2] << 6) | ((data[1] & 0xf0) >> 2) | (data[2] & 0x3);

  1048     const quint8 g = (data[1] << 4) | ((data[0] & 0xc0) >> 4) | ((data[1] & 0x0f) >> 2);

  1049     const quint8 b = (data[0] << 2) | ((data[0] & 0x3f) >> 4);

  1050     const quint8 a = (data[2] & 0xfc) | (data[2] >> 6);

  1051     return qRgba(r, g, b, a);

  1052 }

  1053 

  1054 qargb6666 qargb6666::operator+(qargb6666 v) const

  1055 {

  1056     const quint32 x1 = (data[2] << 16) | (data[1] << 8) | data[0];

  1057     const quint32 x2 = (v.data[2] << 16) | (v.data[1] << 8) | v.data[0];

  1058     const quint32 t = x1 + x2;

  1059     qargb6666 r;

  1060     r.data[0] = t & 0xff;

  1061     r.data[1] = (t >> 8) & 0xff;

  1062     r.data[2] = (t >> 16) & 0xff;

  1063     return r;

  1064 }

  1065 

  1066 quint8 qargb6666::alpha() const

  1067 {

  1068     return (data[2] & 0xfc) | (data[2] >> 6);

  1069 }

  1070 

  1071 inline qargb6666 qargb6666::byte_mul(quint8 a) const

  1072 {

  1073     const quint32 x = (data[2] << 16) | (data[1] << 8) | data[0];

  1074     const quint32 t = ((((x & 0x03f03f) * a) >> 6) & 0x03f03f) |

  1075                       ((((x & 0xfc0fc0) * a) >> 6) & 0xfc0fc0);

  1076 

  1077     qargb6666 r;

  1078     r.data[0] = t & 0xff;

  1079     r.data[1] = (t >> 8) & 0xff;

  1080     r.data[2] = (t >> 16) & 0xff;

  1081     return r;

  1082 }

  1083 

  1084 bool qargb6666::operator==(const qargb6666 &v) const

  1085 {

  1086     return data[0] == v.data[0]

  1087         && data[1] == v.data[1]

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

  1089 }

  1090 

  1091 quint32 qargb6666::rawValue() const

  1092 {

  1093     return (data[2] << 16) | (data[1] << 8) | data[0];

  1094 }

  1095 

  1096 class qrgb888

  1097 {

  1098 public:

  1099     Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }

  1100 

  1101     inline qrgb888() {}

  1102     inline qrgb888(quint32 v);

  1103 

  1104     inline operator quint32() const;

  1105 

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

  1107     inline qrgb888 truncedAlpha() { return *this; }

  1108     Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return a; }

  1109     Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 255 - a; }

  1110 

  1111     inline qrgb888 byte_mul(quint8 a) const;

  1112     inline qrgb888 operator+(qrgb888 v) const;

  1113     inline bool operator==(qrgb888 v) const;

  1114 

  1115     inline quint32 rawValue() const;

  1116 

  1117 private:

  1118     uchar data[3];

  1119 

  1120 } Q_PACKED;

  1121 

  1122 qrgb888::qrgb888(quint32 v)

  1123 {

  1124     data[0] = qRed(v);

  1125     data[1] = qGreen(v);

  1126     data[2] = qBlue(v);

  1127 }

  1128 

  1129 qrgb888::operator quint32() const

  1130 {

  1131     return qRgb(data[0], data[1], data[2]);

  1132 }

  1133 

  1134 qrgb888 qrgb888::operator+(qrgb888 v) const