src/gui/image/qimage.cpp File Reference

#include "qimage.h"
#include "qdatastream.h"
#include "qbuffer.h"
#include "qmap.h"
#include "qmatrix.h"
#include "qimagereader.h"
#include "qimagewriter.h"
#include "qstringlist.h"
#include "qvariant.h"
#include <ctype.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>
#include <private/qdrawhelper_p.h>
#include <private/qpixmap_p.h>
#include <qhash.h>
#include <qpaintengine.h>

Include dependency graph for qimage.cpp:

Go to the source code of this file.

Classes
struct	QImageData
struct	QRgbMap
Defines
#define	MAX_R   5
#define	MAX_G   5
#define	MAX_B   5
#define	INDEXOF(r, g, b)   (((r)*(MAX_G+1)+(g))*(MAX_B+1)+(b))
#define	DITHER(p, m)   ((uchar) ((p * (m) + 127) / 255))
#define	DITHER(p, d, m)   ((uchar) ((((256 * (m) + (m) + 1)) * (p) + (d)) >> 16))
#define	PIX(x, y)   (*((QRgb*)scanLine(y)+x) & 0x00ffffff)
#define	IWX_MSB(b)
#define	IWX_LSB(b)
#define	IWX_PIX(b)
Typedefs
typedef void(*)	_qt_image_cleanup_hook (int)
typedef void(*)	Image_Converter (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
Functions
static ushort	qt_convRgbTo16 (QRgb c)
static QRgb	qt_conv16ToRgb (ushort c)
static void	pnmscale (const QImage &src, QImage &dst)
static QImage	smoothScaled (const QImage &src, int w, int h)
static QImage	rotated90 (const QImage &src)
static QImage	rotated180 (const QImage &src)
static QImage	rotated270 (const QImage &src)
Q_GUI_EXPORT qint64	qt_image_id (const QImage &image)
const QVector< QRgb > *	qt_image_colortable (const QImage &image)
int	qt_defaultDpi ()
int	qimage_next_serial_number ()
static int	depthForFormat (QImage::Format format)
const uchar *	qt_get_bitflip_array ()
bool	qt_read_xpm_image_or_array (QIODevice *device, const char *const *source, QImage &image)
static void	convert_ARGB_to_ARGB_PM (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static void	convert_ARGB_PM_to_ARGB (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static void	convert_ARGB_PM_to_RGB (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static void	swap_bit_order (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static void	mask_alpha_converter (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static QVector< QRgb >	fix_color_table (const QVector< QRgb > &ctbl, QImage::Format format)
static void	dither_to_Mono (QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags, bool fromalpha)
static void	convert_X_to_Mono (QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
static void	convert_ARGB_PM_to_Mono (QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
static void	convert_RGB_to_Indexed8 (QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
static void	convert_ARGB_PM_to_Indexed8 (QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
static void	convert_ARGB_to_Indexed8 (QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
static void	convert_Indexed8_to_X32 (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static void	convert_Mono_to_X32 (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static void	convert_Mono_to_Indexed8 (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static void	convert_16_to_32 (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static void	convert_32_to_16 (QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
static int	pixel_distance (QRgb p1, QRgb p2)
static int	closestMatch (QRgb pixel, const QVector< QRgb > &clut)
static QImage	convertWithPalette (const QImage &src, QImage::Format format, const QVector< QRgb > &clut)
QDataStream &	operator<< (QDataStream &s, const QImage &image)
QDataStream &	operator>> (QDataStream &s, QImage &image)
bool	qt_xForm_helper (const QMatrix &trueMat, int xoffset, int type, int depth, uchar *dptr, int dbpl, int p_inc, int dHeight, const uchar *sptr, int sbpl, int sWidth, int sHeight)
Variables
Q_GUI_EXPORT _qt_image_cleanup_hook	qt_image_cleanup_hook = 0
QBasicAtomic	qimage_serial_number = Q_ATOMIC_INIT(1)
static const uchar	bitflip [256]
static const Image_Converter	converter_map [QImage::NImageFormats][QImage::NImageFormats]

---

Define Documentation

#define DITHER	(	p,
		d,
		m		)	((uchar) ((((256 * (m) + (m) + 1)) * (p) + (d)) >> 16))

#define DITHER	(	p,
		m		)	((uchar) ((p * (m) + 127) / 255))

Referenced by convert_RGB_to_Indexed8().

#define INDEXOF	(	r,
		g,
		b		)	(((r)*(MAX_G+1)+(g))*(MAX_B+1)+(b))

Referenced by convert_RGB_to_Indexed8().

#define IWX_LSB

(

b

)

Value:

if (trigx < maxws && trigy < maxhs) {                              \
                            if (*(sptr+sbpl*(trigy>>12)+(trigx>>15)) &                      \
                                 (1 << ((trigx>>12)&7)))                              \
                                *dptr |= b;                                              \
                        }                                                              \
                        trigx += m11;                                                      \
                        trigy += m12;

Definition at line 4822 of file qimage.cpp.

Referenced by qt_xForm_helper().

#define IWX_MSB

(

b

)

Value:

if (trigx < maxws && trigy < maxhs) {                              \
                            if (*(sptr+sbpl*(trigy>>12)+(trigx>>15)) &                      \
                                 (1 << (7-((trigx>>12)&7))))                              \
                                *dptr |= b;                                              \
                        }                                                              \
                        trigx += m11;                                                      \
                        trigy += m12;

Definition at line 4813 of file qimage.cpp.

Referenced by qt_xForm_helper().

#define IWX_PIX

(

b

)

Value:

if (trigx < maxws && trigy < maxhs) {                              \
                            if ((*(sptr+sbpl*(trigy>>12)+(trigx>>15)) &              \
                                 (1 << (7-((trigx>>12)&7)))) == 0)                      \
                                *dptr &= ~b;                                              \
                        }                                                              \
                        trigx += m11;                                                      \
                        trigy += m12;

Definition at line 4831 of file qimage.cpp.

Referenced by qt_xForm_helper().

#define MAX_B   5

Referenced by convert_RGB_to_Indexed8().

#define MAX_G   5

Referenced by convert_RGB_to_Indexed8().

#define MAX_R   5

Referenced by convert_RGB_to_Indexed8().

#define PIX	(	x,
		y		)	(*((QRgb*)scanLine(y)+x) & 0x00ffffff)

Referenced by QImage::createHeuristicMask().

---

Typedef Documentation

typedef void(*) _qt_image_cleanup_hook(int)

Definition at line 73 of file qimage.cpp.

typedef void(*) Image_Converter(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)

Definition at line 1965 of file qimage.cpp.

---

Function Documentation

static int closestMatch	(	QRgb	pixel,
		const QVector< QRgb > &	clut
	)			[inline, static]

Definition at line 3012 of file qimage.cpp.

References QVector< T >::at(), i, pixel_distance(), and QVector< T >::size().

Referenced by convertWithPalette().

                                                                      {
    int idx = 0;
    int current_distance = INT_MAX;
    for (int i=0; i<clut.size(); ++i) {
        int dist = pixel_distance(pixel, clut.at(i));
        if (dist < current_distance) {
            current_distance = dist;
            idx = i;
        }
    }
    return idx;
}

Here is the call graph for this function:

static void convert_16_to_32	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 2769 of file qimage.cpp.

References QImageData::bytes_per_line, QImageData::data, QImageData::format, QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImage::Format_RGB16, QImage::Format_RGB32, QImageData::height, p, qt_conv16ToRgb(), QImageData::width, and y.

Referenced by QImage::convertToFormat().

{
    Q_ASSERT(src->format == QImage::Format_RGB16);
    Q_ASSERT(dest->format == QImage::Format_RGB32
             || dest->format == QImage::Format_ARGB32_Premultiplied
             || dest->format == QImage::Format_ARGB32);
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);

    int w = src->width;
    const uchar *src_data = src->data;
    uchar *dest_data = dest->data;
    for (int y = 0; y < src->height; y++) {
        uint *p = (uint *)dest_data;
        const ushort *b = (ushort*)src_data;
        uint *end = p + w;

        while (p < end)
            *p++ = qt_conv16ToRgb(*b++);

        src_data += src->bytes_per_line;
        dest_data += dest->bytes_per_line;
    }
}

Here is the call graph for this function:

static void convert_32_to_16	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 2795 of file qimage.cpp.

References QImageData::bytes_per_line, QImageData::data, QImageData::format, QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImage::Format_RGB16, QImage::Format_RGB32, QImageData::height, p, qt_convRgbTo16(), QImageData::width, and y.

Referenced by QImage::convertToFormat().

{
    Q_ASSERT(dest->format == QImage::Format_RGB16);
    Q_ASSERT(src->format == QImage::Format_RGB32
             || src->format == QImage::Format_ARGB32_Premultiplied
             || src->format == QImage::Format_ARGB32);
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);

    int w = src->width;
    const uchar *src_data = src->data;
    uchar *dest_data = dest->data;
    for (int y = 0; y < src->height; y++) {
        ushort *p = (ushort *)dest_data;
        const uint *b = (const uint*)src_data;
        ushort *end = p + w;

        while (p < end)
            *p++ = qt_convRgbTo16(*b++);

        src_data += src->bytes_per_line;
        dest_data += dest->bytes_per_line;
    }
}

Here is the call graph for this function:

static void convert_ARGB_PM_to_ARGB	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 1986 of file qimage.cpp.

References QImageData::bytes_per_line, QImageData::data, QImageData::format, QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImageData::height, INV_PREMUL, QImageData::nbytes, QColor::QRgb(), and QImageData::width.

Referenced by convert_ARGB_PM_to_Indexed8(), and convert_ARGB_PM_to_Mono().

{
    Q_ASSERT(src->format == QImage::Format_ARGB32_Premultiplied);
    Q_ASSERT(dest->format == QImage::Format_ARGB32);
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);
    Q_ASSERT(src->nbytes == dest->nbytes);
    Q_ASSERT(src->bytes_per_line == dest->bytes_per_line);

    const QRgb *src_data = (QRgb *) src->data;
    const QRgb *end = src_data + (src->nbytes>>2);
    QRgb *dest_data = (QRgb *) dest->data;
    while (src_data < end) {
        *dest_data = INV_PREMUL(*src_data);
        ++src_data;
        ++dest_data;
    }
}

Here is the call graph for this function:

static void convert_ARGB_PM_to_Indexed8	(	QImageData *	dst,
		const QImageData *	src,
		Qt::ImageConversionFlags	flags
	)			[static]

Definition at line 2645 of file qimage.cpp.

References convert_ARGB_PM_to_ARGB(), convert_RGB_to_Indexed8(), QImageData::create(), QImage::Format_ARGB32, QImageData::height, and QImageData::width.

{
    QImageData *tmp = QImageData::create(QSize(src->width, src->height), QImage::Format_ARGB32);
    convert_ARGB_PM_to_ARGB(tmp, src, flags);
    convert_RGB_to_Indexed8(dst, tmp, flags);
    delete tmp;
}

Here is the call graph for this function:

static void convert_ARGB_PM_to_Mono	(	QImageData *	dst,
		const QImageData *	src,
		Qt::ImageConversionFlags	flags
	)			[static]

Definition at line 2357 of file qimage.cpp.

References convert_ARGB_PM_to_ARGB(), QImageData::create(), dither_to_Mono(), QImage::Format_ARGB32, QImageData::height, and QImageData::width.

{
    QImageData *tmp = QImageData::create(QSize(src->width, src->height), QImage::Format_ARGB32);
    convert_ARGB_PM_to_ARGB(tmp, src, flags);
    dither_to_Mono(dst, tmp, flags, false);
    delete tmp;
}

Here is the call graph for this function:

static void convert_ARGB_PM_to_RGB	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 2005 of file qimage.cpp.

References QImageData::bytes_per_line, QImageData::data, QImageData::format, QImage::Format_ARGB32_Premultiplied, QImage::Format_RGB32, QImageData::height, INV_PREMUL, QImageData::nbytes, QColor::QRgb(), and QImageData::width.

{
    Q_ASSERT(src->format == QImage::Format_ARGB32_Premultiplied);
    Q_ASSERT(dest->format == QImage::Format_RGB32);
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);
    Q_ASSERT(src->nbytes == dest->nbytes);
    Q_ASSERT(src->bytes_per_line == dest->bytes_per_line);

    const QRgb *src_data = (QRgb *) src->data;
    const QRgb *end = src_data + (src->nbytes>>2);
    QRgb *dest_data = (QRgb *) dest->data;
    while (src_data < end) {
        *dest_data = 0xff000000 | INV_PREMUL(*src_data);
        ++src_data;
        ++dest_data;
    }
}

Here is the call graph for this function:

static void convert_ARGB_to_ARGB_PM	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 1967 of file qimage.cpp.

References QImageData::bytes_per_line, QImageData::data, QImageData::format, QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImageData::height, QImageData::nbytes, PREMUL(), QColor::QRgb(), and QImageData::width.

{
    Q_ASSERT(src->format == QImage::Format_ARGB32);
    Q_ASSERT(dest->format == QImage::Format_ARGB32_Premultiplied);
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);
    Q_ASSERT(src->nbytes == dest->nbytes);
    Q_ASSERT(src->bytes_per_line == dest->bytes_per_line);

    const QRgb *src_data = (QRgb *) src->data;
    const QRgb *end = src_data + (src->nbytes>>2);
    QRgb *dest_data = (QRgb *) dest->data;
    while (src_data < end) {
        *dest_data = PREMUL(*src_data);
        ++src_data;
        ++dest_data;
    }
}

Here is the call graph for this function:

static void convert_ARGB_to_Indexed8	(	QImageData *	dst,
		const QImageData *	src,
		Qt::ImageConversionFlags	flags
	)			[static]

Definition at line 2653 of file qimage.cpp.

References convert_RGB_to_Indexed8().

{
    convert_RGB_to_Indexed8(dst, src, flags);
}

Here is the call graph for this function:

static void convert_Indexed8_to_X32	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 2658 of file qimage.cpp.

References QVector< T >::at(), QImageData::bytes_per_line, QImageData::colortable, QImageData::data, fix_color_table(), QImageData::format, QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImage::Format_Indexed8, QImage::Format_RGB32, QImageData::height, p, QImageData::width, and y.

{
    Q_ASSERT(src->format == QImage::Format_Indexed8);
    Q_ASSERT(dest->format == QImage::Format_RGB32
             || dest->format == QImage::Format_ARGB32
             || dest->format == QImage::Format_ARGB32_Premultiplied);
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);

    QVector<QRgb> colorTable = fix_color_table(src->colortable, dest->format);

    int w = src->width;
    const uchar *src_data = src->data;
    uchar *dest_data = dest->data;
    for (int y = 0; y < src->height; y++) {
        uint *p = (uint *)dest_data;
        const uchar *b = src_data;
        uint *end = p + w;

        while (p < end)
            *p++ = colorTable.at(*b++);

        src_data += src->bytes_per_line;
        dest_data += dest->bytes_per_line;
    }
}

Here is the call graph for this function:

static void convert_Mono_to_Indexed8	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 2727 of file qimage.cpp.

References QImageData::bytes_per_line, QImageData::colortable, QImageData::data, QImageData::format, QImage::Format_Indexed8, QImage::Format_Mono, QImage::Format_MonoLSB, QImageData::height, p, QVector< T >::resize(), QVector< T >::size(), QImageData::width, and y.

{
    Q_ASSERT(src->format == QImage::Format_Mono || src->format == QImage::Format_MonoLSB);
    Q_ASSERT(dest->format == QImage::Format_Indexed8);
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);

    QVector<QRgb> ctbl = src->colortable;
    if (ctbl.size() > 2) {
        ctbl.resize(2);
    } else if (ctbl.size() < 2) {
        if (ctbl.size() == 0)
            ctbl << 0xff000000;
        ctbl << 0xffffffff;
    }
    dest->colortable = ctbl;


    const uchar *src_data = src->data;
    uchar *dest_data = dest->data;
    if (src->format == QImage::Format_Mono) {
        for (int y = 0; y < dest->height; y++) {
            register uchar *p = dest_data;
            for (int x = 0; x < dest->width; x++)
                *p++ = (src_data[x>>3] >> (7 - (x & 7))) & 1;
            src_data += src->bytes_per_line;
            dest_data += dest->bytes_per_line;
        }
    } else {
        for (int y = 0; y < dest->height; y++) {
            register uchar *p = dest_data;
            for (int x = 0; x < dest->width; x++)
                *p++ = (src_data[x>>3] >> (x & 7)) & 1;
            src_data += src->bytes_per_line;
            dest_data += dest->bytes_per_line;
        }
    }
}

Here is the call graph for this function:

static void convert_Mono_to_X32	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 2685 of file qimage.cpp.

References QVector< T >::at(), QImageData::bytes_per_line, QImageData::colortable, QImageData::data, fix_color_table(), QImageData::format, QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImage::Format_Mono, QImage::Format_MonoLSB, QImage::Format_RGB32, QImageData::height, p, QVector< T >::size(), QImageData::width, and y.

{
    Q_ASSERT(src->format == QImage::Format_Mono || src->format == QImage::Format_MonoLSB);
    Q_ASSERT(dest->format == QImage::Format_RGB32
             || dest->format == QImage::Format_ARGB32
             || dest->format == QImage::Format_ARGB32_Premultiplied);
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);

    QVector<QRgb> colorTable = fix_color_table(src->colortable, dest->format);

    // Default to black / white colors
    if (colorTable.size() < 2) {
        if (colorTable.size() == 0)
            colorTable << 0xff000000;
        colorTable << 0xffffffff;
    }

    const uchar *src_data = src->data;
    uchar *dest_data = dest->data;
    if (src->format == QImage::Format_Mono) {
        for (int y = 0; y < dest->height; y++) {
            register uint *p = (uint *)dest_data;
            for (int x = 0; x < dest->width; x++)
                *p++ = colorTable.at((src_data[x>>3] >> (7 - (x & 7))) & 1);

            src_data += src->bytes_per_line;
            dest_data += dest->bytes_per_line;
        }
    } else {
        for (int y = 0; y < dest->height; y++) {
            register uint *p = (uint *)dest_data;
            for (int x = 0; x < dest->width; x++)
                *p++ = colorTable.at((src_data[x>>3] >> (x & 7)) & 1);

            src_data += src->bytes_per_line;
            dest_data += dest->bytes_per_line;
        }
    }
}

Here is the call graph for this function:

static void convert_RGB_to_Indexed8	(	QImageData *	dst,
		const QImageData *	src,
		Qt::ImageConversionFlags	flags
	)			[static]

Definition at line 2380 of file qimage.cpp.

References b, QImageData::bytes_per_line, QImageData::colortable, QImageData::data, Qt::DiffuseDither, DITHER, Qt::Dither_Mask, Qt::DitherMode_Mask, QImageData::format, QImage::Format_ARGB32, QImage::Format_Indexed8, QImage::Format_RGB32, QImageData::height, i, INDEXOF, QVector< T >::isEmpty(), m, MAX_B, MAX_G, MAX_R, p, Qt::PreferDither, QColor::qBlue(), QColor::qGreen(), qMax(), qMin(), QColor::qRed(), QColor::QRgb(), QColor::qRgb(), QVector< T >::resize(), rgb, s, QVector< T >::size(), Qt::ThresholdDither, used, QImageData::width, x, and y.

Referenced by convert_ARGB_PM_to_Indexed8(), and convert_ARGB_to_Indexed8().

{
    Q_ASSERT(src->format == QImage::Format_RGB32 || src->format == QImage::Format_ARGB32);
    Q_ASSERT(dst->format == QImage::Format_Indexed8);
    Q_ASSERT(src->width == dst->width);
    Q_ASSERT(src->height == dst->height);

    bool    do_quant = (flags & Qt::DitherMode_Mask) == Qt::PreferDither
                       || src->format == QImage::Format_ARGB32;
    uint alpha_mask = src->format == QImage::Format_RGB32 ? 0xff000000 : 0;

    const int tablesize = 997; // prime
    QRgbMap table[tablesize];
    int   pix=0;

    if (!dst->colortable.isEmpty()) {
        QVector<QRgb> ctbl = dst->colortable;
        dst->colortable.resize(256);
        // Preload palette into table.
        // Almost same code as pixel insertion below
        for (int i = 0; i < dst->colortable.size(); ++i) {
            // Find in table...
            QRgb p = ctbl.at(i) | alpha_mask;
            int hash = p % tablesize;
            for (;;) {
                if (table[hash].used()) {
                    if (table[hash].rgb == p) {
                        // Found previous insertion - use it
                        break;
                    } else {
                        // Keep searching...
                        if (++hash == tablesize) hash = 0;
                    }
                } else {
                    // Cannot be in table
                    Q_ASSERT (pix != 256);        // too many colors
                    // Insert into table at this unused position
                    dst->colortable[pix] = p;
                    table[hash].pix = pix++;
                    table[hash].rgb = p;
                    break;
                }
            }
        }
    }

    if ((flags & Qt::DitherMode_Mask) != Qt::PreferDither) {
        dst->colortable.resize(256);
        const uchar *src_data = src->data;
        uchar *dest_data = dst->data;
        for (int y = 0; y < src->height; y++) {        // check if <= 256 colors
            const QRgb *s = (const QRgb *)src_data;
            uchar *b = dest_data;
            for (int x = 0; x < src->width; ++x) {
                QRgb p = s[x] | alpha_mask;
                int hash = p % tablesize;
                for (;;) {
                    if (table[hash].used()) {
                        if (table[hash].rgb == (p)) {
                            // Found previous insertion - use it
                            break;
                        } else {
                            // Keep searching...
                            if (++hash == tablesize) hash = 0;
                        }
                    } else {
                        // Cannot be in table
                        if (pix == 256) {        // too many colors
                            do_quant = true;
                            // Break right out
                            x = src->width;
                            y = src->height;
                        } else {
                            // Insert into table at this unused position
                            dst->colortable[pix] = p;
                            table[hash].pix = pix++;
                            table[hash].rgb = p;
                        }
                        break;
                    }
                }
                *b++ = table[hash].pix;                // May occur once incorrectly
            }
            src_data += src->bytes_per_line;
            dest_data += dst->bytes_per_line;
        }
    }
    int numColors = do_quant ? 256 : pix;

    dst->colortable.resize(numColors);

    if (do_quant) {                                // quantization needed

#define MAX_R 5
#define MAX_G 5
#define MAX_B 5
#define INDEXOF(r,g,b) (((r)*(MAX_G+1)+(g))*(MAX_B+1)+(b))

        for (int rc=0; rc<=MAX_R; rc++)                // build 6x6x6 color cube
            for (int gc=0; gc<=MAX_G; gc++)
                for (int bc=0; bc<=MAX_B; bc++)
                    dst->colortable[INDEXOF(rc,gc,bc)] = 0xff000000 | qRgb(rc*255/MAX_R, gc*255/MAX_G, bc*255/MAX_B);

        const uchar *src_data = src->data;
        uchar *dest_data = dst->data;
        if ((flags & Qt::Dither_Mask) == Qt::ThresholdDither) {
            for (int y = 0; y < src->height; y++) {
                const QRgb *p = (const QRgb *)src_data;
                const QRgb *end = p + src->width;
                uchar *b = dest_data;

                while (p < end) {
#define DITHER(p,m) ((uchar) ((p * (m) + 127) / 255))
                    *b++ =
                        INDEXOF(
                            DITHER(qRed(*p), MAX_R),
                            DITHER(qGreen(*p), MAX_G),
                            DITHER(qBlue(*p), MAX_B)
                            );
#undef DITHER
                    p++;
                }
                src_data += src->bytes_per_line;
                dest_data += dst->bytes_per_line;
            }
        } else if ((flags & Qt::Dither_Mask) == Qt::DiffuseDither) {
            int* line1[3];
            int* line2[3];
            int* pv[3];
            line1[0] = new int[src->width];
            line2[0] = new int[src->width];
            line1[1] = new int[src->width];
            line2[1] = new int[src->width];
            line1[2] = new int[src->width];
            line2[2] = new int[src->width];
            pv[0] = new int[src->width];
            pv[1] = new int[src->width];
            pv[2] = new int[src->width];

            int endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian);
            for (int y = 0; y < src->height; y++) {
                const uchar* q = src_data;
                const uchar* q2 = y < src->height - 1 ? q + src->bytes_per_line : src->data;
                uchar *b = dest_data;
                for (int chan = 0; chan < 3; chan++) {
                    int *l1 = (y&1) ? line2[chan] : line1[chan];
                    int *l2 = (y&1) ? line1[chan] : line2[chan];
                    if (y == 0) {
                        for (int i = 0; i < src->width; i++)
                            l1[i] = q[i*4+chan+endian];
                    }
                    if (y+1 < src->height) {
                        for (int i = 0; i < src->width; i++)
                            l2[i] = q2[i*4+chan+endian];
                    }
                    // Bi-directional error diffusion
                    if (y&1) {
                        for (int x = 0; x < src->width; x++) {
                            int pix = qMax(qMin(5, (l1[x] * 5 + 128)/ 255), 0);
                            int err = l1[x] - pix * 255 / 5;
                            pv[chan][x] = pix;

                            // Spread the error around...
                            if (x + 1< src->width) {
                                l1[x+1] += (err*7)>>4;
                                l2[x+1] += err>>4;
                            }
                            l2[x]+=(err*5)>>4;
                            if (x>1)
                                l2[x-1]+=(err*3)>>4;
                        }
                    } else {
                        for (int x = src->width; x-- > 0;) {
                            int pix = qMax(qMin(5, (l1[x] * 5 + 128)/ 255), 0);
                            int err = l1[x] - pix * 255 / 5;
                            pv[chan][x] = pix;

                            // Spread the error around...
                            if (x > 0) {
                                l1[x-1] += (err*7)>>4;
                                l2[x-1] += err>>4;
                            }
                            l2[x]+=(err*5)>>4;
                            if (x + 1 < src->width)
                                l2[x+1]+=(err*3)>>4;
                        }
                    }
                }
                if (endian) {
                    for (int x = 0; x < src->width; x++) {
                        *b++ = INDEXOF(pv[0][x],pv[1][x],pv[2][x]);
                    }
                } else {
                    for (int x = 0; x < src->width; x++) {
                        *b++ = INDEXOF(pv[2][x],pv[1][x],pv[0][x]);
                    }
                }
                src_data += src->bytes_per_line;
                dest_data += dst->bytes_per_line;
            }
            delete [] line1[0];
            delete [] line2[0];
            delete [] line1[1];
            delete [] line2[1];
            delete [] line1[2];
            delete [] line2[2];
            delete [] pv[0];
            delete [] pv[1];
            delete [] pv[2];
        } else { // OrderedDither
            for (int y = 0; y < src->height; y++) {
                const QRgb *p = (const QRgb *)src_data;
                const QRgb *end = p + src->width;
                uchar *b = dest_data;

                int x = 0;
                while (p < end) {
                    uint d = qt_bayer_matrix[y & 15][x & 15] << 8;

#define DITHER(p, d, m) ((uchar) ((((256 * (m) + (m) + 1)) * (p) + (d)) >> 16))
                    *b++ =
                        INDEXOF(
                            DITHER(qRed(*p), d, MAX_R),
                            DITHER(qGreen(*p), d, MAX_G),
                            DITHER(qBlue(*p), d, MAX_B)
                            );
#undef DITHER

                    p++;
                    x++;
                }
                src_data += src->bytes_per_line;
                dest_data += dst->bytes_per_line;
            }
        }

        if (src->format != QImage::Format_RGB32
            && src->format != QImage::Format_RGB16) {
            const int trans = 216;
            Q_ASSERT(dst->colortable.size() > trans);
            dst->colortable[trans] = 0;
            QImageData *mask = QImageData::create(QSize(src->width, src->height), QImage::Format_Mono);
            dither_to_Mono(mask, src, flags, true);
            uchar *dst_data = dst->data;
            const uchar *mask_data = mask->data;
            for (int y = 0; y < src->height; y++) {
                for (int x = 0; x < src->width ; x++) {
                    if (!(mask_data[x>>3] & (0x80 >> (x & 7))))
                        dst_data[x] = trans;
                }
                mask_data += mask->bytes_per_line;
                dst_data += dst->bytes_per_line;
            }
            dst->has_alpha_clut = true;
            delete mask;
        }

#undef MAX_R
#undef MAX_G
#undef MAX_B
#undef INDEXOF

    }
}

Here is the call graph for this function:

static void convert_X_to_Mono	(	QImageData *	dst,
		const QImageData *	src,
		Qt::ImageConversionFlags	flags
	)			[static]

Definition at line 2352 of file qimage.cpp.

References dither_to_Mono().

{
    dither_to_Mono(dst, src, flags, false);
}

Here is the call graph for this function:

static QImage convertWithPalette	(	const QImage &	src,
		QImage::Format	format,
		const QVector< QRgb > &	clut
	)			[static]

Definition at line 3025 of file qimage.cpp.

References closestMatch(), QImage::Format_Indexed8, QImage::height(), QHash< Key, T >::insert(), QColor::QRgb(), QVector< T >::resize(), QImage::scanLine(), QImage::setColorTable(), QImage::size(), QString::SkipEmptyParts, QString::split(), QImage::text(), value, QHash< Key, T >::value(), QImage::width(), and y.

Referenced by QImage::convertToFormat().

                                                            {
    QImage dest(src.size(), format);
    dest.setColorTable(clut);

#if !defined(QT_NO_IMAGE_TEXT)
    QString textsKeys = src.text();
    QStringList textKeyList = textsKeys.split("\n", QString::SkipEmptyParts);
    foreach (QString textKey, textKeyList) {
        QStringList textKeySplitted = textKey.split(": ");
        dest.setText(textKeySplitted[0], textKeySplitted[1]);
    }
#endif // !QT_NO_IMAGE_TEXT

    int h = src.height();
    int w = src.width();

    QHash<QRgb, int> cache;

    if (format == QImage::Format_Indexed8) {
        for (int y=0; y<h; ++y) {
            QRgb *src_pixels = (QRgb *) src.scanLine(y);
            uchar *dest_pixels = (uchar *) dest.scanLine(y);
            for (int x=0; x<w; ++x) {
                int src_pixel = src_pixels[x];
                int value = cache.value(src_pixel, -1);
                if (value == -1) {
                    value = closestMatch(src_pixel, clut);
                    cache.insert(src_pixel, value);
                }
                dest_pixels[x] = (uchar) value;
            }
        }
    } else {
        QVector<QRgb> table = clut;
        table.resize(2);
        for (int y=0; y<h; ++y) {
            QRgb *src_pixels = (QRgb *) src.scanLine(y);
            for (int x=0; x<w; ++x) {
                int src_pixel = src_pixels[x];
                int value = cache.value(src_pixel, -1);
                if (value == -1) {
                    value = closestMatch(src_pixel, table);
                    cache.insert(src_pixel, value);
                }
                dest.setPixel(x, y, value);
            }
        }
    }

    return dest;
}

Here is the call graph for this function:

static int depthForFormat

(

QImage::Format

format

)

[static]

Definition at line 193 of file qimage.cpp.

References QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImage::Format_Indexed8, QImage::Format_Invalid, QImage::Format_Mono, QImage::Format_MonoLSB, QImage::Format_RGB16, QImage::Format_RGB32, and QImage::NImageFormats.

Referenced by QImage::convertToFormat(), and QImage::QImage().

{
    int depth = 0;
    switch(format) {
    case QImage::Format_Invalid:
    case QImage::NImageFormats:
        Q_ASSERT(false);
    case QImage::Format_Mono:
    case QImage::Format_MonoLSB:
        depth = 1;
        break;
    case QImage::Format_Indexed8:
        depth = 8;
        break;
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32:
    case QImage::Format_ARGB32_Premultiplied:
        depth = 32;
        break;
    case QImage::Format_RGB16:
        depth = 16;
        break;
    }
    return depth;
}

static void dither_to_Mono	(	QImageData *	dst,
		const QImageData *	src,
		Qt::ImageConversionFlags	flags,
		bool	fromalpha
	)			[static]

Definition at line 2081 of file qimage.cpp.

References Qt::AlphaDither_Mask, QVector< T >::append(), QVector< T >::at(), bitflip, QImageData::bytes_per_line, QVector< T >::clear(), QImageData::colortable, d, QImageData::data, QImageData::depth, Qt::DiffuseAlphaDither, Qt::Dither_Mask, QImageData::format, QImage::Format_Mono, QImage::Format_MonoLSB, Qt::gray, QImageData::height, i, j, m, QImageData::nbytes, Qt::OrderedAlphaDither, Qt::OrderedDither, p, QColor::qGray(), qt_bayer_matrix, QVector< T >::size(), Qt::ThresholdDither, QImageData::width, x, and y.

Referenced by convert_ARGB_PM_to_Mono(), convert_X_to_Mono(), and QImage::createAlphaMask().

{
    Q_ASSERT(src->width == dst->width);
    Q_ASSERT(src->height == dst->height);
    Q_ASSERT(dst->format == QImage::Format_Mono || dst->format == QImage::Format_MonoLSB);

    dst->colortable.clear();
    dst->colortable.append(0xffffffff);
    dst->colortable.append(0xff000000);

    enum { Threshold, Ordered, Diffuse } dithermode;

    if (fromalpha) {
        if ((flags & Qt::AlphaDither_Mask) == Qt::DiffuseAlphaDither)
            dithermode = Diffuse;
        else if ((flags & Qt::AlphaDither_Mask) == Qt::OrderedAlphaDither)
            dithermode = Ordered;
        else
            dithermode = Threshold;
    } else {
        if ((flags & Qt::Dither_Mask) == Qt::ThresholdDither)
            dithermode = Threshold;
        else if ((flags & Qt::Dither_Mask) == Qt::OrderedDither)
            dithermode = Ordered;
        else
            dithermode = Diffuse;
    }

    int          w = src->width;
    int          h = src->height;
    int          d = src->depth;
    uchar gray[256];                                // gray map for 8 bit images
    bool  use_gray = (d == 8);
    if (use_gray) {                                // make gray map
        if (fromalpha) {
            // Alpha 0x00 -> 0 pixels (white)
            // Alpha 0xFF -> 1 pixels (black)
            for (int i = 0; i < src->colortable.size(); i++)
                gray[i] = (255 - (src->colortable.at(i) >> 24));
        } else {
            // Pixel 0x00 -> 1 pixels (black)
            // Pixel 0xFF -> 0 pixels (white)
            for (int i = 0; i < src->colortable.size(); i++)
                gray[i] = qGray(src->colortable.at(i));
        }
    }

    uchar *dst_data = dst->data;
    int dst_bpl = dst->bytes_per_line;
    const uchar *src_data = src->data;
    int src_bpl = src->bytes_per_line;

    switch (dithermode) {
    case Diffuse: {
        int *line1 = new int[w];
        int *line2 = new int[w];
        int bmwidth = (w+7)/8;

        int *b1, *b2;
        int wbytes = w * (d/8);
        register const uchar *p = src->data;
        const uchar *end = p + wbytes;
        b2 = line2;
        if (use_gray) {                        // 8 bit image
            while (p < end)
                *b2++ = gray[*p++];
        } else {                                // 32 bit image
            if (fromalpha) {
                while (p < end) {
                    *b2++ = 255 - (*(uint*)p >> 24);
                    p += 4;
                }
            } else {
                while (p < end) {
                    *b2++ = qGray(*(uint*)p);
                    p += 4;
                }
            }
        }
        for (int y=0; y<h; y++) {                        // for each scan line...
            int *tmp = line1; line1 = line2; line2 = tmp;
            bool not_last_line = y < h - 1;
            if (not_last_line) {                // calc. grayvals for next line
                p = src->data + (y+1)*src->bytes_per_line;
                end = p + wbytes;
                b2 = line2;
                if (use_gray) {                // 8 bit image
                    while (p < end)
                        *b2++ = gray[*p++];
                } else {                        // 24 bit image
                    if (fromalpha) {
                        while (p < end) {
                            *b2++ = 255 - (*(uint*)p >> 24);
                            p += 4;
                        }
                    } else {
                        while (p < end) {
                            *b2++ = qGray(*(uint*)p);
                            p += 4;
                        }
                    }
                }
            }

            int err;
            uchar *p = dst->data + y*dst->bytes_per_line;
            memset(p, 0, bmwidth);
            b1 = line1;
            b2 = line2;
            int bit = 7;
            for (int x=1; x<=w; x++) {
                if (*b1 < 128) {                // black pixel
                    err = *b1++;
                    *p |= 1 << bit;
                } else {                        // white pixel
                    err = *b1++ - 255;
                }
                if (bit == 0) {
                    p++;
                    bit = 7;
                } else {
                    bit--;
                }
                if (x < w)
                    *b1 += (err*7)>>4;                // spread error to right pixel
                if (not_last_line) {
                    b2[0] += (err*5)>>4;        // pixel below
                    if (x > 1)
                        b2[-1] += (err*3)>>4;        // pixel below left
                    if (x < w)
                        b2[1] += err>>4;        // pixel below right
                }
                b2++;
            }
        }
        delete [] line1;
        delete [] line2;
    } break;
    case Ordered: {

        memset(dst->data, 0, dst->nbytes);
        if (d == 32) {
            for (int i=0; i<h; i++) {
                const uint *p = (const uint *)src_data;
                const uint *end = p + w;
                uchar *m = dst_data;
                int bit = 7;
                int j = 0;
                if (fromalpha) {
                    while (p < end) {
                        if ((*p++ >> 24) >= qt_bayer_matrix[j++&15][i&15])
                            *m |= 1 << bit;
                        if (bit == 0) {
                            m++;
                            bit = 7;
                        } else {
                            bit--;
                        }
                    }
                } else {
                    while (p < end) {
                        if ((uint)qGray(*p++) < qt_bayer_matrix[j++&15][i&15])
                            *m |= 1 << bit;
                        if (bit == 0) {
                            m++;
                            bit = 7;
                        } else {
                            bit--;
                        }
                    }
                }
                dst_data += dst_bpl;
                src_data += src_bpl;
            }
        } else
            /* (d == 8) */ {
            for (int i=0; i<h; i++) {
                const uchar *p = src_data;
                const uchar *end = p + w;
                uchar *m = dst_data;
                int bit = 7;
                int j = 0;
                while (p < end) {
                    if ((uint)gray[*p++] < qt_bayer_matrix[j++&15][i&15])
                        *m |= 1 << bit;
                    if (bit == 0) {
                        m++;
                        bit = 7;
                    } else {
                        bit--;
                    }
                }
                dst_data += dst_bpl;
                src_data += src_bpl;
            }
        }
    } break;
    default: { // Threshold:
        memset(dst->data, 0, dst->nbytes);
        if (d == 32) {
            for (int i=0; i<h; i++) {
                const uint *p = (const uint *)src_data;
                const uint *end = p + w;
                uchar *m = dst_data;
                int bit = 7;
                if (fromalpha) {
                    while (p < end) {
                        if ((*p++ >> 24) >= 128)
                            *m |= 1 << bit;        // Set mask "on"
                        if (bit == 0) {
                            m++;
                            bit = 7;
                        } else {
                            bit--;
                        }
                    }
                } else {
                    while (p < end) {
                        if (qGray(*p++) < 128)
                            *m |= 1 << bit;        // Set pixel "black"
                        if (bit == 0) {
                            m++;
                            bit = 7;
                        } else {
                            bit--;
                        }
                    }
                }
                dst_data += dst_bpl;
                src_data += src_bpl;
            }
        } else
            if (d == 8) {
                for (int i=0; i<h; i++) {
                    const uchar *p = src_data;
                    const uchar *end = p + w;
                    uchar *m = dst_data;
                    int bit = 7;
                    while (p < end) {
                        if (gray[*p++] < 128)
                            *m |= 1 << bit;                // Set mask "on"/ pixel "black"
                        if (bit == 0) {
                            m++;
                            bit = 7;
                        } else {
                            bit--;
                        }
                    }
                    dst_data += dst_bpl;
                    src_data += src_bpl;
                }
            }
        }
    }

    if (dst->format == QImage::Format_MonoLSB) {
        // need to swap bit order
        uchar *sl = dst->data;
        int bpl = (dst->width + 7) * dst->depth / 8;
        int pad = dst->bytes_per_line - bpl;
        for (int y=0; y<dst->height; ++y) {
            for (int x=0; x<bpl; ++x) {
                *sl = bitflip[*sl];
                ++sl;
            }
            sl += pad;
        }
    }
}

Here is the call graph for this function:

static QVector<QRgb> fix_color_table	(	const QVector< QRgb > &	ctbl,
		QImage::Format	format
	)			[static]

Definition at line 2061 of file qimage.cpp.

References QVector< T >::at(), QImage::Format_ARGB32_Premultiplied, QImage::Format_RGB32, i, PREMUL(), QColor::qAlpha(), and QVector< T >::size().

Referenced by convert_Indexed8_to_X32(), and convert_Mono_to_X32().

{
    QVector<QRgb> colorTable = ctbl;
    if (format == QImage::Format_RGB32) {
        // check if the color table has alpha
        for (int i = 0; i < colorTable.size(); ++i)
            if (qAlpha(colorTable.at(i) != 0xff))
                colorTable[i] = colorTable.at(i) | 0xff000000;
    } else if (format == QImage::Format_ARGB32_Premultiplied) {
        // check if the color table has alpha
        for (int i = 0; i < colorTable.size(); ++i)
            colorTable[i] = PREMUL(colorTable.at(i));
    }
    return colorTable;
}

Here is the call graph for this function:

static void mask_alpha_converter	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 2045 of file qimage.cpp.

References QImageData::data, QImageData::height, QImageData::nbytes, and QImageData::width.

{
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);
    Q_ASSERT(src->nbytes == dest->nbytes);

    const uint *src_data = (const uint *)src->data;
    const uint *end = (const uint *)(src->data + src->nbytes);
    uint *dest_data = (uint *)dest->data;
    while (src_data < end) {
        *dest_data = *src_data | 0xff000000;
        ++src_data;
        ++dest_data;
    }
}

QDataStream& operator<<	(	QDataStream &	s,
		const QImage &	image
	)			[related]

Definition at line 4255 of file qimage.cpp.

{
    if (s.version() >= 5) {
        if (image.isNull()) {
            s << (qint32) 0; // null image marker
            return s;
        } else {
            s << (qint32) 1;
            // continue ...
        }
    }
    QImageWriter writer(s.device(), s.version() == 1 ? "bmp" : "png");
    writer.write(image);
    return s;
}

QDataStream& operator>>	(	QDataStream &	s,
		QImage &	image
	)			[related]

Definition at line 4281 of file qimage.cpp.

{
    if (s.version() >= 5) {
        qint32 nullMarker;
        s >> nullMarker;
        if (!nullMarker) {
            image = QImage(); // null image
            return s;
        }
    }
    image = QImageReader(s.device(), 0).read();
    return s;
}

static int pixel_distance	(	QRgb	p1,
		QRgb	p2
	)			[inline, static]

Definition at line 2998 of file qimage.cpp.

References QColor::qAlpha(), QColor::qBlue(), QColor::qGreen(), and QColor::qRed().

Referenced by closestMatch().

                                                   {
    int r1 = qRed(p1);
    int g1 = qGreen(p1);
    int b1 = qBlue(p1);
    int a1 = qAlpha(p1);

    int r2 = qRed(p2);
    int g2 = qGreen(p2);
    int b2 = qBlue(p2);
    int a2 = qAlpha(p2);

    return abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2) + abs(a1 - a2);
}

Here is the call graph for this function:

static void pnmscale	(	const QImage &	src,
		QImage &	dst
	)			[static]

Definition at line 5223 of file qimage.cpp.

References a, QImage::convertToFormat(), QImage::format(), g, QImage::hasAlphaChannel(), QImage::height(), QColor::qAlpha(), QColor::qBlue(), QColor::qGreen(), QColor::qRed(), QColor::QRgb(), QColor::qRgb(), QColor::qRgba(), row, QImage::scanLine(), and QImage::width().

Referenced by smoothScaled().

{
    QRgb* xelrow = 0;
    QRgb* tempxelrow = 0;
    register QRgb* xP;
    register QRgb* nxP;
    int rows, cols, rowsread, newrows, newcols;
    register int row, col, needtoreadrow;
    const uchar maxval = 255;
    double xscale, yscale;
    long sxscale, syscale;
    register long fracrowtofill, fracrowleft;
    long* as;
    long* rs;
    long* gs;
    long* bs;
    int rowswritten = 0;

    cols = src.width();
    rows = src.height();
    newcols = dst.width();
    newrows = dst.height();

    long SCALE;
    long HALFSCALE;

    if (cols > 4096)
    {
        SCALE = 4096;
        HALFSCALE = 2048;
    }
    else
    {
        int fac = 4096;

        while (cols * fac > 4096)
        {
            fac /= 2;
        }

        SCALE = fac * cols;
        HALFSCALE = fac * cols / 2;
    }

    xscale = (double) newcols / (double) cols;
    yscale = (double) newrows / (double) rows;

    sxscale = (long)(xscale * SCALE);
    syscale = (long)(yscale * SCALE);

    if ( newrows != rows )  /* shortcut Y scaling if possible */
  tempxelrow = new QRgb[cols];

    if ( src.hasAlphaChannel() ) {
        dst = dst.convertToFormat(src.format());
  as = new long[cols];
  for ( col = 0; col < cols; ++col )
      as[col] = HALFSCALE;
    } else {
  as = 0;
    }
    rs = new long[cols];
    gs = new long[cols];
    bs = new long[cols];
    rowsread = 0;
    fracrowleft = syscale;
    needtoreadrow = 1;
    for ( col = 0; col < cols; ++col )
  rs[col] = gs[col] = bs[col] = HALFSCALE;
    fracrowtofill = SCALE;

    for ( row = 0; row < newrows; ++row ) {
  /* First scale Y from xelrow into tempxelrow. */
  if ( newrows == rows ) {
      /* shortcut Y scaling if possible */
      tempxelrow = xelrow = (QRgb*)src.scanLine(rowsread++);
  } else {
      while ( fracrowleft < fracrowtofill ) {
    if ( needtoreadrow && rowsread < rows )
        xelrow = (QRgb*)src.scanLine(rowsread++);
    for ( col = 0, xP = xelrow; col < cols; ++col, ++xP ) {
        if (as) {
      as[col] += fracrowleft * qAlpha( *xP );
      rs[col] += fracrowleft * qRed( *xP ) * qAlpha( *xP ) / 255;
      gs[col] += fracrowleft * qGreen( *xP ) * qAlpha( *xP ) / 255;
      bs[col] += fracrowleft * qBlue( *xP ) * qAlpha( *xP ) / 255;
        } else {
      rs[col] += fracrowleft * qRed( *xP );
      gs[col] += fracrowleft * qGreen( *xP );
      bs[col] += fracrowleft * qBlue( *xP );
        }
    }
    fracrowtofill -= fracrowleft;
    fracrowleft = syscale;
    needtoreadrow = 1;
      }
      /* Now fracrowleft is >= fracrowtofill, so we can produce a row. */
      if ( needtoreadrow && rowsread < rows ) {
    xelrow = (QRgb*)src.scanLine(rowsread++);
    needtoreadrow = 0;
      }
      register long a=0;
      for ( col = 0, xP = xelrow, nxP = tempxelrow;
      col < cols; ++col, ++xP, ++nxP )
      {
    register long r, g, b;

    if ( as ) {
        r = rs[col] + fracrowtofill * qRed( *xP ) * qAlpha( *xP ) / 255;
        g = gs[col] + fracrowtofill * qGreen( *xP ) * qAlpha( *xP ) / 255;
        b = bs[col] + fracrowtofill * qBlue( *xP ) * qAlpha( *xP ) / 255;
        a = as[col] + fracrowtofill * qAlpha( *xP );
        if ( a ) {
      r = r * 255 / a * SCALE;
      g = g * 255 / a * SCALE;
      b = b * 255 / a * SCALE;
        }
    } else {
        r = rs[col] + fracrowtofill * qRed( *xP );
        g = gs[col] + fracrowtofill * qGreen( *xP );
        b = bs[col] + fracrowtofill * qBlue( *xP );
    }
    r /= SCALE;
    if ( r > maxval ) r = maxval;
    g /= SCALE;
    if ( g > maxval ) g = maxval;
    b /= SCALE;
    if ( b > maxval ) b = maxval;
    if ( as ) {
        a /= SCALE;
        if ( a > maxval ) a = maxval;
        *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
        as[col] = HALFSCALE;
    } else {
        *nxP = qRgb( (int)r, (int)g, (int)b );
    }
    rs[col] = gs[col] = bs[col] = HALFSCALE;
      }
      fracrowleft -= fracrowtofill;
      if ( fracrowleft == 0 ) {
    fracrowleft = syscale;
    needtoreadrow = 1;
      }
      fracrowtofill = SCALE;
  }

  /* Now scale X from tempxelrow into dst and write it out. */
  if ( newcols == cols ) {
      /* shortcut X scaling if possible */
      memcpy(dst.scanLine(rowswritten++), tempxelrow, newcols*4);
  } else {
      register long a, r, g, b;
      register long fraccoltofill, fraccolleft = 0;
      register int needcol;

      nxP = (QRgb*)dst.scanLine(rowswritten++);
      fraccoltofill = SCALE;
      a = r = g = b = HALFSCALE;
      needcol = 0;
      for ( col = 0, xP = tempxelrow; col < cols; ++col, ++xP ) {
    fraccolleft = sxscale;
    while ( fraccolleft >= fraccoltofill ) {
        if ( needcol ) {
      ++nxP;
      a = r = g = b = HALFSCALE;
        }
        if ( as ) {
      r += fraccoltofill * qRed( *xP ) * qAlpha( *xP ) / 255;
      g += fraccoltofill * qGreen( *xP ) * qAlpha( *xP ) / 255;
      b += fraccoltofill * qBlue( *xP ) * qAlpha( *xP ) / 255;
      a += fraccoltofill * qAlpha( *xP );
      if ( a ) {
          r = r * 255 / a * SCALE;
          g = g * 255 / a * SCALE;
          b = b * 255 / a * SCALE;
      }
        } else {
      r += fraccoltofill * qRed( *xP );
      g += fraccoltofill * qGreen( *xP );
      b += fraccoltofill * qBlue( *xP );
        }
        r /= SCALE;
        if ( r > maxval ) r = maxval;
        g /= SCALE;
        if ( g > maxval ) g = maxval;
        b /= SCALE;
        if ( b > maxval ) b = maxval;
        if (as) {
      a /= SCALE;
      if ( a > maxval ) a = maxval;
      *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
        } else {
      *nxP = qRgb( (int)r, (int)g, (int)b );
        }
        fraccolleft -= fraccoltofill;
        fraccoltofill = SCALE;
        needcol = 1;
    }
    if ( fraccolleft > 0 ) {
        if ( needcol ) {
      ++nxP;
      a = r = g = b = HALFSCALE;
      needcol = 0;
        }
        if (as) {
      a += fraccolleft * qAlpha( *xP );
      r += fraccolleft * qRed( *xP ) * qAlpha( *xP ) / 255;
      g += fraccolleft * qGreen( *xP ) * qAlpha( *xP ) / 255;
      b += fraccolleft * qBlue( *xP ) * qAlpha( *xP ) / 255;
        } else {
      r += fraccolleft * qRed( *xP );
      g += fraccolleft * qGreen( *xP );
      b += fraccolleft * qBlue( *xP );
        }
        fraccoltofill -= fraccolleft;
    }
      }
      if ( fraccoltofill > 0 ) {
    --xP;
    if (as) {
        a += fraccolleft * qAlpha( *xP );
        r += fraccoltofill * qRed( *xP ) * qAlpha( *xP ) / 255;
        g += fraccoltofill * qGreen( *xP ) * qAlpha( *xP ) / 255;
        b += fraccoltofill * qBlue( *xP ) * qAlpha( *xP ) / 255;
        if ( a ) {
      r = r * 255 / a * SCALE;
      g = g * 255 / a * SCALE;
      b = b * 255 / a * SCALE;
        }
    } else {
        r += fraccoltofill * qRed( *xP );
        g += fraccoltofill * qGreen( *xP );
        b += fraccoltofill * qBlue( *xP );
    }
      }
      if ( ! needcol ) {
    r /= SCALE;
    if ( r > maxval ) r = maxval;
    g /= SCALE;
    if ( g > maxval ) g = maxval;
    b /= SCALE;
    if ( b > maxval ) b = maxval;
    if (as) {
        a /= SCALE;
        if ( a > maxval ) a = maxval;
        *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
    } else {
        *nxP = qRgb( (int)r, (int)g, (int)b );
    }
      }
  }
    }

    if ( newrows != rows && tempxelrow )// Robust, tempxelrow might be 0 1 day
  delete [] tempxelrow;
    if ( as )       // Avoid purify complaint
  delete [] as;
    if ( rs )       // Robust, rs might be 0 one day
  delete [] rs;
    if ( gs )       // Robust, gs might be 0 one day
  delete [] gs;
    if ( bs )       // Robust, bs might be 0 one day
  delete [] bs;
}

Here is the call graph for this function:

int qimage_next_serial_number

(

)

Definition at line 156 of file qimage.cpp.

References id, qimage_serial_number, and QBasicAtomic::testAndSet().

Referenced by QImageData::QImageData().

{
    register int id;
    for (;;) {
        id = qimage_serial_number;
        if (qimage_serial_number.testAndSet(id, id + 1))
            break;
    }
    return id;
}

Here is the call graph for this function:

static QRgb qt_conv16ToRgb

(

ushort

c

)

[inline, static]

Definition at line 58 of file qimage.cpp.

References QColor::QRgb().

Referenced by QImage::allGray(), convert_16_to_32(), and QImage::pixel().

{
    QRgb r = (((c) << 3) & 0xf8)
             | (((c) << 5) & 0xfc00)
             | (((c) << 8) & 0xf80000);
    r |= (r >> 5) & 0x70007;
    r |= (r >> 6) & 0x300;
    return r | 0xff000000;
}

Here is the call graph for this function:

static ushort qt_convRgbTo16

(

QRgb

c

)

[inline, static]

Definition at line 51 of file qimage.cpp.

Referenced by convert_32_to_16(), and QImage::setPixel().

{
    return ((c >> 8) & 0xf800)
        | ((c >> 5) & 0x07e)
        | ((c >> 3) & 0x1f);
}

int qt_defaultDpi

(

)

Definition at line 119 of file qfont.cpp.

Referenced by QPicture::exec(), generateWavyPath(), getPixmapSize(), QTextDocumentLayoutPrivate::indent(), QTextDocumentLayoutPrivate::layoutBlock(), QGLPixelBuffer::metric(), QGLFramebufferObject::metric(), QPicture::metric(), QTextDocument::print(), QFontMetrics::QFontMetrics(), QFontMetricsF::QFontMetricsF(), QImageData::QImageData(), and QPdfBaseEnginePrivate::QPdfBaseEnginePrivate().

{
    if (!qt_is_gui_used)
        return 75;

    int dpi;
#ifdef Q_WS_X11
    dpi = QX11Info::appDpiY();
#elif defined(Q_WS_WIN)
    dpi = GetDeviceCaps(shared_dc,LOGPIXELSY);
#elif defined(Q_WS_MAC)
    short hr;
    short mdpi;
    ScreenRes(&hr, &mdpi);
    dpi = int(mdpi);
#elif defined(Q_WS_QWS)
    if (!qt_screen)
        return 72;
    QScreen *screen = qt_screen;
    const QList<QScreen*> subScreens = qt_screen->subScreens();
    if (!subScreens.isEmpty())
        screen = subScreens.at(0);
    dpi = qRound(screen->height() / double(screen->physicalHeight() / 25.4));
#endif // Q_WS_X11

    return dpi;
}

const uchar* qt_get_bitflip_array

(

)

Definition at line 733 of file qimage.cpp.

References bitflip.

{
    return bitflip;
}

const QVector<QRgb>* qt_image_colortable

(

const QImage &

image

)

Definition at line 148 of file qimage.cpp.

References QImage::Format_Indexed8, and image.

Referenced by QSpanData::initTexture().

{
    return (image.d->format <= QImage::Format_Indexed8 && !image.d->colortable.isEmpty()) ? &image.d->colortable : 0;
}

Q_GUI_EXPORT qint64 qt_image_id

(

const QImage &

image

)

Definition at line 143 of file qimage.cpp.

References image.

Referenced by QGLContextPrivate::bindTexture(), and QPdfEngine::drawImage().

{
    return (((qint64) image.d->ser_no) << 32) | ((qint64) image.d->detach_no);
}

bool qt_read_xpm_image_or_array	(	QIODevice *	device,
		const char *const *	source,
		QImage &	image
	)

Definition at line 1009 of file qxpmhandler.cpp.

References buf, cpp(), h, image, index, read_xpm_body(), read_xpm_header(), QIODevice::readLine(), QIODevice::ungetChar(), and w.

Referenced by QImage::QImage().

{
    QByteArray buf(200, 0);
    QByteArray state;

    int cpp, ncols, w, h, index = 0;

    if (device) {
        // "/* XPM */"
        int readBytes;
        if ((readBytes = device->readLine(buf.data(), buf.size())) < 0)
            return false;

        if (buf.indexOf("/* XPM") != 0) {
            while (readBytes > 0) {
                device->ungetChar(buf.at(readBytes - 1));
                --readBytes;
            }
            return false;
        }// bad magic
    }

    if (!read_xpm_header(device, source, index, state, &cpp, &ncols, &w, &h))
        return false;

    return read_xpm_body(device, source, index, state, cpp, ncols, w, h, image);
}

Here is the call graph for this function:

bool qt_xForm_helper	(	const QMatrix &	trueMat,
		int	xoffset,
		int	type,
		int	depth,
		uchar *	dptr,
		int	dbpl,
		int	p_inc,
		int	dHeight,
		const uchar *	sptr,
		int	sbpl,
		int	sWidth,
		int	sHeight
	)

Definition at line 4839 of file qimage.cpp.

References QMatrix::dx(), QMatrix::dy(), IWX_LSB, IWX_MSB, IWX_PIX, QMatrix::m11(), QMatrix::m12(), QMatrix::m21(), QMatrix::m22(), qRound(), QT_XFORM_TYPE_LSBFIRST, QT_XFORM_TYPE_MSBFIRST, and y.

Referenced by QImage::transformed().

{
    int m11 = qRound(trueMat.m11()*4096.0);
    int m12 = qRound(trueMat.m12()*4096.0);
    int m21 = qRound(trueMat.m21()*4096.0);
    int m22 = qRound(trueMat.m22()*4096.0);
    int dx  = qRound(trueMat.dx()*4096.0);
    int dy  = qRound(trueMat.dy()*4096.0);

    int m21ydx = dx + (xoffset<<16);
    int m22ydy = dy;
    uint trigx;
    uint trigy;
    uint maxws = sWidth<<12;
    uint maxhs = sHeight<<12;

    for (int y=0; y<dHeight; y++) {                // for each target scanline
        trigx = m21ydx;
        trigy = m22ydy;
        uchar *maxp = dptr + dbpl;
        if (depth != 1) {
            switch (depth) {
                case 8:                                // 8 bpp transform
                while (dptr < maxp) {
                    if (trigx < maxws && trigy < maxhs)
                        *dptr = *(sptr+sbpl*(trigy>>12)+(trigx>>12));
                    trigx += m11;
                    trigy += m12;
                    dptr++;
                }
                break;

                case 16:                        // 16 bpp transform
                while (dptr < maxp) {
                    if (trigx < maxws && trigy < maxhs)
                        *((ushort*)dptr) = *((ushort *)(sptr+sbpl*(trigy>>12) +
                                                     ((trigx>>12)<<1)));
                    trigx += m11;
                    trigy += m12;
                    dptr++;
                    dptr++;
                }
                break;

                case 24:                        // 24 bpp transform
                while (dptr < maxp) {
                    if (trigx < maxws && trigy < maxhs) {
                        const uchar *p2 = sptr+sbpl*(trigy>>12) + ((trigx>>12)*3);
                        dptr[0] = p2[0];
                        dptr[1] = p2[1];
                        dptr[2] = p2[2];
                    }
                    trigx += m11;
                    trigy += m12;
                    dptr += 3;
                }
                break;

                case 32:                        // 32 bpp transform
                while (dptr < maxp) {
                    if (trigx < maxws && trigy < maxhs)
                        *((uint*)dptr) = *((uint *)(sptr+sbpl*(trigy>>12) +
                                                   ((trigx>>12)<<2)));
                    trigx += m11;
                    trigy += m12;
                    dptr += 4;
                }
                break;

                default: {
                return false;
                }
            }
        } else  {
            switch (type) {
                case QT_XFORM_TYPE_MSBFIRST:
                    while (dptr < maxp) {
                        IWX_MSB(128);
                        IWX_MSB(64);
                        IWX_MSB(32);
                        IWX_MSB(16);
                        IWX_MSB(8);
                        IWX_MSB(4);
                        IWX_MSB(2);
                        IWX_MSB(1);
                        dptr++;
                    }
                    break;
                case QT_XFORM_TYPE_LSBFIRST:
                    while (dptr < maxp) {
                        IWX_LSB(1);
                        IWX_LSB(2);
                        IWX_LSB(4);
                        IWX_LSB(8);
                        IWX_LSB(16);
                        IWX_LSB(32);
                        IWX_LSB(64);
                        IWX_LSB(128);
                        dptr++;
                    }
                    break;
#  if defined(Q_WS_WIN)
                case QT_XFORM_TYPE_WINDOWSPIXMAP:
                    while (dptr < maxp) {
                        IWX_PIX(128);
                        IWX_PIX(64);
                        IWX_PIX(32);
                        IWX_PIX(16);
                        IWX_PIX(8);
                        IWX_PIX(4);
                        IWX_PIX(2);
                        IWX_PIX(1);
                        dptr++;
                    }
                    break;
#  endif
            }
        }
        m21ydx += m21;
        m22ydy += m22;
        dptr += p_inc;
    }
    return true;
}

Here is the call graph for this function:

static QImage rotated180

(

const QImage &

src

)

[static]

Definition at line 5549 of file qimage.cpp.

References image.

Referenced by QImage::transformed().

                                              {
    return image.mirrored(true, true);
}

static QImage rotated270

(

const QImage &

src

)

[static]

Definition at line 5554 of file qimage.cpp.

References QImage::bits(), QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImage::Format_Indexed8, QImage::Format_RGB32, image, QColor::QRgb(), QImage::setColorTable(), QImage::setPixel(), and y.

Referenced by QImage::transformed().

                                              {
    QImage out(image.height(), image.width(), image.format());
    if (image.numColors() > 0)
        out.setColorTable(image.colorTable());
    int w = image.width();
    int h = image.height();
    switch (image.format()) {
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32:
    case QImage::Format_ARGB32_Premultiplied:
        {
            QRgb *dst = (QRgb *) out.bits();
            for (int y=0; y<h; ++y) {
                const QRgb *src = (const QRgb *) image.scanLine(y);
                for (int x=0; x<w; ++x)
                    dst[y + (w-x-1)*h] = *src++;
            }
        }
        break;
    case QImage::Format_Indexed8:
        {
            uchar *dst = out.bits();
            for (int y=0; y<h; ++y) {
                const uchar *src = image.scanLine(y);
                for (int x=0; x<w; ++x) {
                    dst[y + (w-x-1)*h] = *src++;
                }
            }
        }
        break;
    default:
        for (int y=0; y<h; ++y) {
            if (image.numColors())
                for (int x=0; x<w; ++x)
                    out.setPixel(y, w-x-1, image.pixelIndex(x, y));
            else
                for (int x=0; x<w; ++x)
                    out.setPixel(y, w-x-1, image.pixel(x, y));
        }
        break;
    }
    return out;
}

Here is the call graph for this function:

static QImage rotated90

(

const QImage &

src

)

[static]

Definition at line 5504 of file qimage.cpp.

References QImage::bits(), QImage::Format_ARGB32, QImage::Format_ARGB32_Premultiplied, QImage::Format_Indexed8, QImage::Format_RGB32, image, QColor::QRgb(), QImage::setColorTable(), QImage::setPixel(), and y.

Referenced by QImage::transformed().

                                             {
    QImage out(image.height(), image.width(), image.format());
    if (image.numColors() > 0)
        out.setColorTable(image.colorTable());
    int w = image.width();
    int h = image.height();
    switch (image.format()) {
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32:
    case QImage::Format_ARGB32_Premultiplied:
        {
            QRgb *dst = (QRgb *) out.bits();
            for (int y=0; y<h; ++y) {
                const QRgb *src = (const QRgb *) image.scanLine(y);
                for (int x=0; x<w; ++x)
                    dst[x*h + h-y-1] = *src++;
            }
        }
        break;
    case QImage::Format_Indexed8:
        {
            uchar *dst = out.bits();
            for (int y=0; y<h; ++y) {
                const uchar *src = image.scanLine(y);
                for (int x=0; x<w; ++x) {
                    dst[x*h + h-y-1] = *src++;
                }
            }
        }
        break;
    default:
        for (int y=0; y<h; ++y) {
            if (image.numColors())
                for (int x=0; x<w; ++x)
                    out.setPixel(h-y-1, x, image.pixelIndex(x, y));
            else
                for (int x=0; x<w; ++x)
                    out.setPixel(h-y-1, x, image.pixel(x, y));
        }
        break;
    }
    return out;
}

Here is the call graph for this function:

static QImage smoothScaled	(	const QImage &	src,
		int	w,
		int	h
	)			[static]

Definition at line 5489 of file qimage.cpp.

References QImage::convertToFormat(), QImage::format(), QImage::Format_ARGB32, QImage::Format_RGB32, QImage::hasAlphaChannel(), and pnmscale().

Referenced by QImage::transformed().

                                                            {
    QImage::Format sf = src.format();
    QImage source = src;
    if (sf != QImage::Format_RGB32 && sf != QImage::Format_ARGB32) {
        if (src.hasAlphaChannel())
            source = src.convertToFormat(QImage::Format_ARGB32);
        else
            source = src.convertToFormat(QImage::Format_RGB32);
    }
    QImage dest(w, h, source.format());
    pnmscale(source, dest);
    return dest;
}

Here is the call graph for this function:

static void swap_bit_order	(	QImageData *	dest,
		const QImageData *	src,
		Qt::ImageConversionFlags
	)			[static]

Definition at line 2024 of file qimage.cpp.

References bitflip, QImageData::bytes_per_line, QImageData::colortable, QImageData::data, QImageData::format, QImage::Format_Mono, QImage::Format_MonoLSB, QImageData::height, QImageData::nbytes, and QImageData::width.

{
    Q_ASSERT(src->format == QImage::Format_Mono || src->format == QImage::Format_MonoLSB);
    Q_ASSERT(dest->format == QImage::Format_Mono || dest->format == QImage::Format_MonoLSB);
    Q_ASSERT(src->width == dest->width);
    Q_ASSERT(src->height == dest->height);
    Q_ASSERT(src->nbytes == dest->nbytes);
    Q_ASSERT(src->bytes_per_line == dest->bytes_per_line);

    dest->colortable = src->colortable;

    const uchar *src_data = src->data;
    const uchar *end = src->data + src->nbytes;
    uchar *dest_data = dest->data;
    while (src_data < end) {
        *dest_data = bitflip[*src_data];
        ++src_data;
        ++dest_data;
    }
}

---

Variable Documentation

const uchar bitflip[256] [static]

Initial value:

 {
    
    0, 128, 64, 192, 32, 160, 96, 224, 16, 144, 80, 208, 48, 176, 112, 240,
    8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248,
    4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244,
    12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252,
    2, 130, 66, 194, 34, 162, 98, 226, 18, 146, 82, 210, 50, 178, 114, 242,
    10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250,
    6, 134, 70, 198, 38, 166, 102, 230, 22, 150, 86, 214, 54, 182, 118, 246,
    14, 142, 78, 206, 46, 174, 110, 238, 30, 158, 94, 222, 62, 190, 126, 254,
    1, 129, 65, 193, 33, 161, 97, 225, 17, 145, 81, 209, 49, 177, 113, 241,
    9, 137, 73, 201, 41, 169, 105, 233, 25, 153, 89, 217, 57, 185, 121, 249,
    5, 133, 69, 197, 37, 165, 101, 229, 21, 149, 85, 213, 53, 181, 117, 245,
    13, 141, 77, 205, 45, 173, 109, 237, 29, 157, 93, 221, 61, 189, 125, 253,
    3, 131, 67, 195, 35, 163, 99, 227, 19, 147, 83, 211, 51, 179, 115, 243,
    11, 139, 75, 203, 43, 171, 107, 235, 27, 155, 91, 219, 59, 187, 123, 251,
    7, 135, 71, 199, 39, 167, 103, 231, 23, 151, 87, 215, 55, 183, 119, 247,
    15, 143, 79, 207, 47, 175, 111, 239, 31, 159, 95, 223, 63, 191, 127, 255
}

Definition at line 704 of file qimage.cpp.

Referenced by dither_to_Mono(), qt_get_bitflip_array(), and swap_bit_order().

const Image_Converter converter_map[QImage::NImageFormats][QImage::NImageFormats] [static]

Definition at line 2837 of file qimage.cpp.

QBasicAtomic qimage_serial_number = Q_ATOMIC_INIT(1)

Definition at line 155 of file qimage.cpp.

Referenced by qimage_next_serial_number().

Q_GUI_EXPORT _qt_image_cleanup_hook qt_image_cleanup_hook = 0

Definition at line 74 of file qimage.cpp.

Referenced by QGLContextPrivate::bindTexture(), QGLContext::~QGLContext(), and QImageData::~QImageData().

---