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

**

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

**

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

// Uncomment the next line to enable the MIT Shared Memory extension

//

// WARNING:  This has some problems:

//

//    1. Consumes a 800x600 pixmap

//    2. Qt does not handle the ShmCompletion message, so you will

//        get strange effects if you xForm() repeatedly.

//

// #define QT_MITSHM

#if defined(Q_OS_WIN32) && defined(QT_MITSHM)

#undef QT_MITSHM

#endif

#include "qplatformdefs.h"

#include "qdebug.h"

#include "qiodevice.h"

#include "qpixmap_x11_p.h"

#include "qbitmap.h"

#include "qcolormap.h"

#include "qimage.h"

#include "qmatrix.h"

#include "qapplication.h"

#include <private/qpaintengine_x11_p.h>

#include <private/qt_x11_p.h>

#include "qx11info_x11.h"

#include <private/qdrawhelper_p.h>

#include <private/qimage_p.h>

#include <private/qimagepixmapcleanuphooks_p.h>

#include <stdlib.h>

#if defined(Q_CC_MIPS)

#  define for if(0){}else for

#endif

QT_BEGIN_NAMESPACE

QPixmap qt_toX11Pixmap(const QImage &image)

{

    QPixmapData *data =

        new QX11PixmapData(image.depth() == 1

                           ? QPixmapData::BitmapType

                           : QPixmapData::PixmapType);

    data->fromImage(image, Qt::AutoColor);

    return QPixmap(data);

}

QPixmap qt_toX11Pixmap(const QPixmap &pixmap)

{

    if (pixmap.isNull())

        return QPixmap();

    if (QPixmap(pixmap).data_ptr()->classId() == QPixmapData::X11Class)

        return pixmap;

    return qt_toX11Pixmap(pixmap.toImage());

}

// For thread-safety:

//   image->data does not belong to X11, so we must free it ourselves.

inline static void qSafeXDestroyImage(XImage *x)

{

    if (x->data) {

        free(x->data);

        x->data = 0;

    }

    XDestroyImage(x);

}

QBitmap QX11PixmapData::mask_to_bitmap(int screen) const

{

    if (!x11_mask)

        return QBitmap();

    QPixmap::x11SetDefaultScreen(screen);

    QBitmap bm(w, h);

    GC gc = XCreateGC(X11->display, bm.handle(), 0, 0);

    XCopyArea(X11->display, x11_mask, bm.handle(), gc, 0, 0,

              bm.data->width(), bm.data->height(), 0, 0);

    XFreeGC(X11->display, gc);

    return bm;

}

Qt::HANDLE QX11PixmapData::bitmap_to_mask(const QBitmap &bitmap, int screen)

{

    if (bitmap.isNull())

        return 0;

    QBitmap bm = bitmap;

    bm.x11SetScreen(screen);

    Pixmap mask = XCreatePixmap(X11->display, RootWindow(X11->display, screen),

                                bm.data->width(), bm.data->height(), 1);

    GC gc = XCreateGC(X11->display, mask, 0, 0);

    XCopyArea(X11->display, bm.handle(), mask, gc, 0, 0,

              bm.data->width(), bm.data->height(), 0, 0);

    XFreeGC(X11->display, gc);

    return mask;

}

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

  MIT Shared Memory Extension support: makes xForm noticeably (~20%) faster.

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

#if defined(QT_MITSHM)

static bool               xshminit = false;

static XShmSegmentInfo xshminfo;

static XImage              *xshmimg = 0;

static Pixmap               xshmpm  = 0;

static void qt_cleanup_mitshm()

{

    if (xshmimg == 0)

        return;

    Display *dpy = QX11Info::appDisplay();

    if (xshmpm) {

        XFreePixmap(dpy, xshmpm);

        xshmpm = 0;

    }

    XShmDetach(dpy, &xshminfo); xshmimg->data = 0;

    qSafeXDestroyImage(xshmimg); xshmimg = 0;

    shmdt(xshminfo.shmaddr);

    shmctl(xshminfo.shmid, IPC_RMID, 0);

}

static bool qt_create_mitshm_buffer(const QPaintDevice* dev, int w, int h)

{

    static int major, minor;

    static Bool pixmaps_ok;

    Display *dpy = dev->data->xinfo->display();

    int dd         = dev->x11Depth();

    Visual *vis         = (Visual*)dev->x11Visual();

    if (xshminit) {

        qt_cleanup_mitshm();

    } else {

        if (!XShmQueryVersion(dpy, &major, &minor, &pixmaps_ok))

            return false;                        // MIT Shm not supported

        qAddPostRoutine(qt_cleanup_mitshm);

        xshminit = true;

    }

    xshmimg = XShmCreateImage(dpy, vis, dd, ZPixmap, 0, &xshminfo, w, h);

    if (!xshmimg)

        return false;

    bool ok;

    xshminfo.shmid = shmget(IPC_PRIVATE,

                             xshmimg->bytes_per_line * xshmimg->height,

                             IPC_CREAT | 0777);

    ok = xshminfo.shmid != -1;

    if (ok) {

        xshmimg->data = (char*)shmat(xshminfo.shmid, 0, 0);

        xshminfo.shmaddr = xshmimg->data;

        ok = (xshminfo.shmaddr != (char*)-1);

    }

    xshminfo.readOnly = false;

    if (ok)

        ok = XShmAttach(dpy, &xshminfo);

    if (!ok) {

        qSafeXDestroyImage(xshmimg);

        xshmimg = 0;

        if (xshminfo.shmaddr)

            shmdt(xshminfo.shmaddr);

        if (xshminfo.shmid != -1)

            shmctl(xshminfo.shmid, IPC_RMID, 0);

        return false;

    }

    if (pixmaps_ok)

        xshmpm = XShmCreatePixmap(dpy, DefaultRootWindow(dpy), xshmimg->data,

                                   &xshminfo, w, h, dd);

    return true;

}

#else

// If extern, need a dummy.

//

// static bool qt_create_mitshm_buffer(QPaintDevice*, int, int)

// {

//     return false;

// }

#endif // QT_MITSHM

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

  Internal functions

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

extern const uchar *qt_get_bitflip_array();                // defined in qimage.cpp

// Returns position of highest bit set or -1 if none

static int highest_bit(uint v)

{

    int i;

    uint b = (uint)1 << 31;

    for (i=31; ((b & v) == 0) && i>=0;         i--)

        b >>= 1;

    return i;

}

// Returns position of lowest set bit in 'v' as an integer (0-31), or -1

static int lowest_bit(uint v)

{

    int i;

    ulong lb;

    lb = 1;

    for (i=0; ((v & lb) == 0) && i<32;  i++, lb<<=1) {}

    return i==32 ? -1 : i;

}

// Counts the number of bits set in 'v'

static uint n_bits(uint v)

{

    int i = 0;

    while (v) {

        v = v & (v - 1);

        i++;

    }

    return i;

}

static uint *red_scale_table   = 0;

static uint *green_scale_table = 0;

static uint *blue_scale_table  = 0;

static void cleanup_scale_tables()

{

    delete[] red_scale_table;

    delete[] green_scale_table;

    delete[] blue_scale_table;

}

/*

  Could do smart bitshifting, but the "obvious" algorithm only works for

  nBits >= 4. This is more robust.

*/

static void build_scale_table(uint **table, uint nBits)

{

    if (nBits > 7) {

        qWarning("build_scale_table: internal error, nBits = %i", nBits);

        return;

    }

    if (!*table) {

        static bool firstTable = true;

        if (firstTable) {

            qAddPostRoutine(cleanup_scale_tables);

            firstTable = false;

        }

        *table = new uint[256];

    }

    int   maxVal   = (1 << nBits) - 1;

    int   valShift = 8 - nBits;

    int i;

    for(i = 0 ; i < maxVal + 1 ; i++)

        (*table)[i << valShift] = i*255/maxVal;

}

static int defaultScreen = -1;

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

  QPixmap member functions

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

static int qt_pixmap_serial = 0;

int Q_GUI_EXPORT qt_x11_preferred_pixmap_depth = 0;

QX11PixmapData::QX11PixmapData(PixelType type)

    : QPixmapData(type, X11Class), hd(0),

      flags(Uninitialized), x11_mask(0), picture(0), mask_picture(0), hd2(0), gl_surface(0),

      share_mode(QPixmap::ImplicitlyShared), pengine(0)

{

}

QPixmapData *QX11PixmapData::createCompatiblePixmapData() const

{

    return new QX11PixmapData(pixelType());

}

void QX11PixmapData::resize(int width, int height)

{

    setSerialNumber(++qt_pixmap_serial);

    w = width;

    h = height;

    is_null = (w <= 0 || h <= 0);

    if (defaultScreen >= 0 && defaultScreen != xinfo.screen()) {

        QX11InfoData* xd = xinfo.getX11Data(true);

        xd->screen = defaultScreen;

        xd->depth = QX11Info::appDepth(xd->screen);

        xd->cells = QX11Info::appCells(xd->screen);

        xd->colormap = QX11Info::appColormap(xd->screen);

        xd->defaultColormap = QX11Info::appDefaultColormap(xd->screen);

        xd->visual = (Visual *)QX11Info::appVisual(xd->screen);

        xd->defaultVisual = QX11Info::appDefaultVisual(xd->screen);

        xinfo.setX11Data(xd);

    }

    int dd = xinfo.depth();

    if (qt_x11_preferred_pixmap_depth)

        dd = qt_x11_preferred_pixmap_depth;

    bool make_null = w <= 0 || h <= 0;                // create null pixmap

    d = (pixelType() == BitmapType ? 1 : dd);

    if (make_null || d == 0) {

        w = 0;

        h = 0;

        is_null = true;

        hd = 0;

        picture = 0;

        d = 0;

        if (!make_null)

            qWarning("QPixmap: Invalid pixmap parameters");

        return;

    }

    hd = (Qt::HANDLE)XCreatePixmap(X11->display,

                                   RootWindow(X11->display, xinfo.screen()),

                                   w, h, d);

#ifndef QT_NO_XRENDER

    if (X11->use_xrender) {

        XRenderPictFormat *format = d == 1

                                    ? XRenderFindStandardFormat(X11->display, PictStandardA1)

                                    : XRenderFindVisualFormat(X11->display, (Visual *)xinfo.visual());

        picture = XRenderCreatePicture(X11->display, hd, format, 0, 0);

    }

#endif // QT_NO_XRENDER

}

struct QX11AlphaDetector

{

    bool hasAlpha() const {

        if (checked)

            return has;

        // Will implicitly also check format and return quickly for opaque types...

        checked = true;

        has = image->isNull() ? false : const_cast<QImage *>(image)->data_ptr()->checkForAlphaPixels();

        return has;

    }

    bool hasXRenderAndAlpha() const {

        if (!X11->use_xrender)

            return false;

        return hasAlpha();

    }

    QX11AlphaDetector(const QImage *i, Qt::ImageConversionFlags flags)

        : image(i), checked(false), has(false)

    {

        if (flags & Qt::NoOpaqueDetection) {

            checked = true;

            has = image->hasAlphaChannel();

        }

    }

    const QImage *image;

    mutable bool checked;

    mutable bool has;

};

void QX11PixmapData::fromImage(const QImage &img,

                               Qt::ImageConversionFlags flags)

{

    setSerialNumber(++qt_pixmap_serial);

    w = img.width();

    h = img.height();

    d = img.depth();

    is_null = (w <= 0 || h <= 0);

    if (is_null) {

        w = h = 0;

        return;

    }

    if (defaultScreen >= 0 && defaultScreen != xinfo.screen()) {

        QX11InfoData* xd = xinfo.getX11Data(true);

        xd->screen = defaultScreen;

        xd->depth = QX11Info::appDepth(xd->screen);

        xd->cells = QX11Info::appCells(xd->screen);

        xd->colormap = QX11Info::appColormap(xd->screen);

        xd->defaultColormap = QX11Info::appDefaultColormap(xd->screen);

        xd->visual = (Visual *)QX11Info::appVisual(xd->screen);

        xd->defaultVisual = QX11Info::appDefaultVisual(xd->screen);

        xinfo.setX11Data(xd);

    }

    if (pixelType() == BitmapType) {

        bitmapFromImage(img);

        return;

    }

    if (uint(w) >= 32768 || uint(h) >= 32768) {

        w = h = 0;

        is_null = true;

        return;

    }

    QX11AlphaDetector alphaCheck(&img, flags);

    int dd = alphaCheck.hasXRenderAndAlpha() ? 32 : xinfo.depth();

    if (qt_x11_preferred_pixmap_depth)

        dd = qt_x11_preferred_pixmap_depth;

    QImage image = img;

    // must be monochrome

    if (dd == 1 || (flags & Qt::ColorMode_Mask) == Qt::MonoOnly) {

        if (d != 1) {

            // dither

            image = image.convertToFormat(QImage::Format_MonoLSB, flags);

            d = 1;

        }

    } else { // can be both

        bool conv8 = false;

        if (d > 8 && dd <= 8) { // convert to 8 bit

            if ((flags & Qt::DitherMode_Mask) == Qt::AutoDither)

                flags = (flags & ~Qt::DitherMode_Mask)

                        | Qt::PreferDither;

            conv8 = true;

        } else if ((flags & Qt::ColorMode_Mask) == Qt::ColorOnly) {

            conv8 = (d == 1);                        // native depth wanted

        } else if (d == 1) {

            if (image.colorCount() == 2) {

                QRgb c0 = image.color(0);        // Auto: convert to best

                QRgb c1 = image.color(1);

                conv8 = qMin(c0,c1) != qRgb(0,0,0) || qMax(c0,c1) != qRgb(255,255,255);

            } else {

                // eg. 1-color monochrome images (they do exist).

                conv8 = true;

            }

        }

        if (conv8) {

            image = image.convertToFormat(QImage::Format_Indexed8, flags);

            d = 8;

        }

    }

    if (d == 1 || d == 16 || d == 24) {

        image = image.convertToFormat(QImage::Format_RGB32, flags);

        fromImage(image, Qt::AutoColor);

        return;

    }

    Display *dpy   = X11->display;

    Visual *visual = (Visual *)xinfo.visual();

    XImage *xi = 0;

    bool    trucol = (visual->c_class >= TrueColor);

    int     nbytes = image.byteCount();

    uchar  *newbits= 0;

#ifndef QT_NO_XRENDER

    if (alphaCheck.hasXRenderAndAlpha()) {

        const QImage &cimage = image;

        d = 32;

        if (QX11Info::appDepth() != d) {

            if (xinfo.x11data) {

                xinfo.x11data->depth = d;

            } else {

                QX11InfoData *xd = xinfo.getX11Data(true);

                xd->screen = QX11Info::appScreen();

                xd->depth = d;

                xd->cells = QX11Info::appCells();

                xd->colormap = QX11Info::appColormap();

                xd->defaultColormap = QX11Info::appDefaultColormap();

                xd->visual = (Visual *)QX11Info::appVisual();

                xd->defaultVisual = QX11Info::appDefaultVisual();

                xinfo.setX11Data(xd);

            }

        }

        hd = (Qt::HANDLE)XCreatePixmap(dpy, RootWindow(dpy, xinfo.screen()),

                                       w, h, d);

        picture = XRenderCreatePicture(X11->display, hd,

                                       XRenderFindStandardFormat(X11->display, PictStandardARGB32), 0, 0);

        xi = XCreateImage(dpy, visual, d, ZPixmap, 0, 0, w, h, 32, 0);

        Q_CHECK_PTR(xi);

        newbits = (uchar *)malloc(xi->bytes_per_line*h);

        Q_CHECK_PTR(newbits);

        xi->data = (char *)newbits;

        switch(cimage.format()) {

        case QImage::Format_Indexed8: {

            QVector<QRgb> colorTable = cimage.colorTable();

            uint *xidata = (uint *)xi->data;

            for (int y = 0; y < h; ++y) {

                const uchar *p = cimage.scanLine(y);

                for (int x = 0; x < w; ++x) {

                    const QRgb rgb = colorTable[p[x]];

                    const int a = qAlpha(rgb);

                    if (a == 0xff)

                        *xidata = rgb;

                    else

                        // RENDER expects premultiplied alpha

                        *xidata = qRgba(qt_div_255(qRed(rgb) * a),

                                        qt_div_255(qGreen(rgb) * a),

                                        qt_div_255(qBlue(rgb) * a),

                                        a);

                    ++xidata;

                }

            }

        }

            break;

        case QImage::Format_RGB32: {

            uint *xidata = (uint *)xi->data;

            for (int y = 0; y < h; ++y) {

                const QRgb *p = (const QRgb *) cimage.scanLine(y);

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

                    *xidata++ = p[x] | 0xff000000;

            }

        }

            break;

        case QImage::Format_ARGB32: {

            uint *xidata = (uint *)xi->data;

            for (int y = 0; y < h; ++y) {

                const QRgb *p = (const QRgb *) cimage.scanLine(y);

                for (int x = 0; x < w; ++x) {

                    const QRgb rgb = p[x];

                    const int a = qAlpha(rgb);

                    if (a == 0xff)

                        *xidata = rgb;

                    else

                        // RENDER expects premultiplied alpha

                        *xidata = qRgba(qt_div_255(qRed(rgb) * a),

                                        qt_div_255(qGreen(rgb) * a),

                                        qt_div_255(qBlue(rgb) * a),

                                        a);

                    ++xidata;

                }

            }

        }

            break;

        case QImage::Format_ARGB32_Premultiplied: {

            uint *xidata = (uint *)xi->data;

            for (int y = 0; y < h; ++y) {

                const QRgb *p = (const QRgb *) cimage.scanLine(y);

                memcpy(xidata, p, w*sizeof(QRgb));

                xidata += w;

            }

        }

            break;

        default:

            Q_ASSERT(false);

        }

        if ((xi->byte_order == MSBFirst) != (QSysInfo::ByteOrder == QSysInfo::BigEndian)) {

            uint *xidata = (uint *)xi->data;

            uint *xiend = xidata + w*h;

            while (xidata < xiend) {

                *xidata = (*xidata >> 24)

                          | ((*xidata >> 8) & 0xff00)

                          | ((*xidata << 8) & 0xff0000)

                          | (*xidata << 24);

                ++xidata;

            }

        }

        GC gc = XCreateGC(dpy, hd, 0, 0);

        XPutImage(dpy, hd, gc, xi, 0, 0, 0, 0, w, h);

        XFreeGC(dpy, gc);

        qSafeXDestroyImage(xi);

        return;

    }

#endif // QT_NO_XRENDER

    if (trucol) {                                // truecolor display

        if (image.format() == QImage::Format_ARGB32_Premultiplied)

            image = image.convertToFormat(QImage::Format_ARGB32);

        const QImage &cimage = image;

        QRgb  pix[256];                                // pixel translation table

        const bool  d8 = (d == 8);

        const uint  red_mask          = (uint)visual->red_mask;

        const uint  green_mask  = (uint)visual->green_mask;

        const uint  blue_mask          = (uint)visual->blue_mask;

        const int   red_shift          = highest_bit(red_mask)   - 7;

        const int   green_shift = highest_bit(green_mask) - 7;

        const int   blue_shift  = highest_bit(blue_mask)  - 7;

        const uint  rbits = highest_bit(red_mask) - lowest_bit(red_mask) + 1;

        const uint  gbits = highest_bit(green_mask) - lowest_bit(green_mask) + 1;

        const uint  bbits = highest_bit(blue_mask) - lowest_bit(blue_mask) + 1;

        if (d8) {                                // setup pixel translation

            QVector<QRgb> ctable = cimage.colorTable();

            for (int i=0; i < cimage.colorCount(); i++) {

                int r = qRed  (ctable[i]);

                int g = qGreen(ctable[i]);

                int b = qBlue (ctable[i]);

                r = red_shift        > 0 ? r << red_shift   : r >> -red_shift;

                g = green_shift > 0 ? g << green_shift : g >> -green_shift;

                b = blue_shift        > 0 ? b << blue_shift  : b >> -blue_shift;

                pix[i] = (b & blue_mask) | (g & green_mask) | (r & red_mask)

                         | ~(blue_mask | green_mask | red_mask);

            }

        }

        xi = XCreateImage(dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0);

        Q_CHECK_PTR(xi);

        newbits = (uchar *)malloc(xi->bytes_per_line*h);

        Q_CHECK_PTR(newbits);

        if (!newbits)                                // no memory

            return;

        int bppc = xi->bits_per_pixel;

        bool contig_bits = n_bits(red_mask) == rbits &&

                           n_bits(green_mask) == gbits &&

                           n_bits(blue_mask) == bbits;

        bool dither_tc =

            // Want it?

            (flags & Qt::Dither_Mask) != Qt::ThresholdDither &&

            (flags & Qt::DitherMode_Mask) != Qt::AvoidDither &&

            // Need it?

            bppc < 24 && !d8 &&

            // Can do it? (Contiguous bits?)

            contig_bits;

        static bool init=false;

        static int D[16][16];

        if (dither_tc && !init) {

            // I also contributed this code to XV - WWA.

            /*

              The dither matrix, D, is obtained with this formula:

              D2 = [0 2]

              [3 1]

              D2*n = [4*Dn       4*Dn+2*Un]

              [4*Dn+3*Un  4*Dn+1*Un]

            */

            int n,i,j;

            init=1;

            /* Set D2 */

            D[0][0]=0;

            D[1][0]=2;

            D[0][1]=3;

            D[1][1]=1;

            /* Expand using recursive definition given above */

            for (n=2; n<16; n*=2) {

                for (i=0; i<n; i++) {

                    for (j=0; j<n; j++) {

                        D[i][j]*=4;

                        D[i+n][j]=D[i][j]+2;

                        D[i][j+n]=D[i][j]+3;

                        D[i+n][j+n]=D[i][j]+1;

                    }

                }

            }

            init=true;

        }

        enum { BPP8,

               BPP16_565, BPP16_555,

               BPP16_MSB, BPP16_LSB,

               BPP24_888,

               BPP24_MSB, BPP24_LSB,

               BPP32_8888,

               BPP32_MSB, BPP32_LSB

        } mode = BPP8;

        bool same_msb_lsb = (xi->byte_order == MSBFirst) == (QSysInfo::ByteOrder == QSysInfo::BigEndian);

        if(bppc == 8) // 8 bit

            mode = BPP8;

        else if(bppc == 16) { // 16 bit MSB/LSB

            if(red_shift == 8 && green_shift == 3 && blue_shift == -3 && !d8 && same_msb_lsb)

                mode = BPP16_565;

            else if(red_shift == 7 && green_shift == 2 && blue_shift == -3 && !d8 && same_msb_lsb)

                mode = BPP16_555;

            else

                mode = (xi->byte_order == LSBFirst) ? BPP16_LSB : BPP16_MSB;

        } else if(bppc == 24) { // 24 bit MSB/LSB

            if (red_shift == 16 && green_shift == 8 && blue_shift == 0 && !d8 && same_msb_lsb)

                mode = BPP24_888;

            else

                mode = (xi->byte_order == LSBFirst) ? BPP24_LSB : BPP24_MSB;

        } else if(bppc == 32) { // 32 bit MSB/LSB

            if(red_shift == 16 && green_shift == 8 && blue_shift == 0 && !d8 && same_msb_lsb)

                mode = BPP32_8888;

            else

                mode = (xi->byte_order == LSBFirst) ? BPP32_LSB : BPP32_MSB;

        } else

            qFatal("Logic error 3");

#define GET_PIXEL                                                       \

        uint pixel;                                                     \

        if (d8) pixel = pix[*src++];                                    \

        else {                                                          \

            int r = qRed  (*p);                                         \

            int g = qGreen(*p);                                         \

            int b = qBlue (*p++);                                       \

            r = red_shift   > 0                                         \

                ? r << red_shift   : r >> -red_shift;                   \

            g = green_shift > 0                                         \

                ? g << green_shift : g >> -green_shift;                 \

            b = blue_shift  > 0                                         \

                ? b << blue_shift  : b >> -blue_shift;                  \

            pixel = (r & red_mask)|(g & green_mask) | (b & blue_mask)   \

                    | ~(blue_mask | green_mask | red_mask);             \

        }

#define GET_PIXEL_DITHER_TC                                             \

        int r = qRed  (*p);                                             \

        int g = qGreen(*p);                                             \

        int b = qBlue (*p++);                                           \

        const int thres = D[x%16][y%16];                                \

        if (r <= (255-(1<<(8-rbits))) && ((r<<rbits) & 255)             \

            > thres)                                                    \

            r += (1<<(8-rbits));                                        \

        if (g <= (255-(1<<(8-gbits))) && ((g<<gbits) & 255)             \

            > thres)                                                    \

            g += (1<<(8-gbits));                                        \

        if (b <= (255-(1<<(8-bbits))) && ((b<<bbits) & 255)             \

            > thres)                                                    \

            b += (1<<(8-bbits));                                        \

        r = red_shift   > 0                                             \

            ? r << red_shift   : r >> -red_shift;                       \

        g = green_shift > 0                                             \

            ? g << green_shift : g >> -green_shift;                     \

        b = blue_shift  > 0                                             \

            ? b << blue_shift  : b >> -blue_shift;                      \

        uint pixel = (r & red_mask)|(g & green_mask) | (b & blue_mask);

// again, optimized case

// can't be optimized that much :(

#define GET_PIXEL_DITHER_TC_OPT(red_shift,green_shift,blue_shift,red_mask,green_mask,blue_mask, \

                                rbits,gbits,bbits)                      \

        const int thres = D[x%16][y%16];                                \

        int r = qRed  (*p);                                             \

        if (r <= (255-(1<<(8-rbits))) && ((r<<rbits) & 255)             \

            > thres)                                                    \

            r += (1<<(8-rbits));                                        \

        int g = qGreen(*p);                                             \

        if (g <= (255-(1<<(8-gbits))) && ((g<<gbits) & 255)             \

            > thres)                                                    \

            g += (1<<(8-gbits));                                        \

        int b = qBlue (*p++);                                           \

        if (b <= (255-(1<<(8-bbits))) && ((b<<bbits) & 255)             \

            > thres)                                                    \

            b += (1<<(8-bbits));                                        \

        uint pixel = ((r red_shift) & red_mask)                         \

                     | ((g green_shift) & green_mask)                   \

                     | ((b blue_shift) & blue_mask);

#define CYCLE(body)                                             \

        for (int y=0; y<h; y++) {                               \

            const uchar* src = cimage.scanLine(y);              \

            uchar* dst = newbits + xi->bytes_per_line*y;        \

            const QRgb* p = (const QRgb *)src;                  \

            body                                                \

                }

        if (dither_tc) {

            switch (mode) {

            case BPP16_565:

                CYCLE(

                    quint16* dst16 = (quint16*)dst;

                    for (int x=0; x<w; x++) {

                        GET_PIXEL_DITHER_TC_OPT(<<8,<<3,>>3,0xf800,0x7e0,0x1f,5,6,5)

                            *dst16++ = pixel;

                    }

                    )

                    break;

            case BPP16_555:

                CYCLE(

                    quint16* dst16 = (quint16*)dst;

                    for (int x=0; x<w; x++) {

                        GET_PIXEL_DITHER_TC_OPT(<<7,<<2,>>3,0x7c00,0x3e0,0x1f,5,5,5)

                            *dst16++ = pixel;

                    }

                    )

                    break;

            case BPP16_MSB:                        // 16 bit MSB

                CYCLE(

                    for (int x=0; x<w; x++) {

                        GET_PIXEL_DITHER_TC

                            *dst++ = (pixel >> 8);

                        *dst++ = pixel;

                    }

                    )

                    break;

            case BPP16_LSB:                        // 16 bit LSB

                CYCLE(

                    for (int x=0; x<w; x++) {

                        GET_PIXEL_DITHER_TC

                            *dst++ = pixel;

                        *dst++ = pixel >> 8;

                    }

                    )

                    break;

            default:

                qFatal("Logic error");

            }

        } else {

            switch (mode) {

            case BPP8:                        // 8 bit

                CYCLE(

                    Q_UNUSED(p);

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

                        *dst++ = pix[*src++];

                    )

                    break;

            case BPP16_565:

                CYCLE(

                    quint16* dst16 = (quint16*)dst;

                    for (int x = 0; x < w; x++) {

                        *dst16++ = ((*p >> 8) & 0xf800)

                                   | ((*p >> 5) & 0x7e0)

                                   | ((*p >> 3) & 0x1f);

                        ++p;

                    }

                    )

                    break;

            case BPP16_555:

                CYCLE(

                    quint16* dst16 = (quint16*)dst;

                    for (int x=0; x<w; x++) {

                        *dst16++ = ((*p >> 9) & 0x7c00)

                                   | ((*p >> 6) & 0x3e0)

                                   | ((*p >> 3) & 0x1f);

                        ++p;

                    }

                    )

                    break;

            case BPP16_MSB:                        // 16 bit MSB

                CYCLE(

                    for (int x=0; x<w; x++) {

                        GET_PIXEL

                            *dst++ = (pixel >> 8);

                        *dst++ = pixel;

                    }

                    )

                    break;

            case BPP16_LSB:                        // 16 bit LSB

                CYCLE(

                    for (int x=0; x<w; x++) {

                        GET_PIXEL

                            *dst++ = pixel;

                        *dst++ = pixel >> 8;

                    }

                    )

                    break;

            case BPP24_888:                        // 24 bit MSB

                CYCLE(

                    for (int x=0; x<w; x++) {

                        *dst++ = qRed  (*p);

                        *dst++ = qGreen(*p);

                        *dst++ = qBlue (*p++);

                    }

                    )

                    break;

            case BPP24_MSB:                        // 24 bit MSB

                CYCLE(

                    for (int x=0; x<w; x++) {

                        GET_PIXEL

                            *dst++ = pixel >> 16;

                        *dst++ = pixel >> 8;

                        *dst++ = pixel;

                    }

                    )

                    break;

            case BPP24_LSB:                        // 24 bit LSB

                CYCLE(

                    for (int x=0; x<w; x++) {

                        GET_PIXEL

                            *dst++ = pixel;

                        *dst++ = pixel >> 8;

                        *dst++ = pixel >> 16;

                    }

                    )

                    break;

            case BPP32_8888:

                CYCLE(

                    memcpy(dst, p, w * 4);

                    )

                    break;

            case BPP32_MSB:                        // 32 bit MSB

                CYCLE(

                    for (int x=0; x<w; x++) {

                        GET_PIXEL

                            *dst++ = pixel >> 24;

                        *dst++ = pixel >> 16;

                        *dst++ = pixel >> 8;

                        *dst++ = pixel;

                    }

                    )

                    break;

            case BPP32_LSB:                        // 32 bit LSB

                CYCLE(

                    for (int x=0; x<w; x++) {

                        GET_PIXEL

                            *dst++ = pixel;

                        *dst++ = pixel >> 8;

                        *dst++ = pixel >> 16;

                        *dst++ = pixel >> 24;

                    }

                    )

                    break;

            default:

                qFatal("Logic error 2");

            }

        }

        xi->data = (char *)newbits;

    }

    if (d == 8 && !trucol) {                        // 8 bit pixmap

        int  pop[256];                                // pixel popularity

        if (image.colorCount() == 0)

            image.setColorCount(1);

        const QImage &cimage = image;

        memset(pop, 0, sizeof(int)*256);        // reset popularity array

        for (int i = 0; i < h; i++) {                        // for each scanline...

            const uchar* p = cimage.scanLine(i);

            const uchar *end = p + w;

            while (p < end)                        // compute popularity

                pop[*p++]++;

        }

        newbits = (uchar *)malloc(nbytes);        // copy image into newbits

        Q_CHECK_PTR(newbits);

        if (!newbits)                                // no memory

            return;

        uchar* p = newbits;

        memcpy(p, cimage.bits(), nbytes);        // copy image data into newbits

        /*

         * The code below picks the most important colors. It is based on the

         * diversity algorithm, implemented in XV 3.10. XV is (C) by John Bradley.

         */

        struct PIX {                                // pixel sort element

            uchar r,g,b,n;                        // color + pad

            int          use;                                // popularity

            int          index;                        // index in colormap

            int          mindist;

        };

        int ncols = 0;

        for (int i=0; i< cimage.colorCount(); i++) { // compute number of colors

            if (pop[i] > 0)

                ncols++;

        }

        for (int i = cimage.colorCount(); i < 256; i++) // ignore out-of-range pixels

            pop[i] = 0;

        // works since we make sure above to have at least

        // one color in the image

        if (ncols == 0)

            ncols = 1;

        PIX pixarr[256];                        // pixel array

        PIX pixarr_sorted[256];                        // pixel array (sorted)

        memset(pixarr, 0, ncols*sizeof(PIX));

        PIX *px                   = &pixarr[0];

        int  maxpop = 0;

        int  maxpix = 0;

        uint j = 0;

        QVector<QRgb> ctable = cimage.colorTable();

        for (int i = 0; i < 256; i++) {                // init pixel array

            if (pop[i] > 0) {

                px->r = qRed  (ctable[i]);

                px->g = qGreen(ctable[i]);

                px->b = qBlue (ctable[i]);

                px->n = 0;

                px->use = pop[i];

                if (pop[i] > maxpop) {        // select most popular entry

                    maxpop = pop[i];

                    maxpix = j;

                }

                px->index = i;

                px->mindist = 1000000;

                px++;

                j++;

            }

        }

        pixarr_sorted[0] = pixarr[maxpix];

        pixarr[maxpix].use = 0;

        for (int i = 1; i < ncols; i++) {                // sort pixels

            int minpix = -1, mindist = -1;

            px = &pixarr_sorted[i-1];

            int r = px->r;

            int g = px->g;

            int b = px->b;

            int dist;

            if ((i & 1) || i<10) {                // sort on max distance

                for (int j=0; j<ncols; j++) {

                    px = &pixarr[j];

                    if (px->use) {

                        dist = (px->r - r)*(px->r - r) +

                               (px->g - g)*(px->g - g) +

                               (px->b - b)*(px->b - b);

                        if (px->mindist > dist)

                            px->mindist = dist;

                        if (px->mindist > mindist) {

                            mindist = px->mindist;

                            minpix = j;

                        }

                    }

                }

            } else {                                // sort on max popularity

                for (int j=0; j<ncols; j++) {

                    px = &pixarr[j];

                    if (px->use) {

                        dist = (px->r - r)*(px->r - r) +

                               (px->g - g)*(px->g - g) +

                               (px->b - b)*(px->b - b);

                        if (px->mindist > dist)

                            px->mindist = dist;

                        if (px->use > mindist) {

                            mindist = px->use;

                            minpix = j;

                        }

                    }

                }

            }

            pixarr_sorted[i] = pixarr[minpix];

            pixarr[minpix].use = 0;

        }

        QColormap cmap = QColormap::instance(xinfo.screen());

        uint pix[256];                                // pixel translation table

        px = &pixarr_sorted[0];

        for (int i = 0; i < ncols; i++) {                // allocate colors

            QColor c(px->r, px->g, px->b);

            pix[px->index] = cmap.pixel(c);

            px++;

        }

        p = newbits;

        for (int i = 0; i < nbytes; i++) {                // translate pixels

            *p = pix[*p];

            p++;

        }

    }

    if (!xi) {                                // X image not created

        xi = XCreateImage(dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0);

        if (xi->bits_per_pixel == 16) {        // convert 8 bpp ==> 16 bpp

            ushort *p2;

            int            p2inc = xi->bytes_per_line/sizeof(ushort);

            ushort *newerbits = (ushort *)malloc(xi->bytes_per_line * h);

            Q_CHECK_PTR(newerbits);

            if (!newerbits)                                // no memory

                return;

            uchar* p = newbits;

            for (int y = 0; y < h; y++) {                // OOPS: Do right byte order!!

                p2 = newerbits + p2inc*y;

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

                    *p2++ = *p++;

            }

            free(newbits);

            newbits = (uchar *)newerbits;

        } else if (xi->bits_per_pixel != 8) {

            qWarning("QPixmap::fromImage: Display not supported "

                     "(bpp=%d)", xi->bits_per_pixel);

        }

        xi->data = (char *)newbits;

    }

    hd = (Qt::HANDLE)XCreatePixmap(X11->display,

                                   RootWindow(X11->display, xinfo.screen()),

                                   w, h, dd);

    GC gc = XCreateGC(dpy, hd, 0, 0);

    XPutImage(dpy, hd, gc, xi, 0, 0, 0, 0, w, h);

    XFreeGC(dpy, gc);

    qSafeXDestroyImage(xi);

    d = dd;

#ifndef QT_NO_XRENDER

    if (X11->use_xrender) {

        XRenderPictFormat *format = d == 1

                                    ? XRenderFindStandardFormat(X11->display, PictStandardA1)

                                    : XRenderFindVisualFormat(X11->display, (Visual *)xinfo.visual());

        picture = XRenderCreatePicture(X11->display, hd, format, 0, 0);

    }

#endif

    if (alphaCheck.hasAlpha()) {

        QBitmap m = QBitmap::fromImage(image.createAlphaMask(flags));

        setMask(m);

    }

}

void QX11PixmapData::bitmapFromImage(const QImage &image)

{

    QImage img = image.convertToFormat(QImage::Format_MonoLSB);

    const QRgb c0 = QColor(Qt::black).rgb();

    const QRgb c1 = QColor(Qt::white).rgb();

    if (img.color(0) == c0 && img.color(1) == c1) {

        img.invertPixels();

        img.setColor(0, c1);

        img.setColor(1, c0);

    }

    char  *bits;

    uchar *tmp_bits;

    w = img.width();

    h = img.height();

    d = 1;

    is_null = (w <= 0 || h <= 0);

    int bpl = (w + 7) / 8;

    int ibpl = img.bytesPerLine();

    if (bpl != ibpl) {

        tmp_bits = new uchar[bpl*h];

        bits = (char *)tmp_bits;

        uchar *p, *b;

        int y;

        b = tmp_bits;

        p = img.scanLine(0);

        for (y = 0; y < h; y++) {

            memcpy(b, p, bpl);

            b += bpl;

            p += ibpl;

        }

    } else {

        bits = (char *)img.bits();

        tmp_bits = 0;

    }

    hd = (Qt::HANDLE)XCreateBitmapFromData(xinfo.display(),

                                           RootWindow(xinfo.display(), xinfo.screen()),

                                           bits, w, h);

#ifndef QT_NO_XRENDER

    if (X11->use_xrender)

        picture = XRenderCreatePicture(X11->display, hd,

                                       XRenderFindStandardFormat(X11->display, PictStandardA1), 0, 0);

#endif // QT_NO_XRENDER

    if (tmp_bits)                                // Avoid purify complaint

        delete [] tmp_bits;

}

void QX11PixmapData::fill(const QColor &fillColor)

{

    if (fillColor.alpha() != 255) {

#ifndef QT_NO_XRENDER

        if (X11->use_xrender) {

            if (!picture || d != 32)

                convertToARGB32(/*preserveContents = */false);

            ::Picture src  = X11->getSolidFill(xinfo.screen(), fillColor);

            XRenderComposite(X11->display, PictOpSrc, src, 0, picture,

                             0, 0, width(), height(),

                             0, 0, width(), height());

        } else

#endif

        {

            QImage im(width(), height(), QImage::Format_ARGB32_Premultiplied);

            im.fill(PREMUL(fillColor.rgba()));

            release();

            fromImage(im, Qt::AutoColor | Qt::OrderedAlphaDither);

        }

        return;

    }

    GC gc = XCreateGC(X11->display, hd, 0, 0);

    if (depth() == 1) {

        XSetForeground(X11->display, gc, qGray(fillColor.rgb()) > 127 ? 0 : 1);

    } else if (X11->use_xrender && d >= 24) {

        XSetForeground(X11->display, gc, fillColor.rgba());

    } else {

        XSetForeground(X11->display, gc,

                       QColormap::instance(xinfo.screen()).pixel(fillColor));

    }

    XFillRectangle(X11->display, hd, gc, 0, 0, width(), height());

    XFreeGC(X11->display, gc);

}

QX11PixmapData::~QX11PixmapData()

{

    // Cleanup hooks have to be called before the handles are freed

    if (is_cached) {

        QImagePixmapCleanupHooks::executePixmapDataDestructionHooks(this);

        is_cached = false;

    }

    release();

}

void QX11PixmapData::release()

{

    delete pengine;

    pengine = 0;

    if (!X11) {

#ifndef QT_NO_DEBUG

        qWarning("~QX11PixmapData(): QPixmap objects must be destroyed before the QApplication"

                 " object, otherwise the native pixmap object will be leaked.");

#endif

        return;

    }

    if (x11_mask) {

#ifndef QT_NO_XRENDER

        if (mask_picture)

            XRenderFreePicture(X11->display, mask_picture);

        mask_picture = 0;

#endif

        XFreePixmap(X11->display, x11_mask);

        x11_mask = 0;

    }

    if (hd) {

#ifndef QT_NO_XRENDER

        if (picture) {

            XRenderFreePicture(X11->display, picture);

            picture = 0;

        }

#endif // QT_NO_XRENDER

        if (hd2) {

            XFreePixmap(xinfo.display(), hd2);

            hd2 = 0;

        }

        if (!(flags & Readonly))

            XFreePixmap(xinfo.display(), hd);

        hd = 0;

    }

}

QPixmap QX11PixmapData::alphaChannel() const

{

    if (!hasAlphaChannel()) {

        QPixmap pm(w, h);

        pm.fill(Qt::white);

        return pm;

    }

    QImage im(toImage());

    return QPixmap::fromImage(im.alphaChannel(), Qt::OrderedDither);

}

void QX11PixmapData::setAlphaChannel(const QPixmap &alpha)

{

    QImage image(toImage());

    image.setAlphaChannel(alpha.toImage());

    release();

    fromImage(image, Qt::OrderedDither | Qt::OrderedAlphaDither);

}

QBitmap QX11PixmapData::mask() const

{

    QBitmap mask;

#ifndef QT_NO_XRENDER

    if (picture && d == 32) {

        // #### slow - there must be a better way..

        mask = QBitmap::fromImage(toImage().createAlphaMask());

    } else

#endif

    if (d == 1) {

        QX11PixmapData *that = const_cast<QX11PixmapData*>(this);

        mask = QPixmap(that);

    } else {

        mask = mask_to_bitmap(xinfo.screen());

    }

    return mask;

}

/*!

    Sets a mask bitmap.

    The \a newmask bitmap defines the clip mask for this pixmap. Every

    pixel in \a newmask corresponds to a pixel in this pixmap. Pixel

    value 1 means opaque and pixel value 0 means transparent. The mask

    must have the same size as this pixmap.

    \warning Setting the mask on a pixmap will cause any alpha channel

    data to be cleared. For example:

    \snippet doc/src/snippets/image/image.cpp 2

    Now, alpha and alphacopy are visually different.

    Setting a null mask resets the mask.

    The effect of this function is undefined when the pixmap is being

    painted on.

    \sa mask(), {QPixmap#Pixmap Transformations}{Pixmap

    Transformations}, QBitmap

*/

void QX11PixmapData::setMask(const QBitmap &newmask)

{

    if (newmask.isNull()) { // clear mask

#ifndef QT_NO_XRENDER

        if (picture && d == 32) {

            QX11PixmapData newData(pixelType());

            newData.resize(w, h);

            newData.fill(Qt::black);

            XRenderComposite(X11->display, PictOpOver,

                             picture, 0, newData.picture,

                             0, 0, 0, 0, 0, 0, w, h);

            release();

            *this = newData;

            // the new QX11PixmapData object isn't referenced yet, so

            // ref it

            ref.ref();

            // the below is to make sure the QX11PixmapData destructor

            // doesn't delete our newly created render picture

            newData.hd = 0;

            newData.x11_mask = 0;

            newData.picture = 0;

            newData.mask_picture = 0;

            newData.hd2 = 0;

        } else

#endif

            if (x11_mask) {

#ifndef QT_NO_XRENDER

                if (picture) {

                    XRenderPictureAttributes attrs;

                    attrs.alpha_map = 0;

                    XRenderChangePicture(X11->display, picture, CPAlphaMap,

                                         &attrs);

                }

                if (mask_picture)

                    XRenderFreePicture(X11->display, mask_picture);

                mask_picture = 0;

#endif

                XFreePixmap(X11->display, x11_mask);

                x11_mask = 0;

            }

        return;

    }

#ifndef QT_NO_XRENDER

    if (picture && d == 32) {

        XRenderComposite(X11->display, PictOpSrc,

                         picture, newmask.x11PictureHandle(),

                         picture, 0, 0, 0, 0, 0, 0, w, h);

    } else

#endif

        if (depth() == 1) {

            XGCValues vals;

            vals.function = GXand;

            GC gc = XCreateGC(X11->display, hd, GCFunction, &vals);

            XCopyArea(X11->display, newmask.handle(), hd, gc, 0, 0,

                      width(), height(), 0, 0);

            XFreeGC(X11->display, gc);

        } else {

            // ##### should or the masks together

            if (x11_mask) {

                XFreePixmap(X11->display, x11_mask);

#ifndef QT_NO_XRENDER

                if (mask_picture)

                    XRenderFreePicture(X11->display, mask_picture);

#endif

            }

            x11_mask = QX11PixmapData::bitmap_to_mask(newmask, xinfo.screen());

#ifndef QT_NO_XRENDER

            if (picture) {

                mask_picture = XRenderCreatePicture(X11->display, x11_mask,

                                                    XRenderFindStandardFormat(X11->display, PictStandardA1), 0, 0);

                XRenderPictureAttributes attrs;

                attrs.alpha_map = mask_picture;

                XRenderChangePicture(X11->display, picture, CPAlphaMap, &attrs);

            }

#endif

        }

}

int QX11PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const

{

    switch (metric) {

    case QPaintDevice::PdmWidth:

        return w;

    case QPaintDevice::PdmHeight:

        return h;

    case QPaintDevice::PdmNumColors:

        return 1 << d;

    case QPaintDevice::PdmDepth:

        return d;

    case QPaintDevice::PdmWidthMM: {

        const int screen = xinfo.screen();

        const int mm = DisplayWidthMM(X11->display, screen) * w

                       / DisplayWidth(X11->display, screen);

        return mm;

    }

    case QPaintDevice::PdmHeightMM: {

        const int screen = xinfo.screen();

        const int mm = (DisplayHeightMM(X11->display, screen) * h)

                       / DisplayHeight(X11->display, screen);

        return mm;

    }

    case QPaintDevice::PdmDpiX:

    case QPaintDevice::PdmPhysicalDpiX:

        return QX11Info::appDpiX(xinfo.screen());

    case QPaintDevice::PdmDpiY:

    case QPaintDevice::PdmPhysicalDpiY:

        return QX11Info::appDpiY(xinfo.screen());

    default:

        qWarning("QX11PixmapData::metric(): Invalid metric");

        return 0;

    }

}

/*!

    Converts the pixmap to a QImage. Returns a null image if the

    conversion fails.

    If the pixmap has 1-bit depth, the returned image will also be 1

    bit deep. If the pixmap has 2- to 8-bit depth, the returned image

    has 8-bit depth. If the pixmap has greater than 8-bit depth, the

    returned image has 32-bit depth.

    Note that for the moment, alpha masks on monochrome images are

    ignored.

    \sa fromImage(), {QImage#Image Formats}{Image Formats}

*/

QImage QX11PixmapData::toImage() const

{

    int d = depth();

    Visual *visual = (Visual *)xinfo.visual();

    bool trucol = (visual->c_class >= TrueColor) && d > 1;

    QImage::Format format = QImage::Format_Mono;

    if (d > 1 && d <= 8) {

        d = 8;

        format = QImage::Format_Indexed8;

    }

    // we could run into the situation where d == 8 AND trucol is true, which can

    // cause problems when converting to and from images.  in this case, always treat

    // the depth as 32...

    if (d > 8 || trucol) {

        d = 32;

        format = QImage::Format_RGB32;

    }

    XImage *xi = XGetImage(X11->display, hd, 0, 0, w, h, AllPlanes,

                           (d == 1) ? XYPixmap : ZPixmap);

    Q_CHECK_PTR(xi);

    if (!xi)

        return QImage();

    if (picture && depth() == 32) {

        QImage image(w, h, QImage::Format_ARGB32_Premultiplied);

        memcpy(image.bits(), xi->data, xi->bytes_per_line * xi->height);

        // we may have to swap the byte order

        if ((QSysInfo::ByteOrder == QSysInfo::LittleEndian && xi->byte_order == MSBFirst)

            || (QSysInfo::ByteOrder == QSysInfo::BigEndian && xi->byte_order == LSBFirst))

        {

            for (int i=0; i < image.height(); i++) {

                uint *p = (uint*)image.scanLine(i);

                uint *end = p + image.width();

                if ((xi->byte_order == LSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian)

                    || (xi->byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian)) {

                    while (p < end) {

                        *p = ((*p << 24) & 0xff000000) | ((*p << 8) & 0x00ff0000)

                             | ((*p >> 8) & 0x0000ff00) | ((*p >> 24) & 0x000000ff);

                        p++;

                    }

                } else if (xi->byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian) {

                    while (p < end) {

                        *p = ((*p << 16) & 0x00ff0000) | ((*p >> 16) & 0x000000ff)

                             | ((*p ) & 0xff00ff00);

                        p++;

                    }

                }

            }

        }

        // throw away image data

        qSafeXDestroyImage(xi);

        return image;

    }

    if (d == 1 && xi->bitmap_bit_order == LSBFirst)

        format = QImage::Format_MonoLSB;

    if (x11_mask && format == QImage::Format_RGB32)

        format = QImage::Format_ARGB32;

    QImage image(w, h, format);

    if (image.isNull())                        // could not create image

        return image;

    QImage alpha;

    if (x11_mask) {

        alpha = mask().toImage();

    }

    bool ale = alpha.format() == QImage::Format_MonoLSB;

    if (trucol) {                                // truecolor

        const uint red_mask = (uint)visual->red_mask;

        const uint green_mask = (uint)visual->green_mask;

        const uint blue_mask = (uint)visual->blue_mask;

        const int  red_shift = highest_bit(red_mask) - 7;

        const int  green_shift = highest_bit(green_mask) - 7;

        const int  blue_shift = highest_bit(blue_mask) - 7;

        const uint red_bits = n_bits(red_mask);

        const uint green_bits = n_bits(green_mask);

        const uint blue_bits = n_bits(blue_mask);

        static uint red_table_bits = 0;

        static uint green_table_bits = 0;

        static uint blue_table_bits = 0;

        if (red_bits < 8 && red_table_bits != red_bits) {

            build_scale_table(&red_scale_table, red_bits);

            red_table_bits = red_bits;

        }

        if (blue_bits < 8 && blue_table_bits != blue_bits) {

            build_scale_table(&blue_scale_table, blue_bits);

            blue_table_bits = blue_bits;

        }

        if (green_bits < 8 && green_table_bits != green_bits) {

            build_scale_table(&green_scale_table, green_bits);

            green_table_bits = green_bits;

        }

        int  r, g, b;

        QRgb *dst;

        uchar *src;

        uint pixel;

        int bppc = xi->bits_per_pixel;

        if (bppc > 8 && xi->byte_order == LSBFirst)

            bppc++;

        for (int y = 0; y < h; ++y) {

            uchar* asrc = x11_mask ? alpha.scanLine(y) : 0;