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

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

// 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;

        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);