| /**************************************************************************** |
| ** |
| ** 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$ |
| ** GNU Lesser General Public License Usage |
| ** 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. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qimage.h" |
| #include "qdatastream.h" |
| #include "qbuffer.h" |
| #include "qmap.h" |
| #include "qmatrix.h" |
| #include "qtransform.h" |
| #include "qimagereader.h" |
| #include "qimagewriter.h" |
| #include "qstringlist.h" |
| #include "qvariant.h" |
| #include "qimagepixmapcleanuphooks_p.h" |
| #include <ctype.h> |
| #include <stdlib.h> |
| #include <limits.h> |
| #include <math.h> |
| #include <private/qdrawhelper_p.h> |
| #include <private/qmemrotate_p.h> |
| #include <private/qpixmapdata_p.h> |
| #include <private/qimagescale_p.h> |
| #include <private/qsimd_p.h> |
| |
| #include <qhash.h> |
| |
| #if defined(Q_OS_SYMBIAN) |
| #include <private/qpaintengine_raster_symbian_p.h> |
| #else |
| #include <private/qpaintengine_raster_p.h> |
| #endif |
| |
| #include <private/qimage_p.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| static inline bool checkPixelSize(const QImage::Format format) |
| { |
| switch (format) { |
| case QImage::Format_ARGB8565_Premultiplied: |
| return (sizeof(qargb8565) == 3); |
| case QImage::Format_RGB666: |
| return (sizeof(qrgb666) == 3); |
| case QImage::Format_ARGB6666_Premultiplied: |
| return (sizeof(qargb6666) == 3); |
| case QImage::Format_RGB555: |
| return (sizeof(qrgb555) == 2); |
| case QImage::Format_ARGB8555_Premultiplied: |
| return (sizeof(qargb8555) == 3); |
| case QImage::Format_RGB888: |
| return (sizeof(qrgb888) == 3); |
| case QImage::Format_RGB444: |
| return (sizeof(qrgb444) == 2); |
| case QImage::Format_ARGB4444_Premultiplied: |
| return (sizeof(qargb4444) == 2); |
| default: |
| return true; |
| } |
| } |
| |
| #if defined(Q_CC_DEC) && defined(__alpha) && (__DECCXX_VER-0 >= 50190001) |
| #pragma message disable narrowptr |
| #endif |
| |
| |
| #define QIMAGE_SANITYCHECK_MEMORY(image) \ |
| if ((image).isNull()) { \ |
| qWarning("QImage: out of memory, returning null image"); \ |
| return QImage(); \ |
| } |
| |
| |
| static QImage rotated90(const QImage &src); |
| static QImage rotated180(const QImage &src); |
| static QImage rotated270(const QImage &src); |
| |
| // ### Qt 5: remove |
| Q_GUI_EXPORT qint64 qt_image_id(const QImage &image) |
| { |
| return image.cacheKey(); |
| } |
| |
| const QVector<QRgb> *qt_image_colortable(const QImage &image) |
| { |
| return &image.d->colortable; |
| } |
| |
| Q_GUI_EXPORT extern int qt_defaultDpiX(); |
| Q_GUI_EXPORT extern int qt_defaultDpiY(); |
| |
| QBasicAtomicInt qimage_serial_number = Q_BASIC_ATOMIC_INITIALIZER(1); |
| |
| QImageData::QImageData() |
| : ref(0), width(0), height(0), depth(0), nbytes(0), data(0), |
| #ifdef QT3_SUPPORT |
| jumptable(0), |
| #endif |
| format(QImage::Format_ARGB32), bytes_per_line(0), |
| ser_no(qimage_serial_number.fetchAndAddRelaxed(1)), |
| detach_no(0), |
| dpmx(qt_defaultDpiX() * 100 / qreal(2.54)), |
| dpmy(qt_defaultDpiY() * 100 / qreal(2.54)), |
| offset(0, 0), own_data(true), ro_data(false), has_alpha_clut(false), |
| is_cached(false), paintEngine(0) |
| { |
| } |
| |
| static int depthForFormat(QImage::Format format) |
| { |
| 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_RGB555: |
| case QImage::Format_RGB16: |
| case QImage::Format_RGB444: |
| case QImage::Format_ARGB4444_Premultiplied: |
| depth = 16; |
| break; |
| case QImage::Format_RGB666: |
| case QImage::Format_ARGB6666_Premultiplied: |
| case QImage::Format_ARGB8565_Premultiplied: |
| case QImage::Format_ARGB8555_Premultiplied: |
| case QImage::Format_RGB888: |
| depth = 24; |
| break; |
| } |
| return depth; |
| } |
| |
| /*! \fn QImageData * QImageData::create(const QSize &size, QImage::Format format, int numColors) |
| |
| \internal |
| |
| Creates a new image data. |
| Returns 0 if invalid parameters are give or anything else failed. |
| */ |
| QImageData * QImageData::create(const QSize &size, QImage::Format format, int numColors) |
| { |
| if (!size.isValid() || numColors < 0 || format == QImage::Format_Invalid) |
| return 0; // invalid parameter(s) |
| |
| if (!checkPixelSize(format)) { |
| qWarning("QImageData::create(): Invalid pixel size for format %i", |
| format); |
| return 0; |
| } |
| |
| uint width = size.width(); |
| uint height = size.height(); |
| uint depth = depthForFormat(format); |
| |
| switch (format) { |
| case QImage::Format_Mono: |
| case QImage::Format_MonoLSB: |
| numColors = 2; |
| break; |
| case QImage::Format_Indexed8: |
| numColors = qBound(0, numColors, 256); |
| break; |
| default: |
| numColors = 0; |
| break; |
| } |
| |
| const int bytes_per_line = ((width * depth + 31) >> 5) << 2; // bytes per scanline (must be multiple of 4) |
| |
| // sanity check for potential overflows |
| if (INT_MAX/depth < width |
| || bytes_per_line <= 0 |
| || height <= 0 |
| || INT_MAX/uint(bytes_per_line) < height |
| || INT_MAX/sizeof(uchar *) < uint(height)) |
| return 0; |
| |
| QScopedPointer<QImageData> d(new QImageData); |
| d->colortable.resize(numColors); |
| if (depth == 1) { |
| d->colortable[0] = QColor(Qt::black).rgba(); |
| d->colortable[1] = QColor(Qt::white).rgba(); |
| } else { |
| for (int i = 0; i < numColors; ++i) |
| d->colortable[i] = 0; |
| } |
| |
| d->width = width; |
| d->height = height; |
| d->depth = depth; |
| d->format = format; |
| d->has_alpha_clut = false; |
| d->is_cached = false; |
| |
| d->bytes_per_line = bytes_per_line; |
| |
| d->nbytes = d->bytes_per_line*height; |
| d->data = (uchar *)malloc(d->nbytes); |
| |
| if (!d->data) { |
| return 0; |
| } |
| |
| d->ref.ref(); |
| return d.take(); |
| |
| } |
| |
| QImageData::~QImageData() |
| { |
| if (is_cached) |
| QImagePixmapCleanupHooks::executeImageHooks((((qint64) ser_no) << 32) | ((qint64) detach_no)); |
| delete paintEngine; |
| if (data && own_data) |
| free(data); |
| #ifdef QT3_SUPPORT |
| if (jumptable) |
| free(jumptable); |
| jumptable = 0; |
| #endif |
| data = 0; |
| } |
| |
| |
| bool QImageData::checkForAlphaPixels() const |
| { |
| bool has_alpha_pixels = false; |
| |
| switch (format) { |
| |
| case QImage::Format_Mono: |
| case QImage::Format_MonoLSB: |
| case QImage::Format_Indexed8: |
| has_alpha_pixels = has_alpha_clut; |
| break; |
| |
| case QImage::Format_ARGB32: |
| case QImage::Format_ARGB32_Premultiplied: { |
| uchar *bits = data; |
| for (int y=0; y<height && !has_alpha_pixels; ++y) { |
| for (int x=0; x<width; ++x) |
| has_alpha_pixels |= (((uint *)bits)[x] & 0xff000000) != 0xff000000; |
| bits += bytes_per_line; |
| } |
| } break; |
| |
| case QImage::Format_ARGB8555_Premultiplied: |
| case QImage::Format_ARGB8565_Premultiplied: { |
| uchar *bits = data; |
| uchar *end_bits = data + bytes_per_line; |
| |
| for (int y=0; y<height && !has_alpha_pixels; ++y) { |
| while (bits < end_bits) { |
| has_alpha_pixels |= bits[0] != 0; |
| bits += 3; |
| } |
| bits = end_bits; |
| end_bits += bytes_per_line; |
| } |
| } break; |
| |
| case QImage::Format_ARGB6666_Premultiplied: { |
| uchar *bits = data; |
| uchar *end_bits = data + bytes_per_line; |
| |
| for (int y=0; y<height && !has_alpha_pixels; ++y) { |
| while (bits < end_bits) { |
| has_alpha_pixels |= (bits[0] & 0xfc) != 0; |
| bits += 3; |
| } |
| bits = end_bits; |
| end_bits += bytes_per_line; |
| } |
| } break; |
| |
| case QImage::Format_ARGB4444_Premultiplied: { |
| uchar *bits = data; |
| uchar *end_bits = data + bytes_per_line; |
| |
| for (int y=0; y<height && !has_alpha_pixels; ++y) { |
| while (bits < end_bits) { |
| has_alpha_pixels |= (bits[0] & 0xf0) != 0; |
| bits += 2; |
| } |
| bits = end_bits; |
| end_bits += bytes_per_line; |
| } |
| } break; |
| |
| default: |
| break; |
| } |
| |
| return has_alpha_pixels; |
| } |
| |
| /*! |
| \class QImage |
| |
| \ingroup painting |
| \ingroup shared |
| |
| \reentrant |
| |
| \brief The QImage class provides a hardware-independent image |
| representation that allows direct access to the pixel data, and |
| can be used as a paint device. |
| |
| Qt provides four classes for handling image data: QImage, QPixmap, |
| QBitmap and QPicture. QImage is designed and optimized for I/O, |
| and for direct pixel access and manipulation, while QPixmap is |
| designed and optimized for showing images on screen. QBitmap is |
| only a convenience class that inherits QPixmap, ensuring a |
| depth of 1. Finally, the QPicture class is a paint device that |
| records and replays QPainter commands. |
| |
| Because QImage is a QPaintDevice subclass, QPainter can be used to |
| draw directly onto images. When using QPainter on a QImage, the |
| painting can be performed in another thread than the current GUI |
| thread. |
| |
| The QImage class supports several image formats described by the |
| \l Format enum. These include monochrome, 8-bit, 32-bit and |
| alpha-blended images which are available in all versions of Qt |
| 4.x. |
| |
| QImage provides a collection of functions that can be used to |
| obtain a variety of information about the image. There are also |
| several functions that enables transformation of the image. |
| |
| QImage objects can be passed around by value since the QImage |
| class uses \l{Implicit Data Sharing}{implicit data |
| sharing}. QImage objects can also be streamed and compared. |
| |
| \note If you would like to load QImage objects in a static build of Qt, |
| refer to the \l{How To Create Qt Plugins#Static Plugins}{Plugin HowTo}. |
| |
| \warning Painting on a QImage with the format |
| QImage::Format_Indexed8 is not supported. |
| |
| \tableofcontents |
| |
| \section1 Reading and Writing Image Files |
| |
| QImage provides several ways of loading an image file: The file |
| can be loaded when constructing the QImage object, or by using the |
| load() or loadFromData() functions later on. QImage also provides |
| the static fromData() function, constructing a QImage from the |
| given data. When loading an image, the file name can either refer |
| to an actual file on disk or to one of the application's embedded |
| resources. See \l{The Qt Resource System} overview for details |
| on how to embed images and other resource files in the |
| application's executable. |
| |
| Simply call the save() function to save a QImage object. |
| |
| The complete list of supported file formats are available through |
| the QImageReader::supportedImageFormats() and |
| QImageWriter::supportedImageFormats() functions. New file formats |
| can be added as plugins. By default, Qt supports the following |
| formats: |
| |
| \table |
| \header \o Format \o Description \o Qt's support |
| \row \o BMP \o Windows Bitmap \o Read/write |
| \row \o GIF \o Graphic Interchange Format (optional) \o Read |
| \row \o JPG \o Joint Photographic Experts Group \o Read/write |
| \row \o JPEG \o Joint Photographic Experts Group \o Read/write |
| \row \o PNG \o Portable Network Graphics \o Read/write |
| \row \o PBM \o Portable Bitmap \o Read |
| \row \o PGM \o Portable Graymap \o Read |
| \row \o PPM \o Portable Pixmap \o Read/write |
| \row \o TIFF \o Tagged Image File Format \o Read/write |
| \row \o XBM \o X11 Bitmap \o Read/write |
| \row \o XPM \o X11 Pixmap \o Read/write |
| \endtable |
| |
| \section1 Image Information |
| |
| QImage provides a collection of functions that can be used to |
| obtain a variety of information about the image: |
| |
| \table |
| \header |
| \o \o Available Functions |
| |
| \row |
| \o Geometry |
| \o |
| |
| The size(), width(), height(), dotsPerMeterX(), and |
| dotsPerMeterY() functions provide information about the image size |
| and aspect ratio. |
| |
| The rect() function returns the image's enclosing rectangle. The |
| valid() function tells if a given pair of coordinates is within |
| this rectangle. The offset() function returns the number of pixels |
| by which the image is intended to be offset by when positioned |
| relative to other images, which also can be manipulated using the |
| setOffset() function. |
| |
| \row |
| \o Colors |
| \o |
| |
| The color of a pixel can be retrieved by passing its coordinates |
| to the pixel() function. The pixel() function returns the color |
| as a QRgb value indepedent of the image's format. |
| |
| In case of monochrome and 8-bit images, the colorCount() and |
| colorTable() functions provide information about the color |
| components used to store the image data: The colorTable() function |
| returns the image's entire color table. To obtain a single entry, |
| use the pixelIndex() function to retrieve the pixel index for a |
| given pair of coordinates, then use the color() function to |
| retrieve the color. Note that if you create an 8-bit image |
| manually, you have to set a valid color table on the image as |
| well. |
| |
| The hasAlphaChannel() function tells if the image's format |
| respects the alpha channel, or not. The allGray() and |
| isGrayscale() functions tell whether an image's colors are all |
| shades of gray. |
| |
| See also the \l {QImage#Pixel Manipulation}{Pixel Manipulation} |
| and \l {QImage#Image Transformations}{Image Transformations} |
| sections. |
| |
| \row |
| \o Text |
| \o |
| |
| The text() function returns the image text associated with the |
| given text key. An image's text keys can be retrieved using the |
| textKeys() function. Use the setText() function to alter an |
| image's text. |
| |
| \row |
| \o Low-level information |
| \o |
| |
| The depth() function returns the depth of the image. The supported |
| depths are 1 (monochrome), 8, 16, 24 and 32 bits. The |
| bitPlaneCount() function tells how many of those bits that are |
| used. For more information see the |
| \l {QImage#Image Formats}{Image Formats} section. |
| |
| The format(), bytesPerLine(), and byteCount() functions provide |
| low-level information about the data stored in the image. |
| |
| The cacheKey() function returns a number that uniquely |
| identifies the contents of this QImage object. |
| \endtable |
| |
| \section1 Pixel Manipulation |
| |
| The functions used to manipulate an image's pixels depend on the |
| image format. The reason is that monochrome and 8-bit images are |
| index-based and use a color lookup table, while 32-bit images |
| store ARGB values directly. For more information on image formats, |
| see the \l {Image Formats} section. |
| |
| In case of a 32-bit image, the setPixel() function can be used to |
| alter the color of the pixel at the given coordinates to any other |
| color specified as an ARGB quadruplet. To make a suitable QRgb |
| value, use the qRgb() (adding a default alpha component to the |
| given RGB values, i.e. creating an opaque color) or qRgba() |
| function. For example: |
| |
| \table |
| \header |
| \o {2,1}32-bit |
| \row |
| \o \inlineimage qimage-32bit_scaled.png |
| \o |
| \snippet doc/src/snippets/code/src_gui_image_qimage.cpp 0 |
| \endtable |
| |
| In case of a 8-bit and monchrome images, the pixel value is only |
| an index from the image's color table. So the setPixel() function |
| can only be used to alter the color of the pixel at the given |
| coordinates to a predefined color from the image's color table, |
| i.e. it can only change the pixel's index value. To alter or add a |
| color to an image's color table, use the setColor() function. |
| |
| An entry in the color table is an ARGB quadruplet encoded as an |
| QRgb value. Use the qRgb() and qRgba() functions to make a |
| suitable QRgb value for use with the setColor() function. For |
| example: |
| |
| \table |
| \header |
| \o {2,1} 8-bit |
| \row |
| \o \inlineimage qimage-8bit_scaled.png |
| \o |
| \snippet doc/src/snippets/code/src_gui_image_qimage.cpp 1 |
| \endtable |
| |
| QImage also provide the scanLine() function which returns a |
| pointer to the pixel data at the scanline with the given index, |
| and the bits() function which returns a pointer to the first pixel |
| data (this is equivalent to \c scanLine(0)). |
| |
| \section1 Image Formats |
| |
| Each pixel stored in a QImage is represented by an integer. The |
| size of the integer varies depending on the format. QImage |
| supports several image formats described by the \l Format |
| enum. |
| |
| Monochrome images are stored using 1-bit indexes into a color table |
| with at most two colors. There are two different types of |
| monochrome images: big endian (MSB first) or little endian (LSB |
| first) bit order. |
| |
| 8-bit images are stored using 8-bit indexes into a color table, |
| i.e. they have a single byte per pixel. The color table is a |
| QVector<QRgb>, and the QRgb typedef is equivalent to an unsigned |
| int containing an ARGB quadruplet on the format 0xAARRGGBB. |
| |
| 32-bit images have no color table; instead, each pixel contains an |
| QRgb value. There are three different types of 32-bit images |
| storing RGB (i.e. 0xffRRGGBB), ARGB and premultiplied ARGB |
| values respectively. In the premultiplied format the red, green, |
| and blue channels are multiplied by the alpha component divided by |
| 255. |
| |
| An image's format can be retrieved using the format() |
| function. Use the convertToFormat() functions to convert an image |
| into another format. The allGray() and isGrayscale() functions |
| tell whether a color image can safely be converted to a grayscale |
| image. |
| |
| \section1 Image Transformations |
| |
| QImage supports a number of functions for creating a new image |
| that is a transformed version of the original: The |
| createAlphaMask() function builds and returns a 1-bpp mask from |
| the alpha buffer in this image, and the createHeuristicMask() |
| function creates and returns a 1-bpp heuristic mask for this |
| image. The latter function works by selecting a color from one of |
| the corners, then chipping away pixels of that color starting at |
| all the edges. |
| |
| The mirrored() function returns a mirror of the image in the |
| desired direction, the scaled() returns a copy of the image scaled |
| to a rectangle of the desired measures, and the rgbSwapped() function |
| constructs a BGR image from a RGB image. |
| |
| The scaledToWidth() and scaledToHeight() functions return scaled |
| copies of the image. |
| |
| The transformed() function returns a copy of the image that is |
| transformed with the given transformation matrix and |
| transformation mode: Internally, the transformation matrix is |
| adjusted to compensate for unwanted translation, |
| i.e. transformed() returns the smallest image containing all |
| transformed points of the original image. The static trueMatrix() |
| function returns the actual matrix used for transforming the |
| image. |
| |
| There are also functions for changing attributes of an image |
| in-place: |
| |
| \table |
| \header \o Function \o Description |
| \row |
| \o setDotsPerMeterX() |
| \o Defines the aspect ratio by setting the number of pixels that fit |
| horizontally in a physical meter. |
| \row |
| \o setDotsPerMeterY() |
| \o Defines the aspect ratio by setting the number of pixels that fit |
| vertically in a physical meter. |
| \row |
| \o fill() |
| \o Fills the entire image with the given pixel value. |
| \row |
| \o invertPixels() |
| \o Inverts all pixel values in the image using the given InvertMode value. |
| \row |
| \o setColorTable() |
| \o Sets the color table used to translate color indexes. Only |
| monochrome and 8-bit formats. |
| \row |
| \o setColorCount() |
| \o Resizes the color table. Only monochrome and 8-bit formats. |
| |
| \endtable |
| |
| \section1 Legal Information |
| |
| For smooth scaling, the transformed() functions use code based on |
| smooth scaling algorithm by Daniel M. Duley. |
| |
| \legalese |
| Copyright (C) 2004, 2005 Daniel M. Duley |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions |
| are met: |
| |
| 1. Redistributions of source code must retain the above copyright |
| notice, this list of conditions and the following disclaimer. |
| 2. Redistributions in binary form must reproduce the above copyright |
| notice, this list of conditions and the following disclaimer in the |
| documentation and/or other materials provided with the distribution. |
| |
| THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| \endlegalese |
| |
| \sa QImageReader, QImageWriter, QPixmap, QSvgRenderer, {Image Composition Example}, |
| {Image Viewer Example}, {Scribble Example}, {Pixelator Example} |
| */ |
| |
| /*! |
| \enum QImage::Endian |
| \compat |
| |
| This enum type is used to describe the endianness of the CPU and |
| graphics hardware. It is provided here for compatibility with earlier versions of Qt. |
| |
| Use the \l Format enum instead. The \l Format enum specify the |
| endianess for monchrome formats, but for other formats the |
| endianess is not relevant. |
| |
| \value IgnoreEndian Endianness does not matter. Useful for some |
| operations that are independent of endianness. |
| \value BigEndian Most significant bit first or network byte order, as on SPARC, PowerPC, and Motorola CPUs. |
| \value LittleEndian Least significant bit first or little endian byte order, as on Intel x86. |
| */ |
| |
| /*! |
| \enum QImage::InvertMode |
| |
| This enum type is used to describe how pixel values should be |
| inverted in the invertPixels() function. |
| |
| \value InvertRgb Invert only the RGB values and leave the alpha |
| channel unchanged. |
| |
| \value InvertRgba Invert all channels, including the alpha channel. |
| |
| \sa invertPixels() |
| */ |
| |
| /*! |
| \enum QImage::Format |
| |
| The following image formats are available in Qt. Values greater |
| than QImage::Format_RGB16 were added in Qt 4.4. See the notes |
| after the table. |
| |
| \value Format_Invalid The image is invalid. |
| \value Format_Mono The image is stored using 1-bit per pixel. Bytes are |
| packed with the most significant bit (MSB) first. |
| \value Format_MonoLSB The image is stored using 1-bit per pixel. Bytes are |
| packed with the less significant bit (LSB) first. |
| |
| \value Format_Indexed8 The image is stored using 8-bit indexes |
| into a colormap. |
| |
| \value Format_RGB32 The image is stored using a 32-bit RGB format (0xffRRGGBB). |
| |
| \value Format_ARGB32 The image is stored using a 32-bit ARGB |
| format (0xAARRGGBB). |
| |
| \value Format_ARGB32_Premultiplied The image is stored using a premultiplied 32-bit |
| ARGB format (0xAARRGGBB), i.e. the red, |
| green, and blue channels are multiplied |
| by the alpha component divided by 255. (If RR, GG, or BB |
| has a higher value than the alpha channel, the results are |
| undefined.) Certain operations (such as image composition |
| using alpha blending) are faster using premultiplied ARGB32 |
| than with plain ARGB32. |
| |
| \value Format_RGB16 The image is stored using a 16-bit RGB format (5-6-5). |
| |
| \value Format_ARGB8565_Premultiplied The image is stored using a |
| premultiplied 24-bit ARGB format (8-5-6-5). |
| \value Format_RGB666 The image is stored using a 24-bit RGB format (6-6-6). |
| The unused most significant bits is always zero. |
| \value Format_ARGB6666_Premultiplied The image is stored using a |
| premultiplied 24-bit ARGB format (6-6-6-6). |
| \value Format_RGB555 The image is stored using a 16-bit RGB format (5-5-5). |
| The unused most significant bit is always zero. |
| \value Format_ARGB8555_Premultiplied The image is stored using a |
| premultiplied 24-bit ARGB format (8-5-5-5). |
| \value Format_RGB888 The image is stored using a 24-bit RGB format (8-8-8). |
| \value Format_RGB444 The image is stored using a 16-bit RGB format (4-4-4). |
| The unused bits are always zero. |
| \value Format_ARGB4444_Premultiplied The image is stored using a |
| premultiplied 16-bit ARGB format (4-4-4-4). |
| |
| \note Drawing into a QImage with QImage::Format_Indexed8 is not |
| supported. |
| |
| \note Do not render into ARGB32 images using QPainter. Using |
| QImage::Format_ARGB32_Premultiplied is significantly faster. |
| |
| \sa format(), convertToFormat() |
| */ |
| |
| /***************************************************************************** |
| QImage member functions |
| *****************************************************************************/ |
| |
| // table to flip bits |
| static const uchar bitflip[256] = { |
| /* |
| open OUT, "| fmt"; |
| for $i (0..255) { |
| print OUT (($i >> 7) & 0x01) | (($i >> 5) & 0x02) | |
| (($i >> 3) & 0x04) | (($i >> 1) & 0x08) | |
| (($i << 7) & 0x80) | (($i << 5) & 0x40) | |
| (($i << 3) & 0x20) | (($i << 1) & 0x10), ", "; |
| } |
| close OUT; |
| */ |
| 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 |
| }; |
| |
| const uchar *qt_get_bitflip_array() // called from QPixmap code |
| { |
| return bitflip; |
| } |
| |
| #if defined(QT3_SUPPORT) |
| static QImage::Format formatFor(int depth, QImage::Endian bitOrder) |
| { |
| QImage::Format format; |
| if (depth == 1) { |
| format = bitOrder == QImage::BigEndian ? QImage::Format_Mono : QImage::Format_MonoLSB; |
| } else if (depth == 8) { |
| format = QImage::Format_Indexed8; |
| } else if (depth == 32) { |
| format = QImage::Format_RGB32; |
| } else if (depth == 24) { |
| format = QImage::Format_RGB888; |
| } else if (depth == 16) { |
| format = QImage::Format_RGB16; |
| } else { |
| qWarning("QImage: Depth %d not supported", depth); |
| format = QImage::Format_Invalid; |
| } |
| return format; |
| } |
| #endif |
| |
| /*! |
| Constructs a null image. |
| |
| \sa isNull() |
| */ |
| |
| QImage::QImage() |
| : QPaintDevice() |
| { |
| d = 0; |
| } |
| |
| /*! |
| Constructs an image with the given \a width, \a height and \a |
| format. |
| |
| A \l{isNull()}{null} image will be returned if memory cannot be allocated. |
| |
| \warning This will create a QImage with uninitialized data. Call |
| fill() to fill the image with an appropriate pixel value before |
| drawing onto it with QPainter. |
| */ |
| QImage::QImage(int width, int height, Format format) |
| : QPaintDevice() |
| { |
| d = QImageData::create(QSize(width, height), format, 0); |
| } |
| |
| /*! |
| Constructs an image with the given \a size and \a format. |
| |
| A \l{isNull()}{null} image is returned if memory cannot be allocated. |
| |
| \warning This will create a QImage with uninitialized data. Call |
| fill() to fill the image with an appropriate pixel value before |
| drawing onto it with QPainter. |
| */ |
| QImage::QImage(const QSize &size, Format format) |
| : QPaintDevice() |
| { |
| d = QImageData::create(size, format, 0); |
| } |
| |
| |
| |
| QImageData *QImageData::create(uchar *data, int width, int height, int bpl, QImage::Format format, bool readOnly) |
| { |
| QImageData *d = 0; |
| |
| if (format == QImage::Format_Invalid) |
| return d; |
| |
| if (!checkPixelSize(format)) { |
| qWarning("QImageData::create(): Invalid pixel size for format %i", |
| format); |
| return 0; |
| } |
| |
| const int depth = depthForFormat(format); |
| const int calc_bytes_per_line = ((width * depth + 31)/32) * 4; |
| const int min_bytes_per_line = (width * depth + 7)/8; |
| |
| if (bpl <= 0) |
| bpl = calc_bytes_per_line; |
| |
| if (width <= 0 || height <= 0 || !data |
| || INT_MAX/sizeof(uchar *) < uint(height) |
| || INT_MAX/uint(depth) < uint(width) |
| || bpl <= 0 |
| || height <= 0 |
| || bpl < min_bytes_per_line |
| || INT_MAX/uint(bpl) < uint(height)) |
| return d; // invalid parameter(s) |
| |
| d = new QImageData; |
| d->ref.ref(); |
| |
| d->own_data = false; |
| d->ro_data = readOnly; |
| d->data = data; |
| d->width = width; |
| d->height = height; |
| d->depth = depth; |
| d->format = format; |
| |
| d->bytes_per_line = bpl; |
| d->nbytes = d->bytes_per_line * height; |
| |
| return d; |
| } |
| |
| /*! |
| Constructs an image with the given \a width, \a height and \a |
| format, that uses an existing memory buffer, \a data. The \a width |
| and \a height must be specified in pixels, \a data must be 32-bit aligned, |
| and each scanline of data in the image must also be 32-bit aligned. |
| |
| The buffer must remain valid throughout the life of the |
| QImage. The image does not delete the buffer at destruction. |
| |
| If \a format is an indexed color format, the image color table is |
| initially empty and must be sufficiently expanded with |
| setColorCount() or setColorTable() before the image is used. |
| */ |
| QImage::QImage(uchar* data, int width, int height, Format format) |
| : QPaintDevice() |
| { |
| d = QImageData::create(data, width, height, 0, format, false); |
| } |
| |
| /*! |
| Constructs an image with the given \a width, \a height and \a |
| format, that uses an existing read-only memory buffer, \a |
| data. The \a width and \a height must be specified in pixels, \a |
| data must be 32-bit aligned, and each scanline of data in the |
| image must also be 32-bit aligned. |
| |
| The buffer must remain valid throughout the life of the QImage and |
| all copies that have not been modified or otherwise detached from |
| the original buffer. The image does not delete the buffer at |
| destruction. |
| |
| If \a format is an indexed color format, the image color table is |
| initially empty and must be sufficiently expanded with |
| setColorCount() or setColorTable() before the image is used. |
| |
| Unlike the similar QImage constructor that takes a non-const data buffer, |
| this version will never alter the contents of the buffer. For example, |
| calling QImage::bits() will return a deep copy of the image, rather than |
| the buffer passed to the constructor. This allows for the efficiency of |
| constructing a QImage from raw data, without the possibility of the raw |
| data being changed. |
| */ |
| QImage::QImage(const uchar* data, int width, int height, Format format) |
| : QPaintDevice() |
| { |
| d = QImageData::create(const_cast<uchar*>(data), width, height, 0, format, true); |
| } |
| |
| /*! |
| Constructs an image with the given \a width, \a height and \a |
| format, that uses an existing memory buffer, \a data. The \a width |
| and \a height must be specified in pixels. \a bytesPerLine |
| specifies the number of bytes per line (stride). |
| |
| The buffer must remain valid throughout the life of the |
| QImage. The image does not delete the buffer at destruction. |
| |
| If \a format is an indexed color format, the image color table is |
| initially empty and must be sufficiently expanded with |
| setColorCount() or setColorTable() before the image is used. |
| */ |
| QImage::QImage(uchar *data, int width, int height, int bytesPerLine, Format format) |
| :QPaintDevice() |
| { |
| d = QImageData::create(data, width, height, bytesPerLine, format, false); |
| } |
| |
| |
| /*! |
| Constructs an image with the given \a width, \a height and \a |
| format, that uses an existing memory buffer, \a data. The \a width |
| and \a height must be specified in pixels. \a bytesPerLine |
| specifies the number of bytes per line (stride). |
| |
| The buffer must remain valid throughout the life of the |
| QImage. The image does not delete the buffer at destruction. |
| |
| If \a format is an indexed color format, the image color table is |
| initially empty and must be sufficiently expanded with |
| setColorCount() or setColorTable() before the image is used. |
| |
| Unlike the similar QImage constructor that takes a non-const data buffer, |
| this version will never alter the contents of the buffer. For example, |
| calling QImage::bits() will return a deep copy of the image, rather than |
| the buffer passed to the constructor. This allows for the efficiency of |
| constructing a QImage from raw data, without the possibility of the raw |
| data being changed. |
| */ |
| |
| QImage::QImage(const uchar *data, int width, int height, int bytesPerLine, Format format) |
| :QPaintDevice() |
| { |
| d = QImageData::create(const_cast<uchar*>(data), width, height, bytesPerLine, format, true); |
| } |
| |
| /*! |
| Constructs an image and tries to load the image from the file with |
| the given \a fileName. |
| |
| The loader attempts to read the image using the specified \a |
| format. If the \a format is not specified (which is the default), |
| the loader probes the file for a header to guess the file format. |
| |
| If the loading of the image failed, this object is a null image. |
| |
| The file name can either refer to an actual file on disk or to one |
| of the application's embedded resources. See the |
| \l{resources.html}{Resource System} overview for details on how to |
| embed images and other resource files in the application's |
| executable. |
| |
| \sa isNull(), {QImage#Reading and Writing Image Files}{Reading and Writing Image Files} |
| */ |
| |
| QImage::QImage(const QString &fileName, const char *format) |
| : QPaintDevice() |
| { |
| d = 0; |
| load(fileName, format); |
| } |
| |
| /*! |
| Constructs an image and tries to load the image from the file with |
| the given \a fileName. |
| |
| The loader attempts to read the image using the specified \a |
| format. If the \a format is not specified (which is the default), |
| the loader probes the file for a header to guess the file format. |
| |
| If the loading of the image failed, this object is a null image. |
| |
| The file name can either refer to an actual file on disk or to one |
| of the application's embedded resources. See the |
| \l{resources.html}{Resource System} overview for details on how to |
| embed images and other resource files in the application's |
| executable. |
| |
| You can disable this constructor by defining \c |
| QT_NO_CAST_FROM_ASCII when you compile your applications. This can |
| be useful, for example, if you want to ensure that all |
| user-visible strings go through QObject::tr(). |
| |
| \sa QString::fromAscii(), isNull(), {QImage#Reading and Writing |
| Image Files}{Reading and Writing Image Files} |
| */ |
| #ifndef QT_NO_CAST_FROM_ASCII |
| QImage::QImage(const char *fileName, const char *format) |
| : QPaintDevice() |
| { |
| // ### Qt 5: if you remove the QImage(const QByteArray &) QT3_SUPPORT |
| // constructor, remove this constructor as well. The constructor here |
| // exists so that QImage("foo.png") compiles without ambiguity. |
| d = 0; |
| load(QString::fromAscii(fileName), format); |
| } |
| #endif |
| |
| #ifndef QT_NO_IMAGEFORMAT_XPM |
| extern bool qt_read_xpm_image_or_array(QIODevice *device, const char * const *source, QImage &image); |
| |
| /*! |
| Constructs an image from the given \a xpm image. |
| |
| Make sure that the image is a valid XPM image. Errors are silently |
| ignored. |
| |
| Note that it's possible to squeeze the XPM variable a little bit |
| by using an unusual declaration: |
| |
| \snippet doc/src/snippets/code/src_gui_image_qimage.cpp 2 |
| |
| The extra \c const makes the entire definition read-only, which is |
| slightly more efficient (e.g., when the code is in a shared |
| library) and able to be stored in ROM with the application. |
| */ |
| |
| QImage::QImage(const char * const xpm[]) |
| : QPaintDevice() |
| { |
| d = 0; |
| if (!xpm) |
| return; |
| if (!qt_read_xpm_image_or_array(0, xpm, *this)) |
| // Issue: Warning because the constructor may be ambigious |
| qWarning("QImage::QImage(), XPM is not supported"); |
| } |
| #endif // QT_NO_IMAGEFORMAT_XPM |
| |
| /*! |
| \fn QImage::QImage(const QByteArray &data) |
| |
| Use the static fromData() function instead. |
| |
| \oldcode |
| QByteArray data; |
| ... |
| QImage image(data); |
| \newcode |
| QByteArray data; |
| ... |
| QImage image = QImage::fromData(data); |
| \endcode |
| */ |
| |
| |
| /*! |
| Constructs a shallow copy of the given \a image. |
| |
| For more information about shallow copies, see the \l {Implicit |
| Data Sharing} documentation. |
| |
| \sa copy() |
| */ |
| |
| QImage::QImage(const QImage &image) |
| : QPaintDevice() |
| { |
| if (image.paintingActive()) { |
| d = 0; |
| operator=(image.copy()); |
| } else { |
| d = image.d; |
| if (d) |
| d->ref.ref(); |
| } |
| } |
| |
| #ifdef QT3_SUPPORT |
| /*! |
| \fn QImage::QImage(int width, int height, int depth, int numColors, Endian bitOrder) |
| |
| Constructs an image with the given \a width, \a height, \a depth, |
| \a numColors colors and \a bitOrder. |
| |
| Use the constructor that accepts a width, a height and a format |
| (i.e. specifying the depth and bit order), in combination with the |
| setColorCount() function, instead. |
| |
| \oldcode |
| QImage image(width, height, depth, numColors); |
| \newcode |
| QImage image(width, height, format); |
| |
| // For 8 bit images the default number of colors is 256. If |
| // another number of colors is required it can be specified |
| // using the setColorCount() function. |
| image.setColorCount(numColors); |
| \endcode |
| */ |
| |
| QImage::QImage(int w, int h, int depth, int colorCount, Endian bitOrder) |
| : QPaintDevice() |
| { |
| d = QImageData::create(QSize(w, h), formatFor(depth, bitOrder), colorCount); |
| } |
| |
| /*! |
| Constructs an image with the given \a size, \a depth, \a numColors |
| and \a bitOrder. |
| |
| Use the constructor that accepts a size and a format |
| (i.e. specifying the depth and bit order), in combination with the |
| setColorCount() function, instead. |
| |
| \oldcode |
| QSize mySize(width, height); |
| QImage image(mySize, depth, numColors); |
| \newcode |
| QSize mySize(width, height); |
| QImage image(mySize, format); |
| |
| // For 8 bit images the default number of colors is 256. If |
| // another number of colors is required it can be specified |
| // using the setColorCount() function. |
| image.setColorCount(numColors); |
| \endcode |
| */ |
| QImage::QImage(const QSize& size, int depth, int numColors, Endian bitOrder) |
| : QPaintDevice() |
| { |
| d = QImageData::create(size, formatFor(depth, bitOrder), numColors); |
| } |
| |
| /*! |
| \fn QImage::QImage(uchar* data, int width, int height, int depth, const QRgb* colortable, int numColors, Endian bitOrder) |
| |
| Constructs an image with the given \a width, \a height, depth, \a |
| colortable, \a numColors and \a bitOrder, that uses an existing |
| memory buffer, \a data. |
| |
| Use the constructor that accepts a uchar pointer, a width, a |
| height and a format (i.e. specifying the depth and bit order), in |
| combination with the setColorTable() function, instead. |
| |
| \oldcode |
| uchar *myData; |
| QRgb *myColorTable; |
| |
| QImage image(myData, width, height, depth, |
| myColorTable, numColors, IgnoreEndian); |
| \newcode |
| uchar *myData; |
| QVector<QRgb> myColorTable; |
| |
| QImage image(myData, width, height, format); |
| image.setColorTable(myColorTable); |
| \endcode |
| */ |
| QImage::QImage(uchar* data, int w, int h, int depth, const QRgb* colortable, int numColors, Endian bitOrder) |
| : QPaintDevice() |
| { |
| d = 0; |
| Format f = formatFor(depth, bitOrder); |
| if (f == Format_Invalid) |
| return; |
| |
| const int bytes_per_line = ((w*depth+31)/32)*4; // bytes per scanline |
| if (w <= 0 || h <= 0 || numColors < 0 || !data |
| || INT_MAX/sizeof(uchar *) < uint(h) |
| || INT_MAX/uint(depth) < uint(w) |
| || bytes_per_line <= 0 |
| || INT_MAX/uint(bytes_per_line) < uint(h)) |
| return; // invalid parameter(s) |
| d = new QImageData; |
| d->ref.ref(); |
| |
| d->own_data = false; |
| d->data = data; |
| d->width = w; |
| d->height = h; |
| d->depth = depth; |
| d->format = f; |
| if (depth == 32) |
| numColors = 0; |
| |
| d->bytes_per_line = bytes_per_line; |
| d->nbytes = d->bytes_per_line * h; |
| if (colortable) { |
| d->colortable.resize(numColors); |
| for (int i = 0; i < numColors; ++i) |
| d->colortable[i] = colortable[i]; |
| } else if (numColors) { |
| setColorCount(numColors); |
| } |
| } |
| |
| #ifdef Q_WS_QWS |
| |
| /*! |
| \fn QImage::QImage(uchar* data, int width, int height, int depth, int bytesPerLine, const QRgb* colortable, int numColors, Endian bitOrder) |
| |
| Constructs an image with the given \a width, \a height, \a depth, |
| \a bytesPerLine, \a colortable, \a numColors and \a bitOrder, that |
| uses an existing memory buffer, \a data. The image does not delete |
| the buffer at destruction. |
| |
| \warning This constructor is only available in Qt for Embedded Linux. |
| |
| The data has to be 32-bit aligned, and each scanline of data in the image |
| must also be 32-bit aligned, so it's no longer possible to specify a custom |
| \a bytesPerLine value. |
| */ |
| QImage::QImage(uchar* data, int w, int h, int depth, int bpl, const QRgb* colortable, int numColors, Endian bitOrder) |
| : QPaintDevice() |
| { |
| d = 0; |
| Format f = formatFor(depth, bitOrder); |
| if (f == Format_Invalid) |
| return; |
| if (!data || w <= 0 || h <= 0 || depth <= 0 || numColors < 0 |
| || INT_MAX/sizeof(uchar *) < uint(h) |
| || INT_MAX/uint(depth) < uint(w) |
| || bpl <= 0 |
| || INT_MAX/uint(bpl) < uint(h)) |
| return; // invalid parameter(s) |
| |
| d = new QImageData; |
| d->ref.ref(); |
| d->own_data = false; |
| d->data = data; |
| d->width = w; |
| d->height = h; |
| d->depth = depth; |
| d->format = f; |
| if (depth == 32) |
| numColors = 0; |
| d->bytes_per_line = bpl; |
| d->nbytes = d->bytes_per_line * h; |
| if (colortable) { |
| d->colortable.resize(numColors); |
| for (int i = 0; i < numColors; ++i) |
| d->colortable[i] = colortable[i]; |
| } else if (numColors) { |
| setColorCount(numColors); |
| } |
| } |
| #endif // Q_WS_QWS |
| #endif // QT3_SUPPORT |
| |
| /*! |
| Destroys the image and cleans up. |
| */ |
| |
| QImage::~QImage() |
| { |
| if (d && !d->ref.deref()) |
| delete d; |
| } |
| |
| /*! |
| Assigns a shallow copy of the given \a image to this image and |
| returns a reference to this image. |
| |
| For more information about shallow copies, see the \l {Implicit |
| Data Sharing} documentation. |
| |
| \sa copy(), QImage() |
| */ |
| |
| QImage &QImage::operator=(const QImage &image) |
| { |
| if (image.paintingActive()) { |
| operator=(image.copy()); |
| } else { |
| if (image.d) |
| image.d->ref.ref(); |
| if (d && !d->ref.deref()) |
| delete d; |
| d = image.d; |
| } |
| return *this; |
| } |
| |
| /*! |
| \internal |
| */ |
| int QImage::devType() const |
| { |
| return QInternal::Image; |
| } |
| |
| /*! |
| Returns the image as a QVariant. |
| */ |
| QImage::operator QVariant() const |
| { |
| return QVariant(QVariant::Image, this); |
| } |
| |
| /*! |
| \internal |
| |
| If multiple images share common data, this image makes a copy of |
| the data and detaches itself from the sharing mechanism, making |
| sure that this image is the only one referring to the data. |
| |
| Nothing is done if there is just a single reference. |
| |
| \sa copy(), isDetached(), {Implicit Data Sharing} |
| */ |
| void QImage::detach() |
| { |
| if (d) { |
| if (d->is_cached && d->ref == 1) |
| QImagePixmapCleanupHooks::executeImageHooks(cacheKey()); |
| |
| if (d->ref != 1 || d->ro_data) |
| *this = copy(); |
| |
| if (d) |
| ++d->detach_no; |
| } |
| } |
| |
| |
| /*! |
| \fn QImage QImage::copy(int x, int y, int width, int height) const |
| \overload |
| |
| The returned image is copied from the position (\a x, \a y) in |
| this image, and will always have the given \a width and \a height. |
| In areas beyond this image, pixels are set to 0. |
| |
| */ |
| |
| /*! |
| \fn QImage QImage::copy(const QRect& rectangle) const |
| |
| Returns a sub-area of the image as a new image. |
| |
| The returned image is copied from the position (\a |
| {rectangle}.x(), \a{rectangle}.y()) in this image, and will always |
| have the size of the given \a rectangle. |
| |
| In areas beyond this image, pixels are set to 0. For 32-bit RGB |
| images, this means black; for 32-bit ARGB images, this means |
| transparent black; for 8-bit images, this means the color with |
| index 0 in the color table which can be anything; for 1-bit |
| images, this means Qt::color0. |
| |
| If the given \a rectangle is a null rectangle the entire image is |
| copied. |
| |
| \sa QImage() |
| */ |
| QImage QImage::copy(const QRect& r) const |
| { |
| if (!d) |
| return QImage(); |
| |
| if (r.isNull()) { |
| QImage image(d->width, d->height, d->format); |
| if (image.isNull()) |
| return image; |
| |
| // Qt for Embedded Linux can create images with non-default bpl |
| // make sure we don't crash. |
| if (image.d->nbytes != d->nbytes) { |
| int bpl = image.bytesPerLine(); |
| for (int i = 0; i < height(); i++) |
| memcpy(image.scanLine(i), scanLine(i), bpl); |
| } else |
| memcpy(image.bits(), bits(), d->nbytes); |
| image.d->colortable = d->colortable; |
| image.d->dpmx = d->dpmx; |
| image.d->dpmy = d->dpmy; |
| image.d->offset = d->offset; |
| image.d->has_alpha_clut = d->has_alpha_clut; |
| #ifndef QT_NO_IMAGE_TEXT |
| image.d->text = d->text; |
| #endif |
| return image; |
| } |
| |
| int x = r.x(); |
| int y = r.y(); |
| int w = r.width(); |
| int h = r.height(); |
| |
| int dx = 0; |
| int dy = 0; |
| if (w <= 0 || h <= 0) |
| return QImage(); |
| |
| QImage image(w, h, d->format); |
| if (image.isNull()) |
| return image; |
| |
| if (x < 0 || y < 0 || x + w > d->width || y + h > d->height) { |
| // bitBlt will not cover entire image - clear it. |
| image.fill(0); |
| if (x < 0) { |
| dx = -x; |
| x = 0; |
| } |
| if (y < 0) { |
| dy = -y; |
| y = 0; |
| } |
| } |
| |
| image.d->colortable = d->colortable; |
| |
| int pixels_to_copy = qMax(w - dx, 0); |
| if (x > d->width) |
| pixels_to_copy = 0; |
| else if (pixels_to_copy > d->width - x) |
| pixels_to_copy = d->width - x; |
| int lines_to_copy = qMax(h - dy, 0); |
| if (y > d->height) |
| lines_to_copy = 0; |
| else if (lines_to_copy > d->height - y) |
| lines_to_copy = d->height - y; |
| |
| bool byteAligned = true; |
| if (d->format == Format_Mono || d->format == Format_MonoLSB) |
| byteAligned = !(dx & 7) && !(x & 7) && !(pixels_to_copy & 7); |
| |
| if (byteAligned) { |
| const uchar *src = d->data + ((x * d->depth) >> 3) + y * d->bytes_per_line; |
| uchar *dest = image.d->data + ((dx * d->depth) >> 3) + dy * image.d->bytes_per_line; |
| const int bytes_to_copy = (pixels_to_copy * d->depth) >> 3; |
| for (int i = 0; i < lines_to_copy; ++i) { |
| memcpy(dest, src, bytes_to_copy); |
| src += d->bytes_per_line; |
| dest += image.d->bytes_per_line; |
| } |
| } else if (d->format == Format_Mono) { |
| const uchar *src = d->data + y * d->bytes_per_line; |
| uchar *dest = image.d->data + dy * image.d->bytes_per_line; |
| for (int i = 0; i < lines_to_copy; ++i) { |
| for (int j = 0; j < pixels_to_copy; ++j) { |
| if (src[(x + j) >> 3] & (0x80 >> ((x + j) & 7))) |
| dest[(dx + j) >> 3] |= (0x80 >> ((dx + j) & 7)); |
| else |
| dest[(dx + j) >> 3] &= ~(0x80 >> ((dx + j) & 7)); |
| } |
| src += d->bytes_per_line; |
| dest += image.d->bytes_per_line; |
| } |
| } else { // Format_MonoLSB |
| Q_ASSERT(d->format == Format_MonoLSB); |
| const uchar *src = d->data + y * d->bytes_per_line; |
| uchar *dest = image.d->data + dy * image.d->bytes_per_line; |
| for (int i = 0; i < lines_to_copy; ++i) { |
| for (int j = 0; j < pixels_to_copy; ++j) { |
| if (src[(x + j) >> 3] & (0x1 << ((x + j) & 7))) |
| dest[(dx + j) >> 3] |= (0x1 << ((dx + j) & 7)); |
| else |
| dest[(dx + j) >> 3] &= ~(0x1 << ((dx + j) & 7)); |
| } |
| src += d->bytes_per_line; |
| dest += image.d->bytes_per_line; |
| } |
| } |
| |
| image.d->dpmx = dotsPerMeterX(); |
| image.d->dpmy = dotsPerMeterY(); |
| image.d->offset = offset(); |
| image.d->has_alpha_clut = d->has_alpha_clut; |
| #ifndef QT_NO_IMAGE_TEXT |
| image.d->text = d->text; |
| #endif |
| return image; |
| } |
| |
| |
| /*! |
| \fn bool QImage::isNull() const |
| |
| Returns true if it is a null image, otherwise returns false. |
| |
| A null image has all parameters set to zero and no allocated data. |
| */ |
| bool QImage::isNull() const |
| { |
| return !d; |
| } |
| |
| /*! |
| \fn int QImage::width() const |
| |
| Returns the width of the image. |
| |
| \sa {QImage#Image Information}{Image Information} |
| */ |
| int QImage::width() const |
| { |
| return d ? d->width : 0; |
| } |
| |
| /*! |
| \fn int QImage::height() const |
| |
| Returns the height of the image. |
| |
| \sa {QImage#Image Information}{Image Information} |
| */ |
| int QImage::height() const |
| { |
| return d ? d->height : 0; |
| } |
| |
| /*! |
| \fn QSize QImage::size() const |
| |
| Returns the size of the image, i.e. its width() and height(). |
| |
| \sa {QImage#Image Information}{Image Information} |
| */ |
| QSize QImage::size() const |
| { |
| return d ? QSize(d->width, d->height) : QSize(0, 0); |
| } |
| |
| /*! |
| \fn QRect QImage::rect() const |
| |
| Returns the enclosing rectangle (0, 0, width(), height()) of the |
| image. |
| |
| \sa {QImage#Image Information}{Image Information} |
| */ |
| QRect QImage::rect() const |
| { |
| return d ? QRect(0, 0, d->width, d->height) : QRect(); |
| } |
| |
| /*! |
| Returns the depth of the image. |
| |
| The image depth is the number of bits used to store a single |
| pixel, also called bits per pixel (bpp). |
| |
| The supported depths are 1, 8, 16, 24 and 32. |
| |
| \sa bitPlaneCount(), convertToFormat(), {QImage#Image Formats}{Image Formats}, |
| {QImage#Image Information}{Image Information} |
| |
| */ |
| int QImage::depth() const |
| { |
| return d ? d->depth : 0; |
| } |
| |
| /*! |
| \obsolete |
| \fn int QImage::numColors() const |
| |
| Returns the size of the color table for the image. |
| |
| \sa setColorCount() |
| */ |
| int QImage::numColors() const |
| { |
| return d ? d->colortable.size() : 0; |
| } |
| |
| /*! |
| \since 4.6 |
| \fn int QImage::colorCount() const |
| |
| Returns the size of the color table for the image. |
| |
| Notice that colorCount() returns 0 for 32-bpp images because these |
| images do not use color tables, but instead encode pixel values as |
| ARGB quadruplets. |
| |
| \sa setColorCount(), {QImage#Image Information}{Image Information} |
| */ |
| int QImage::colorCount() const |
| { |
| return d ? d->colortable.size() : 0; |
| } |
| |
| |
| #ifdef QT3_SUPPORT |
| /*! |
| \fn QImage::Endian QImage::bitOrder() const |
| |
| Returns the bit order for the image. If it is a 1-bpp image, this |
| function returns either QImage::BigEndian or |
| QImage::LittleEndian. Otherwise, this function returns |
| QImage::IgnoreEndian. |
| |
| Use the format() function instead for the monochrome formats. For |
| non-monochrome formats the bit order is irrelevant. |
| */ |
| |
| /*! |
| Returns a pointer to the scanline pointer table. This is the |
| beginning of the data block for the image. |
| Returns 0 in case of an error. |
| |
| Use the bits() or scanLine() function instead. |
| */ |
| uchar **QImage::jumpTable() |
| { |
| if (!d) |
| return 0; |
| detach(); |
| |
| // in case detach() ran out of memory.. |
| if (!d) |
| return 0; |
| |
| if (!d->jumptable) { |
| d->jumptable = (uchar **)malloc(d->height*sizeof(uchar *)); |
| if (!d->jumptable) |
| return 0; |
| uchar *data = d->data; |
| int height = d->height; |
| uchar **p = d->jumptable; |
| while (height--) { |
| *p++ = data; |
| data += d->bytes_per_line; |
| } |
| } |
| return d->jumptable; |
| } |
| |
| /*! |
| \overload |
| */ |
| const uchar * const *QImage::jumpTable() const |
| { |
| if (!d) |
| return 0; |
| if (!d->jumptable) { |
| d->jumptable = (uchar **)malloc(d->height*sizeof(uchar *)); |
| if (!d->jumptable) |
| return 0; |
| uchar *data = d->data; |
| int height = d->height; |
| uchar **p = d->jumptable; |
| while (height--) { |
| *p++ = data; |
| data += d->bytes_per_line; |
| } |
| } |
| return d->jumptable; |
| } |
| #endif |
| |
| /*! |
| Sets the color table used to translate color indexes to QRgb |
| values, to the specified \a colors. |
| |
| When the image is used, the color table must be large enough to |
| have entries for all the pixel/index values present in the image, |
| otherwise the results are undefined. |
| |
| \sa colorTable(), setColor(), {QImage#Image Transformations}{Image |
| Transformations} |
| */ |
| void QImage::setColorTable(const QVector<QRgb> colors) |
| { |
| if (!d) |
| return; |
| detach(); |
| |
| // In case detach() ran out of memory |
| if (!d) |
| return; |
| |
| d->colortable = colors; |
| d->has_alpha_clut = false; |
| for (int i = 0; i < d->colortable.size(); ++i) { |
| if (qAlpha(d->colortable.at(i)) != 255) { |
| d->has_alpha_clut = true; |
| break; |
| } |
| } |
| } |
| |
| /*! |
| Returns a list of the colors contained in the image's color table, |
| or an empty list if the image does not have a color table |
| |
| \sa setColorTable(), colorCount(), color() |
| */ |
| QVector<QRgb> QImage::colorTable() const |
| { |
| return d ? d->colortable : QVector<QRgb>(); |
| } |
| |
| |
| /*! |
| \obsolete |
| Returns the number of bytes occupied by the image data. |
| |
| \sa byteCount() |
| */ |
| int QImage::numBytes() const |
| { |
| return d ? d->nbytes : 0; |
| } |
| |
| /*! |
| \since 4.6 |
| Returns the number of bytes occupied by the image data. |
| |
| \sa bytesPerLine(), bits(), {QImage#Image Information}{Image |
| Information} |
| */ |
| int QImage::byteCount() const |
| { |
| return d ? d->nbytes : 0; |
| } |
| |
| /*! |
| Returns the number of bytes per image scanline. |
| |
| This is equivalent to byteCount() / height(). |
| |
| \sa scanLine() |
| */ |
| int QImage::bytesPerLine() const |
| { |
| return (d && d->height) ? d->nbytes / d->height : 0; |
| } |
| |
| |
| /*! |
| Returns the color in the color table at index \a i. The first |
| color is at index 0. |
| |
| The colors in an image's color table are specified as ARGB |
| quadruplets (QRgb). Use the qAlpha(), qRed(), qGreen(), and |
| qBlue() functions to get the color value components. |
| |
| \sa setColor(), pixelIndex(), {QImage#Pixel Manipulation}{Pixel |
| Manipulation} |
| */ |
| QRgb QImage::color(int i) const |
| { |
| Q_ASSERT(i < colorCount()); |
| return d ? d->colortable.at(i) : QRgb(uint(-1)); |
| } |
| |
| /*! |
| \fn void QImage::setColor(int index, QRgb colorValue) |
| |
| Sets the color at the given \a index in the color table, to the |
| given to \a colorValue. The color value is an ARGB quadruplet. |
| |
| If \a index is outside the current size of the color table, it is |
| expanded with setColorCount(). |
| |
| \sa color(), colorCount(), setColorTable(), {QImage#Pixel Manipulation}{Pixel |
| Manipulation} |
| */ |
| void QImage::setColor(int i, QRgb c) |
| { |
| if (!d) |
| return; |
| if (i < 0 || d->depth > 8 || i >= 1<<d->depth) { |
| qWarning("QImage::setColor: Index out of bound %d", i); |
| return; |
| } |
| detach(); |
| |
| // In case detach() run out of memory |
| if (!d) |
| return; |
| |
| if (i >= d->colortable.size()) |
| setColorCount(i+1); |
| d->colortable[i] = c; |
| d->has_alpha_clut |= (qAlpha(c) != 255); |
| } |
| |
| /*! |
| Returns a pointer to the pixel data at the scanline with index \a |
| i. The first scanline is at index 0. |
| |
| The scanline data is aligned on a 32-bit boundary. |
| |
| \warning If you are accessing 32-bpp image data, cast the returned |
| pointer to \c{QRgb*} (QRgb has a 32-bit size) and use it to |
| read/write the pixel value. You cannot use the \c{uchar*} pointer |
| directly, because the pixel format depends on the byte order on |
| the underlying platform. Use qRed(), qGreen(), qBlue(), and |
| qAlpha() to access the pixels. |
| |
| \sa bytesPerLine(), bits(), {QImage#Pixel Manipulation}{Pixel |
| Manipulation}, constScanLine() |
| */ |
| uchar *QImage::scanLine(int i) |
| { |
| if (!d) |
| return 0; |
| |
| detach(); |
| |
| // In case detach() ran out of memory |
| if (!d) |
| return 0; |
| |
| return d->data + i * d->bytes_per_line; |
| } |
| |
| /*! |
| \overload |
| */ |
| const uchar *QImage::scanLine(int i) const |
| { |
| if (!d) |
| return 0; |
| |
| Q_ASSERT(i >= 0 && i < height()); |
| return d->data + i * d->bytes_per_line; |
| } |
| |
| |
| /*! |
| Returns a pointer to the pixel data at the scanline with index \a |
| i. The first scanline is at index 0. |
| |
| The scanline data is aligned on a 32-bit boundary. |
| |
| Note that QImage uses \l{Implicit Data Sharing} {implicit data |
| sharing}, but this function does \e not perform a deep copy of the |
| shared pixel data, because the returned data is const. |
| |
| \sa scanLine(), constBits() |
| \since 4.7 |
| */ |
| const uchar *QImage::constScanLine(int i) const |
| { |
| if (!d) |
| return 0; |
| |
| Q_ASSERT(i >= 0 && i < height()); |
| return d->data + i * d->bytes_per_line; |
| } |
| |
| /*! |
| Returns a pointer to the first pixel data. This is equivalent to |
| scanLine(0). |
| |
| Note that QImage uses \l{Implicit Data Sharing} {implicit data |
| sharing}. This function performs a deep copy of the shared pixel |
| data, thus ensuring that this QImage is the only one using the |
| current return value. |
| |
| \sa scanLine(), byteCount(), constBits() |
| */ |
| uchar *QImage::bits() |
| { |
| if (!d) |
| return 0; |
| detach(); |
| |
| // In case detach ran out of memory... |
| if (!d) |
| return 0; |
| |
| return d->data; |
| } |
| |
| /*! |
| \overload |
| |
| Note that QImage uses \l{Implicit Data Sharing} {implicit data |
| sharing}, but this function does \e not perform a deep copy of the |
| shared pixel data, because the returned data is const. |
| */ |
| const uchar *QImage::bits() const |
| { |
| return d ? d->data : 0; |
| } |
| |
| |
| /*! |
| Returns a pointer to the first pixel data. |
| |
| Note that QImage uses \l{Implicit Data Sharing} {implicit data |
| sharing}, but this function does \e not perform a deep copy of the |
| shared pixel data, because the returned data is const. |
| |
| \sa bits(), constScanLine() |
| \since 4.7 |
| */ |
| const uchar *QImage::constBits() const |
| { |
| return d ? d->data : 0; |
| } |
| |
| /*! |
| \fn void QImage::reset() |
| |
| Resets all image parameters and deallocates the image data. |
| |
| Assign a null image instead. |
| |
| \oldcode |
| QImage image; |
| image.reset(); |
| \newcode |
| QImage image; |
| image = QImage(); |
| \endcode |
| */ |
| |
| /*! |
| \fn void QImage::fill(uint pixelValue) |
| |
| Fills the entire image with the given \a pixelValue. |
| |
| If the depth of this image is 1, only the lowest bit is used. If |
| you say fill(0), fill(2), etc., the image is filled with 0s. If |
| you say fill(1), fill(3), etc., the image is filled with 1s. If |
| the depth is 8, the lowest 8 bits are used and if the depth is 16 |
| the lowest 16 bits are used. |
| |
| Note: QImage::pixel() returns the color of the pixel at the given |
| coordinates while QColor::pixel() returns the pixel value of the |
| underlying window system (essentially an index value), so normally |
| you will want to use QImage::pixel() to use a color from an |
| existing image or QColor::rgb() to use a specific color. |
| |
| \sa depth(), {QImage#Image Transformations}{Image Transformations} |
| */ |
| |
| void QImage::fill(uint pixel) |
| { |
| if (!d) |
| return; |
| |
| detach(); |
| |
| // In case detach() ran out of memory |
| if (!d) |
| return; |
| |
| if (d->depth == 1 || d->depth == 8) { |
| int w = d->width; |
| if (d->depth == 1) { |
| if (pixel & 1) |
| pixel = 0xffffffff; |
| else |
| pixel = 0; |
| w = (w + 7) / 8; |
| } else { |
| pixel &= 0xff; |
| } |
| qt_rectfill<quint8>(d->data, pixel, 0, 0, |
| w, d->height, d->bytes_per_line); |
| return; |
| } else if (d->depth == 16) { |
| qt_rectfill<quint16>(reinterpret_cast<quint16*>(d->data), pixel, |
| 0, 0, d->width, d->height, d->bytes_per_line); |
| return; |
| } else if (d->depth == 24) { |
| qt_rectfill<quint24>(reinterpret_cast<quint24*>(d->data), pixel, |
| 0, 0, d->width, d->height, d->bytes_per_line); |
| return; |
| } |
| |
| if (d->format == Format_RGB32) |
| pixel |= 0xff000000; |
| |
| qt_rectfill<uint>(reinterpret_cast<uint*>(d->data), pixel, |
| 0, 0, d->width, d->height, d->bytes_per_line); |
| } |
| |
| /*! |
| Inverts all pixel values in the image. |
| |
| The given invert \a mode only have a meaning when the image's |
| depth is 32. The default \a mode is InvertRgb, which leaves the |
| alpha channel unchanged. If the \a mode is InvertRgba, the alpha |
| bits are also inverted. |
| |
| Inverting an 8-bit image means to replace all pixels using color |
| index \e i with a pixel using color index 255 minus \e i. The same |
| is the case for a 1-bit image. Note that the color table is \e not |
| changed. |
| |
| \sa {QImage#Image Transformations}{Image Transformations} |
| */ |
| |
| void QImage::invertPixels(InvertMode mode) |
| { |
| if (!d) |
| return; |
| |
| detach(); |
| |
| // In case detach() ran out of memory |
| if (!d) |
| return; |
| |
| if (depth() != 32) { |
| // number of used bytes pr line |
| int bpl = (d->width * d->depth + 7) / 8; |
| int pad = d->bytes_per_line - bpl; |
| uchar *sl = d->data; |
| for (int y=0; y<d->height; ++y) { |
| for (int x=0; x<bpl; ++x) |
| *sl++ ^= 0xff; |
| sl += pad; |
| } |
| } else { |
| quint32 *p = (quint32*)d->data; |
| quint32 *end = (quint32*)(d->data + d->nbytes); |
| uint xorbits = (mode == InvertRgba) ? 0xffffffff : 0x00ffffff; |
| while (p < end) |
| *p++ ^= xorbits; |
| } |
| } |
| |
| /*! |
| \fn void QImage::invertPixels(bool invertAlpha) |
| |
| Use the invertPixels() function that takes a QImage::InvertMode |
| parameter instead. |
| */ |
| |
| /*! \fn QImage::Endian QImage::systemByteOrder() |
| |
| Determines the host computer byte order. Returns |
| QImage::LittleEndian (LSB first) or QImage::BigEndian (MSB first). |
| |
| This function is no longer relevant for QImage. Use QSysInfo |
| instead. |
| */ |
| |
| // Windows defines these |
| #if defined(write) |
| # undef write |
| #endif |
| #if defined(close) |
| # undef close |
| #endif |
| #if defined(read) |
| # undef read |
| #endif |
| |
| /*! |
| \obsolete |
| Resizes the color table to contain \a numColors entries. |
| |
| \sa setColorCount() |
| */ |
| |
| void QImage::setNumColors(int numColors) |
| { |
| setColorCount(numColors); |
| } |
| |
| /*! |
| \since 4.6 |
| Resizes the color table to contain \a colorCount entries. |
| |
| If the color table is expanded, all the extra colors will be set to |
| transparent (i.e qRgba(0, 0, 0, 0)). |
| |
| When the image is used, the color table must be large enough to |
| have entries for all the pixel/index values present in the image, |
| otherwise the results are undefined. |
| |
| \sa colorCount(), colorTable(), setColor(), {QImage#Image |
| Transformations}{Image Transformations} |
| */ |
| |
| void QImage::setColorCount(int colorCount) |
| { |
| if (!d) { |
| qWarning("QImage::setColorCount: null image"); |
| return; |
| } |
| |
| detach(); |
| |
| // In case detach() ran out of memory |
| if (!d) |
| return; |
| |
| if (colorCount == d->colortable.size()) |
| return; |
| if (colorCount <= 0) { // use no color table |
| d->colortable = QVector<QRgb>(); |
| return; |
| } |
| int nc = d->colortable.size(); |
| d->colortable.resize(colorCount); |
| for (int i = nc; i < colorCount; ++i) |
| d->colortable[i] = 0; |
| } |
| |
| /*! |
| Returns the format of the image. |
| |
| \sa {QImage#Image Formats}{Image Formats} |
| */ |
| QImage::Format QImage::format() const |
| { |
| return d ? d->format : Format_Invalid; |
| } |
| |
| |
| #ifdef QT3_SUPPORT |
| /*! |
| Returns true if alpha buffer mode is enabled; otherwise returns |
| false. |
| |
| Use the hasAlphaChannel() function instead. |
| |
| */ |
| bool QImage::hasAlphaBuffer() const |
| { |
| if (!d) |
| return false; |
| |
| switch (d->format) { |
| case Format_ARGB32: |
| case Format_ARGB32_Premultiplied: |
| case Format_ARGB8565_Premultiplied: |
| case Format_ARGB8555_Premultiplied: |
| case Format_ARGB6666_Premultiplied: |
| case Format_ARGB4444_Premultiplied: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /*! |
| Enables alpha buffer mode if \a enable is true, otherwise disables |
| it. The alpha buffer is used to set a mask when a QImage is |
| translated to a QPixmap. |
| |
| If a monochrome or indexed 8-bit image has alpha channels in their |
| color tables they will automatically detect that they have an |
| alpha channel, so this function is not required. To force alpha |
| channels on 32-bit images, use the convertToFormat() function. |
| */ |
| |
| void QImage::setAlphaBuffer(bool enable) |
| { |
| if (!d |
| || d->format == Format_Mono |
| || d->format == Format_MonoLSB |
| || d->format == Format_Indexed8) |
| return; |
| if (enable && (d->format == Format_ARGB32 || |
| d->format == Format_ARGB32_Premultiplied || |
| d->format == Format_ARGB8565_Premultiplied || |
| d->format == Format_ARGB6666_Premultiplied || |
| d->format == Format_ARGB8555_Premultiplied || |
| d->format == Format_ARGB4444_Premultiplied)) |
| { |
| return; |
| } |
| if (!enable && (d->format == Format_RGB32 || |
| d->format == Format_RGB555 || |
| d->format == Format_RGB666 || |
| d->format == Format_RGB888 || |
| d->format == Format_RGB444)) |
| { |
| return; |
| } |
| detach(); |
| d->format = (enable ? Format_ARGB32 : Format_RGB32); |
| } |
| |
| |
| /*! |
| \fn bool QImage::create(int width, int height, int depth, int numColors, Endian bitOrder) |
| |
| Sets the image \a width, \a height, \a depth, its number of colors |
| (in \a numColors), and bit order. Returns true if successful, or |
| false if the parameters are incorrect or if memory cannot be |
| allocated. |
| |
| The \a width and \a height is limited to 32767. \a depth must be |
| 1, 8, or 32. If \a depth is 1, \a bitOrder must be set to |
| either QImage::LittleEndian or QImage::BigEndian. For other depths |
| \a bitOrder must be QImage::IgnoreEndian. |
| |
| This function allocates a color table and a buffer for the image |
| data. The image data is not initialized. The image buffer is |
| allocated as a single block that consists of a table of scanLine() |
| pointers (jumpTable()) and the image data (bits()). |
| |
| Use a QImage constructor instead. |
| */ |
| bool QImage::create(int width, int height, int depth, int numColors, Endian bitOrder) |
| { |
| if (d && !d->ref.deref()) |
| delete d; |
| d = QImageData::create(QSize(width, height), formatFor(depth, bitOrder), numColors); |
| return true; |
| } |
| |
| /*! |
| \fn bool QImage::create(const QSize& size, int depth, int numColors, Endian bitOrder) |
| \overload |
| |
| The width and height are specified in the \a size argument. |
| |
| Use a QImage constructor instead. |
| */ |
| bool QImage::create(const QSize& size, int depth, int numColors, QImage::Endian bitOrder) |
| { |
| if (d && !d->ref.deref()) |
| delete d; |
| d = QImageData::create(size, formatFor(depth, bitOrder), numColors); |
| return true; |
| } |
| #endif // QT3_SUPPORT |
| |
| /***************************************************************************** |
| Internal routines for converting image depth. |
| *****************************************************************************/ |
| |
| typedef void (*Image_Converter)(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags); |
| |
| typedef bool (*InPlace_Image_Converter)(QImageData *data, Qt::ImageConversionFlags); |
| |
| static void convert_ARGB_to_ARGB_PM(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags) |
| { |
| 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); |
| |
| const int src_pad = (src->bytes_per_line >> 2) - src->width; |
| const int dest_pad = (dest->bytes_per_line >> 2) - dest->width; |
| const QRgb *src_data = (QRgb *) src->data; |
| QRgb *dest_data = (QRgb *) dest->data; |
| |
| for (int i = 0; i < src->height; ++i) { |
| const QRgb *end = src_data + src->width; |
| while (src_data < end) { |
| *dest_data = PREMUL(*src_data); |
| ++src_data; |
| ++dest_data; |
| } |
| src_data += src_pad; |
| dest_data += dest_pad; |
| } |
| } |
| |
| static bool convert_ARGB_to_ARGB_PM_inplace(QImageData *data, Qt::ImageConversionFlags) |
| { |
| Q_ASSERT(data->format == QImage::Format_ARGB32); |
| |
| const int pad = (data->bytes_per_line >> 2) - data->width; |
| QRgb *rgb_data = (QRgb *) data->data; |
| |
| for (int i = 0; i < data->height; ++i) { |
| const QRgb *end = rgb_data + data->width; |
| while (rgb_data < end) { |
| *rgb_data = PREMUL(*rgb_data); |
| ++rgb_data; |
| } |
| rgb_data += pad; |
| } |
| data->format = QImage::Format_ARGB32_Premultiplied; |
| return true; |
| } |
| |
| static bool convert_indexed8_to_ARGB_PM_inplace(QImageData *data, Qt::ImageConversionFlags) |
| { |
| Q_ASSERT(data->format == QImage::Format_Indexed8); |
| const int depth = 32; |
| |
| const int dst_bytes_per_line = ((data->width * depth + 31) >> 5) << 2; |
| const int nbytes = dst_bytes_per_line * data->height; |
| uchar *const newData = (uchar *)realloc(data->data, nbytes); |
| if (!newData) |
| return false; |
| |
| data->data = newData; |
| |
| // start converting from the end because the end image is bigger than the source |
| uchar *src_data = newData + data->nbytes; // end of src |
| quint32 *dest_data = (quint32 *) (newData + nbytes); // end of dest > end of src |
| const int width = data->width; |
| const int src_pad = data->bytes_per_line - width; |
| const int dest_pad = (dst_bytes_per_line >> 2) - width; |
| if (data->colortable.size() == 0) { |
| data->colortable.resize(256); |
| for (int i = 0; i < 256; ++i) |
| data->colortable[i] = qRgb(i, i, i); |
| } else { |
| for (int i = 0; i < data->colortable.size(); ++i) |
| data->colortable[i] = PREMUL(data->colortable.at(i)); |
| |
| // Fill the rest of the table in case src_data > colortable.size() |
| const int oldSize = data->colortable.size(); |
| const QRgb lastColor = data->colortable.at(oldSize - 1); |
| data->colortable.insert(oldSize, 256 - oldSize, lastColor); |
| } |
| |
| for (int i = 0; i < data->height; ++i) { |
| src_data -= src_pad; |
| dest_data -= dest_pad; |
| for (int pixI = 0; pixI < width; ++pixI) { |
| --src_data; |
| --dest_data; |
| *dest_data = data->colortable.at(*src_data); |
| } |
| } |
| |
| data->colortable = QVector<QRgb>(); |
| data->format = QImage::Format_ARGB32_Premultiplied; |
| data->bytes_per_line = dst_bytes_per_line; |
| data->depth = depth; |
| data->nbytes = nbytes; |
| |
| return true; |
| } |
| |
| static bool convert_indexed8_to_RGB_inplace(QImageData *data, Qt::ImageConversionFlags) |
| { |
| Q_ASSERT(data->format == QImage::Format_Indexed8); |
| const int depth = 32; |
| |
| const int dst_bytes_per_line = ((data->width * depth + 31) >> 5) << 2; |
| const int nbytes = dst_bytes_per_line * data->height; |
| uchar *const newData = (uchar *)realloc(data->data, nbytes); |
| if (!newData) |
| return false; |
| |
| data->data = newData; |
| |
| // start converting from the end because the end image is bigger than the source |
| uchar *src_data = newData + data->nbytes; |
| quint32 *dest_data = (quint32 *) (newData + nbytes); |
| const int width = data->width; |
| const int src_pad = data->bytes_per_line - width; |
| const int dest_pad = (dst_bytes_per_line >> 2) - width; |
| if (data->colortable.size() == 0) { |
| data->colortable.resize(256); |
| for (int i = 0; i < 256; ++i) |
| data->colortable[i] = qRgb(i, i, i); |
| } else { |
| // Fill the rest of the table in case src_data > colortable.size() |
| const int oldSize = data->colortable.size(); |
| const QRgb lastColor = data->colortable.at(oldSize - 1); |
| data->colortable.insert(oldSize, 256 - oldSize, lastColor); |
| } |
| |
| for (int i = 0; i < data->height; ++i) { |
| src_data -= src_pad; |
| dest_data -= dest_pad; |
| for (int pixI = 0; pixI < width; ++pixI) { |
| --src_data; |
| --dest_data; |
| *dest_data = (quint32) data->colortable.at(*src_data); |
| } |
| } |
| |
| data->colortable = QVector<QRgb>(); |
| data->format = QImage::Format_RGB32; |
| data->bytes_per_line = dst_bytes_per_line; |
| data->depth = depth; |
| data->nbytes = nbytes; |
| |
| return true; |
| } |
| |
| static bool convert_indexed8_to_RGB16_inplace(QImageData *data, Qt::ImageConversionFlags) |
| { |
| Q_ASSERT(data->format == QImage::Format_Indexed8); |
| const int depth = 16; |
| |
| const int dst_bytes_per_line = ((data->width * depth + 31) >> 5) << 2; |
| const int nbytes = dst_bytes_per_line * data->height; |
| uchar *const newData = (uchar *)realloc(data->data, nbytes); |
| if (!newData) |
| return false; |
| |
| data->data = newData; |
| |
| // start converting from the end because the end image is bigger than the source |
| uchar *src_data = newData + data->nbytes; |
| quint16 *dest_data = (quint16 *) (newData + nbytes); |
| const int width = data->width; |
| const int src_pad = data->bytes_per_line - width; |
| const int dest_pad = (dst_bytes_per_line >> 1) - width; |
| |
| quint16 colorTableRGB16[256]; |
| if (data->colortable.isEmpty()) { |
| for (int i = 0; i < 256; ++i) |
| colorTableRGB16[i] = qt_colorConvert<quint16, quint32>(qRgb(i, i, i), 0); |
| } else { |
| // 1) convert the existing colors to RGB16 |
| const int tableSize = data->colortable.size(); |
| for (int i = 0; i < tableSize; ++i) |
| colorTableRGB16[i] = qt_colorConvert<quint16, quint32>(data->colortable.at(i), 0); |
| data->colortable = QVector<QRgb>(); |
| |
| // 2) fill the rest of the table in case src_data > colortable.size() |
| const quint16 lastColor = colorTableRGB16[tableSize - 1]; |
| for (int i = tableSize; i < 256; ++i) |
| colorTableRGB16[i] = lastColor; |
| } |
| |
| for (int i = 0; i < data->height; ++i) { |
| src_data -= src_pad; |
| dest_data -= dest_pad; |
| for (int pixI = 0; pixI < width; ++pixI) { |
| --src_data; |
| --dest_data; |
| *dest_data = colorTableRGB16[*src_data]; |
| } |
| } |
| |
| data->format = QImage::Format_RGB16; |
| data->bytes_per_line = dst_bytes_per_line; |
| data->depth = depth; |
| data->nbytes = nbytes; |
| |
| return true; |
| } |
| |
| static bool convert_RGB_to_RGB16_inplace(QImageData *data, Qt::ImageConversionFlags) |
| { |
| Q_ASSERT(data->format == QImage::Format_RGB32); |
| const int depth = 16; |
| |
| const int dst_bytes_per_line = ((data->width * depth + 31) >> 5) << 2; |
| const int src_bytes_per_line = data->bytes_per_line; |
| quint32 *src_data = (quint32 *) data->data; |
| quint16 *dst_data = (quint16 *) data->data; |
| |
| for (int i = 0; i < data->height; ++i) { |
| qt_memconvert(dst_data, src_data, data->width); |
| src_data = (quint32 *) (((char*)src_data) + src_bytes_per_line); |
| dst_data = (quint16 *) (((char*)dst_data) + dst_bytes_per_line); |
| } |
| data->format = QImage::Format_RGB16; |
| data->bytes_per_line = dst_bytes_per_line; |
| data->depth = depth; |
| data->nbytes = dst_bytes_per_line * data->height; |
| uchar *const newData = (uchar *)realloc(data->data, data->nbytes); |
| if (newData) { |
| data->data = newData; |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| static void convert_ARGB_PM_to_ARGB(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags) |
| { |
| 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); |
| |
| const int src_pad = (src->bytes_per_line >> 2) - src->width; |
| const int dest_pad = (dest->bytes_per_line >> 2) - dest->width; |
| const QRgb *src_data = (QRgb *) src->data; |
| QRgb *dest_data = (QRgb *) dest->data; |
| |
| for (int i = 0; i < src->height; ++i) { |
| const QRgb *end = src_data + src->width; |
| while (src_data < end) { |
| *dest_data = INV_PREMUL(*src_data); |
| ++src_data; |
| ++dest_data; |
| } |
| src_data += src_pad; |
| dest_data += dest_pad; |
| } |
| } |
| |
| static void convert_ARGB_PM_to_RGB(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags) |
| { |
| 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); |
| |
| const int src_pad = (src->bytes_per_line >> 2) - src->width; |
| const int dest_pad = (dest->bytes_per_line >> 2) - dest->width; |
| const QRgb *src_data = (QRgb *) src->data; |
| QRgb *dest_data = (QRgb *) dest->data; |
| |
| for (int i = 0; i < src->height; ++i) { |
| const QRgb *end = src_data + src->width; |
| while (src_data < end) { |
| *dest_data = 0xff000000 | INV_PREMUL(*src_data); |
| ++src_data; |
| ++dest_data; |
| } |
| src_data += src_pad; |
| dest_data += dest_pad; |
| } |
| } |
| |
| static void swap_bit_order(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags) |
| { |
| 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; |
| } |
| } |
| |
| static void mask_alpha_converter(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags) |
| { |
| Q_ASSERT(src->width == dest->width); |
| Q_ASSERT(src->height == dest->height); |
| |
| const int src_pad = (src->bytes_per_line >> 2) - src->width; |
| const int dest_pad = (dest->bytes_per_line >> 2) - dest->width; |
| const uint *src_data = (const uint *)src->data; |
| uint *dest_data = (uint *)dest->data; |
| |
| for (int i = 0; i < src->height; ++i) { |
| const uint *end = src_data + src->width; |
| while (src_data < end) { |
| *dest_data = *src_data | 0xff000000; |
| ++src_data; |
| ++dest_data; |
| } |
| src_data += src_pad; |
| dest_data += dest_pad; |
| } |
| } |
| |
| static QVector<QRgb> fix_color_table(const QVector<QRgb> &ctbl, QImage::Format format) |
| { |
| 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; |
| } |
| |
| // |
| // dither_to_1: Uses selected dithering algorithm. |
| // |
| |
| static void dither_to_Mono(QImageData *dst, const QImageData *src, |
| Qt::ImageConversionFlags flags, bool fromalpha) |
| { |
| 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: { |
| QScopedArrayPointer<int> lineBuffer(new int[w * 2]); |
| int *line1 = lineBuffer.data(); |
| int *line2 = lineBuffer.data() + 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++; |
| } |
| } |
| } 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; |
| } |
| } |
| } |
| |
| static void convert_X_to_Mono(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags) |
| { |
| dither_to_Mono(dst, src, flags, false); |
| } |
| |
| static void convert_ARGB_PM_to_Mono(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags) |
| { |
| QScopedPointer<QImageData> tmp(QImageData::create(QSize(src->width, src->height), QImage::Format_ARGB32)); |
| convert_ARGB_PM_to_ARGB(tmp.data(), src, flags); |
| dither_to_Mono(dst, tmp.data(), flags, false); |
| } |
| |
| // |
| // convert_32_to_8: Converts a 32 bits depth (true color) to an 8 bit |
| // image with a colormap. If the 32 bit image has more than 256 colors, |
| // we convert the red,green and blue bytes into a single byte encoded |
| // as 6 shades of each of red, green and blue. |
| // |
| // if dithering is needed, only 1 color at most is available for alpha. |
| // |
| struct QRgbMap { |
| inline QRgbMap() : used(0) { } |
| uchar pix; |
| uchar used; |
| QRgb rgb; |
| }; |
| |
| static void convert_RGB_to_Indexed8(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags) |
| { |
| 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; |
| table[hash].used = 1; |
| 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; |
| table[hash].used = 1; |
| } |
| 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]; |
| QScopedArrayPointer<int> lineBuffer(new int[src->width * 9]); |
| line1[0] = lineBuffer.data(); |
| line2[0] = lineBuffer.data() + src->width; |
| line1[1] = lineBuffer.data() + src->width * 2; |
| line2[1] = lineBuffer.data() + src->width * 3; |
| line1[2] = lineBuffer.data() + src->width * 4; |
| line2[2] = lineBuffer.data() + src->width * 5; |
| pv[0] = lineBuffer.data() + src->width * 6; |
| pv[1] = lineBuffer.data() + src->width * 7; |
| pv[2] = lineBuffer.data() + src->width * 8; |
| |
| 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; |
| } |
| } 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; |
| QScopedPointer<QImageData> mask(QImageData::create(QSize(src->width, src->height), QImage::Format_Mono)); |
| dither_to_Mono(mask.data(), 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; |
| } |
| |
| #undef MAX_R |
| #undef MAX_G |
| #undef MAX_B |
| #undef INDEXOF |
| |
| } |
| } |
| |
| static void convert_ARGB_PM_to_Indexed8(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags) |
| { |
| QScopedPointer<QImageData> tmp(QImageData::create(QSize(src->width, src->height), QImage::Format_ARGB32)); |
| convert_ARGB_PM_to_ARGB(tmp.data(), src, flags); |
| convert_RGB_to_Indexed8(dst, tmp.data(), flags); |
| } |
| |
| static void convert_ARGB_to_Indexed8(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags) |
| { |
| convert_RGB_to_Indexed8(dst, src, flags); |
| } |
| |
| static void convert_Indexed8_to_X32(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags) |
| { |
| 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); |
| if (colorTable.size() == 0) { |
| colorTable.resize(256); |
| for (int i=0; i<256; ++i) |
| colorTable[i] = qRgb(i, i, i); |
| } |
| |
| int w = src->width; |
| const uchar *src_data = src->data; |
| uchar *dest_data = dest->data; |
| int tableSize = colorTable.size() - 1; |
| 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(qMin<int>(tableSize, *b++)); |
| |
| src_data += src->bytes_per_line; |
| dest_data += dest->bytes_per_line; |
| } |
| } |
| |
| static void convert_Mono_to_X32(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags) |
| { |
| 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; |
| } |
| } |
| } |
| |
| |
| static void convert_Mono_to_Indexed8(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags) |
| { |
| 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; |
| dest->has_alpha_clut = src->has_alpha_clut; |
| |
| |
| 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; |
| } |
| } |
| } |
| |
| #define CONVERT_DECL(DST, SRC) \ |
| static void convert_##SRC##_to_##DST(QImageData *dest, \ |
| const QImageData *src, \ |
| Qt::ImageConversionFlags) \ |
| { \ |
| qt_rectconvert<DST, SRC>(reinterpret_cast<DST*>(dest->data), \ |
| reinterpret_cast<const SRC*>(src->data), \ |
| 0, 0, src->width, src->height, \ |
| dest->bytes_per_line, src->bytes_per_line); \ |
| } |
| |
| CONVERT_DECL(quint32, quint16) |
| CONVERT_DECL(quint16, quint32) |
| CONVERT_DECL(quint32, qargb8565) |
| CONVERT_DECL(qargb8565, quint32) |
| CONVERT_DECL(quint32, qrgb555) |
| CONVERT_DECL(qrgb666, quint32) |
| CONVERT_DECL(quint32, qrgb666) |
| CONVERT_DECL(qargb6666, quint32) |
| CONVERT_DECL(quint32, qargb6666) |
| CONVERT_DECL(qrgb555, quint32) |
| #if !defined(Q_WS_QWS) || (defined(QT_QWS_DEPTH_15) && defined(QT_QWS_DEPTH_16)) |
| CONVERT_DECL(quint16, qrgb555) |
| CONVERT_DECL(qrgb555, quint16) |
| #endif |
| CONVERT_DECL(quint32, qrgb888) |
| CONVERT_DECL(qrgb888, quint32) |
| CONVERT_DECL(quint32, qargb8555) |
| CONVERT_DECL(qargb8555, quint32) |
| CONVERT_DECL(quint32, qrgb444) |
| CONVERT_DECL(qrgb444, quint32) |
| CONVERT_DECL(quint32, qargb4444) |
| CONVERT_DECL(qargb4444, quint32) |
| #undef CONVERT_DECL |
| #define CONVERT_PTR(DST, SRC) convert_##SRC##_to_##DST |
| |
| /* |
| Format_Invalid, |
| Format_Mono, |
| Format_MonoLSB, |
| Format_Indexed8, |
| Format_RGB32, |
| Format_ARGB32, |
| Format_ARGB32_Premultiplied, |
| Format_RGB16, |
| Format_ARGB8565_Premultiplied, |
| Format_RGB666, |
| Format_ARGB6666_Premultiplied, |
| Format_RGB555, |
| Format_ARGB8555_Premultiplied, |
| Format_RGB888 |
| Format_RGB444 |
| Format_ARGB4444_Premultiplied |
| */ |
| |
| |
| // first index source, second dest |
| static Image_Converter converter_map[QImage::NImageFormats][QImage::NImageFormats] = |
| { |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, |
| { |
| 0, |
| 0, |
| swap_bit_order, |
| convert_Mono_to_Indexed8, |
| convert_Mono_to_X32, |
| convert_Mono_to_X32, |
| convert_Mono_to_X32, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_Mono |
| |
| { |
| 0, |
| swap_bit_order, |
| 0, |
| convert_Mono_to_Indexed8, |
| convert_Mono_to_X32, |
| convert_Mono_to_X32, |
| convert_Mono_to_X32, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_MonoLSB |
| |
| { |
| 0, |
| convert_X_to_Mono, |
| convert_X_to_Mono, |
| 0, |
| convert_Indexed8_to_X32, |
| convert_Indexed8_to_X32, |
| convert_Indexed8_to_X32, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_Indexed8 |
| |
| { |
| 0, |
| convert_X_to_Mono, |
| convert_X_to_Mono, |
| convert_RGB_to_Indexed8, |
| 0, |
| mask_alpha_converter, |
| mask_alpha_converter, |
| CONVERT_PTR(quint16, quint32), |
| CONVERT_PTR(qargb8565, quint32), |
| CONVERT_PTR(qrgb666, quint32), |
| CONVERT_PTR(qargb6666, quint32), |
| CONVERT_PTR(qrgb555, quint32), |
| CONVERT_PTR(qargb8555, quint32), |
| CONVERT_PTR(qrgb888, quint32), |
| CONVERT_PTR(qrgb444, quint32), |
| CONVERT_PTR(qargb4444, quint32) |
| }, // Format_RGB32 |
| |
| { |
| 0, |
| convert_X_to_Mono, |
| convert_X_to_Mono, |
| convert_ARGB_to_Indexed8, |
| mask_alpha_converter, |
| 0, |
| convert_ARGB_to_ARGB_PM, |
| CONVERT_PTR(quint16, quint32), |
| CONVERT_PTR(qargb8565, quint32), |
| CONVERT_PTR(qrgb666, quint32), |
| CONVERT_PTR(qargb6666, quint32), |
| CONVERT_PTR(qrgb555, quint32), |
| CONVERT_PTR(qargb8555, quint32), |
| CONVERT_PTR(qrgb888, quint32), |
| CONVERT_PTR(qrgb444, quint32), |
| CONVERT_PTR(qargb4444, quint32) |
| }, // Format_ARGB32 |
| |
| { |
| 0, |
| convert_ARGB_PM_to_Mono, |
| convert_ARGB_PM_to_Mono, |
| convert_ARGB_PM_to_Indexed8, |
| convert_ARGB_PM_to_RGB, |
| convert_ARGB_PM_to_ARGB, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_ARGB32_Premultiplied |
| |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| CONVERT_PTR(quint32, quint16), |
| CONVERT_PTR(quint32, quint16), |
| CONVERT_PTR(quint32, quint16), |
| 0, |
| 0, |
| 0, |
| 0, |
| #if !defined(Q_WS_QWS) || (defined(QT_QWS_DEPTH_15) && defined(QT_QWS_DEPTH_16)) |
| CONVERT_PTR(qrgb555, quint16), |
| #else |
| 0, |
| #endif |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_RGB16 |
| |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| CONVERT_PTR(quint32, qargb8565), |
| CONVERT_PTR(quint32, qargb8565), |
| CONVERT_PTR(quint32, qargb8565), |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_ARGB8565_Premultiplied |
| |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| CONVERT_PTR(quint32, qrgb666), |
| CONVERT_PTR(quint32, qrgb666), |
| CONVERT_PTR(quint32, qrgb666), |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_RGB666 |
| |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| CONVERT_PTR(quint32, qargb6666), |
| CONVERT_PTR(quint32, qargb6666), |
| CONVERT_PTR(quint32, qargb6666), |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_ARGB6666_Premultiplied |
| |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| CONVERT_PTR(quint32, qrgb555), |
| CONVERT_PTR(quint32, qrgb555), |
| CONVERT_PTR(quint32, qrgb555), |
| #if !defined(Q_WS_QWS) || (defined(QT_QWS_DEPTH_15) && defined(QT_QWS_DEPTH_16)) |
| CONVERT_PTR(quint16, qrgb555), |
| #else |
| 0, |
| #endif |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_RGB555 |
| |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| CONVERT_PTR(quint32, qargb8555), |
| CONVERT_PTR(quint32, qargb8555), |
| CONVERT_PTR(quint32, qargb8555), |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_ARGB8555_Premultiplied |
| |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| CONVERT_PTR(quint32, qrgb888), |
| CONVERT_PTR(quint32, qrgb888), |
| CONVERT_PTR(quint32, qrgb888), |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_RGB888 |
| |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| CONVERT_PTR(quint32, qrgb444), |
| CONVERT_PTR(quint32, qrgb444), |
| CONVERT_PTR(quint32, qrgb444), |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| }, // Format_RGB444 |
| |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| CONVERT_PTR(quint32, qargb4444), |
| CONVERT_PTR(quint32, qargb4444), |
| CONVERT_PTR(quint32, qargb4444), |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0 |
| } // Format_ARGB4444_Premultiplied |
| }; |
| |
| static InPlace_Image_Converter inplace_converter_map[QImage::NImageFormats][QImage::NImageFormats] = |
| { |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_Mono |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_MonoLSB |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| convert_indexed8_to_RGB_inplace, |
| convert_indexed8_to_ARGB_PM_inplace, |
| convert_indexed8_to_RGB16_inplace, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| }, // Format_Indexed8 |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| convert_RGB_to_RGB16_inplace, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| }, // Format_ARGB32 |
| { |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| convert_ARGB_to_ARGB_PM_inplace, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| }, // Format_ARGB32 |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_ARGB32_Premultiplied |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_RGB16 |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_ARGB8565_Premultiplied |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_RGB666 |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_ARGB6666_Premultiplied |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_RGB555 |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_ARGB8555_Premultiplied |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_RGB888 |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }, // Format_RGB444 |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| } // Format_ARGB4444_Premultiplied |
| }; |
| |
| void qInitImageConversions() |
| { |
| const uint features = qDetectCPUFeatures(); |
| Q_UNUSED(features); |
| |
| #ifdef QT_HAVE_SSE2 |
| if (features & SSE2) { |
| extern bool convert_ARGB_to_ARGB_PM_inplace_sse2(QImageData *data, Qt::ImageConversionFlags); |
| inplace_converter_map[QImage::Format_ARGB32][QImage::Format_ARGB32_Premultiplied] = convert_ARGB_to_ARGB_PM_inplace_sse2; |
| } |
| #endif |
| #ifdef QT_HAVE_SSSE3 |
| if (features & SSSE3) { |
| extern void convert_RGB888_to_RGB32_ssse3(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags); |
| converter_map[QImage::Format_RGB888][QImage::Format_RGB32] = convert_RGB888_to_RGB32_ssse3; |
| converter_map[QImage::Format_RGB888][QImage::Format_ARGB32] = convert_RGB888_to_RGB32_ssse3; |
| converter_map[QImage::Format_RGB888][QImage::Format_ARGB32_Premultiplied] = convert_RGB888_to_RGB32_ssse3; |
| } |
| #endif |
| #ifdef QT_HAVE_NEON |
| if (features & NEON) { |
| extern void convert_RGB888_to_RGB32_neon(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags); |
| converter_map[QImage::Format_RGB888][QImage::Format_RGB32] = convert_RGB888_to_RGB32_neon; |
| converter_map[QImage::Format_RGB888][QImage::Format_ARGB32] = convert_RGB888_to_RGB32_neon; |
| converter_map[QImage::Format_RGB888][QImage::Format_ARGB32_Premultiplied] = convert_RGB888_to_RGB32_neon; |
| } |
| #endif |
| } |
| |
| /*! |
| Returns a copy of the image in the given \a format. |
| |
| The specified image conversion \a flags control how the image data |
| is handled during the conversion process. |
| |
| \sa {QImage#Image Format}{Image Format} |
| */ |
| QImage QImage::convertToFormat(Format format, Qt::ImageConversionFlags flags) const |
| { |
| if (!d || d->format == format) |
| return *this; |
| |
| if (format == Format_Invalid || d->format == Format_Invalid) |
| return QImage(); |
| |
| const Image_Converter *converterPtr = &converter_map[d->format][format]; |
| Image_Converter converter = *converterPtr; |
| if (converter) { |
| QImage image(d->width, d->height, format); |
| |
| QIMAGE_SANITYCHECK_MEMORY(image); |
| |
| image.setDotsPerMeterY(dotsPerMeterY()); |
| image.setDotsPerMeterX(dotsPerMeterX()); |
| |
| #if !defined(QT_NO_IMAGE_TEXT) |
| image.d->text = d->text; |
| #endif // !QT_NO_IMAGE_TEXT |
| |
| converter(image.d, d, flags); |
| return image; |
| } |
| |
| Q_ASSERT(format != QImage::Format_ARGB32); |
| Q_ASSERT(d->format != QImage::Format_ARGB32); |
| |
| QImage image = convertToFormat(Format_ARGB32, flags); |
| return image.convertToFormat(format, flags); |
| } |
| |
| |
| |
| static inline int pixel_distance(QRgb p1, QRgb p2) { |
| 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); |
| } |
| |
| static inline int closestMatch(QRgb pixel, const QVector<QRgb> &clut) { |
| 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; |
| } |
| |
| static QImage convertWithPalette(const QImage &src, QImage::Format format, |
| const QVector<QRgb> &clut) { |
| QImage dest(src.size(), format); |
| dest.setColorTable(clut); |
| |
| #if !defined(QT_NO_IMAGE_TEXT) |
| QString textsKeys = src.text(); |
| QStringList textKeyList = textsKeys.split(QLatin1Char('\n'), QString::SkipEmptyParts); |
| foreach (const QString &textKey, textKeyList) { |
| QStringList textKeySplitted = textKey.split(QLatin1String(": ")); |
| 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; |
| } |
| |
| /*! |
| \overload |
| |
| Returns a copy of the image converted to the given \a format, |
| using the specified \a colorTable. |
| |
| Conversion from 32 bit to 8 bit indexed is a slow operation and |
| will use a straightforward nearest color approach, with no |
| dithering. |
| */ |
| QImage QImage::convertToFormat(Format format, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags) const |
| { |
| if (d->format == format) |
| return *this; |
| |
| if (format <= QImage::Format_Indexed8 && depth() == 32) { |
| return convertWithPalette(*this, format, colorTable); |
| } |
| |
| const Image_Converter *converterPtr = &converter_map[d->format][format]; |
| Image_Converter converter = *converterPtr; |
| if (!converter) |
| return QImage(); |
| |
| QImage image(d->width, d->height, format); |
| QIMAGE_SANITYCHECK_MEMORY(image); |
| |
| #if !defined(QT_NO_IMAGE_TEXT) |
| image.d->text = d->text; |
| #endif // !QT_NO_IMAGE_TEXT |
| |
| converter(image.d, d, flags); |
| return image; |
| } |
| |
| #ifdef QT3_SUPPORT |
| /*! |
| Converts the depth (bpp) of the image to the given \a depth and |
| returns the converted image. The original image is not changed. |
| Returns this image if \a depth is equal to the image depth, or a |
| null image if this image cannot be converted. The \a depth |
| argument must be 1, 8 or 32. If the image needs to be modified to |
| fit in a lower-resolution result (e.g. converting from 32-bit to |
| 8-bit), use the \a flags to specify how you'd prefer this to |
| happen. |
| |
| Use the convertToFormat() function instead. |
| */ |
| |
| QImage QImage::convertDepth(int depth, Qt::ImageConversionFlags flags) const |
| { |
| if (!d || d->depth == depth) |
| return *this; |
| |
| Format format = formatFor (depth, QImage::LittleEndian); |
| return convertToFormat(format, flags); |
| } |
| #endif |
| |
| /*! |
| \fn bool QImage::valid(const QPoint &pos) const |
| |
| Returns true if \a pos is a valid coordinate pair within the |
| image; otherwise returns false. |
| |
| \sa rect(), QRect::contains() |
| */ |
| |
| /*! |
| \overload |
| |
| Returns true if QPoint(\a x, \a y) is a valid coordinate pair |
| within the image; otherwise returns false. |
| */ |
| bool QImage::valid(int x, int y) const |
| { |
| return d |
| && x >= 0 && x < d->width |
| && y >= 0 && y < d->height; |
| } |
| |
| /*! |
| \fn int QImage::pixelIndex(const QPoint &position) const |
| |
| Returns the pixel index at the given \a position. |
| |
| If \a position is not valid, or if the image is not a paletted |
| image (depth() > 8), the results are undefined. |
| |
| \sa valid(), depth(), {QImage#Pixel Manipulation}{Pixel Manipulation} |
| */ |
| |
| /*! |
| \overload |
| |
| Returns the pixel index at (\a x, \a y). |
| */ |
| int QImage::pixelIndex(int x, int y) const |
| { |
| if (!d || x < 0 || x >= d->width || y < 0 || y >= height()) { |
| qWarning("QImage::pixelIndex: coordinate (%d,%d) out of range", x, y); |
| return -12345; |
| } |
| const uchar * s = scanLine(y); |
| switch(d->format) { |
| case Format_Mono: |
| return (*(s + (x >> 3)) >> (7- (x & 7))) & 1; |
| case Format_MonoLSB: |
| return (*(s + (x >> 3)) >> (x & 7)) & 1; |
| case Format_Indexed8: |
| return (int)s[x]; |
| default: |
| qWarning("QImage::pixelIndex: Not applicable for %d-bpp images (no palette)", d->depth); |
| } |
| return 0; |
| } |
| |
| |
| /*! |
| \fn QRgb QImage::pixel(const QPoint &position) const |
| |
| Returns the color of the pixel at the given \a position. |
| |
| If the \a position is not valid, the results are undefined. |
| |
| \warning This function is expensive when used for massive pixel |
| manipulations. |
| |
| \sa setPixel(), valid(), {QImage#Pixel Manipulation}{Pixel |
| Manipulation} |
| */ |
| |
| /*! |
| \overload |
| |
| Returns the color of the pixel at coordinates (\a x, \a y). |
| */ |
| QRgb QImage::pixel(int x, int y) const |
| { |
| if (!d || x < 0 || x >= d->width || y < 0 || y >= height()) { |
| qWarning("QImage::pixel: coordinate (%d,%d) out of range", x, y); |
| return 12345; |
| } |
| const uchar * s = scanLine(y); |
| switch(d->format) { |
| case Format_Mono: |
| return d->colortable.at((*(s + (x >> 3)) >> (7- (x & 7))) & 1); |
| case Format_MonoLSB: |
| return d->colortable.at((*(s + (x >> 3)) >> (x & 7)) & 1); |
| case Format_Indexed8: |
| return d->colortable.at((int)s[x]); |
| case Format_ARGB8565_Premultiplied: |
| return qt_colorConvert<quint32, qargb8565>(reinterpret_cast<const qargb8565*>(s)[x], 0); |
| case Format_RGB666: |
| return qt_colorConvert<quint32, qrgb666>(reinterpret_cast<const qrgb666*>(s)[x], 0); |
| case Format_ARGB6666_Premultiplied: |
| return qt_colorConvert<quint32, qargb6666>(reinterpret_cast<const qargb6666*>(s)[x], 0); |
| case Format_RGB555: |
| return qt_colorConvert<quint32, qrgb555>(reinterpret_cast<const qrgb555*>(s)[x], 0); |
| case Format_ARGB8555_Premultiplied: |
| return qt_colorConvert<quint32, qargb8555>(reinterpret_cast<const qargb8555*>(s)[x], 0); |
| case Format_RGB888: |
| return qt_colorConvert<quint32, qrgb888>(reinterpret_cast<const qrgb888*>(s)[x], 0); |
| case Format_RGB444: |
| return qt_colorConvert<quint32, qrgb444>(reinterpret_cast<const qrgb444*>(s)[x], 0); |
| case Format_ARGB4444_Premultiplied: |
| return qt_colorConvert<quint32, qargb4444>(reinterpret_cast<const qargb4444*>(s)[x], 0); |
| case Format_RGB16: |
| return qt_colorConvert<quint32, quint16>(reinterpret_cast<const quint16*>(s)[x], 0); |
| default: |
| return ((QRgb*)s)[x]; |
| } |
| } |
| |
| |
| /*! |
| \fn void QImage::setPixel(const QPoint &position, uint index_or_rgb) |
| |
| Sets the pixel index or color at the given \a position to \a |
| index_or_rgb. |
| |
| If the image's format is either monochrome or 8-bit, the given \a |
| index_or_rgb value must be an index in the image's color table, |
| otherwise the parameter must be a QRgb value. |
| |
| If \a position is not a valid coordinate pair in the image, or if |
| \a index_or_rgb >= colorCount() in the case of monochrome and |
| 8-bit images, the result is undefined. |
| |
| \warning This function is expensive due to the call of the internal |
| \c{detach()} function called within; if performance is a concern, we |
| recommend the use of \l{QImage::}{scanLine()} to access pixel data |
| directly. |
| |
| \sa pixel(), {QImage#Pixel Manipulation}{Pixel Manipulation} |
| */ |
| |
| /*! |
| \overload |
| |
| Sets the pixel index or color at (\a x, \a y) to \a index_or_rgb. |
| */ |
| void QImage::setPixel(int x, int y, uint index_or_rgb) |
| { |
| if (!d || x < 0 || x >= width() || y < 0 || y >= height()) { |
| qWarning("QImage::setPixel: coordinate (%d,%d) out of range", x, y); |
| return; |
| } |
| // detach is called from within scanLine |
| uchar * s = scanLine(y); |
| const quint32p p = quint32p::fromRawData(index_or_rgb); |
| switch(d->format) { |
| case Format_Mono: |
| case Format_MonoLSB: |
| if (index_or_rgb > 1) { |
| qWarning("QImage::setPixel: Index %d out of range", index_or_rgb); |
| } else if (format() == Format_MonoLSB) { |
| if (index_or_rgb==0) |
| *(s + (x >> 3)) &= ~(1 << (x & 7)); |
| else |
| *(s + (x >> 3)) |= (1 << (x & 7)); |
| } else { |
| if (index_or_rgb==0) |
| *(s + (x >> 3)) &= ~(1 << (7-(x & 7))); |
| else |
| *(s + (x >> 3)) |= (1 << (7-(x & 7))); |
| } |
| break; |
| case Format_Indexed8: |
| if (index_or_rgb >= (uint)d->colortable.size()) { |
| qWarning("QImage::setPixel: Index %d out of range", index_or_rgb); |
| return; |
| } |
| s[x] = index_or_rgb; |
| break; |
| case Format_RGB32: |
| //make sure alpha is 255, we depend on it in qdrawhelper for cases |
| // when image is set as a texture pattern on a qbrush |
| ((uint *)s)[x] = uint(255 << 24) | index_or_rgb; |
| break; |
| case Format_ARGB32: |
| case Format_ARGB32_Premultiplied: |
| ((uint *)s)[x] = index_or_rgb; |
| break; |
| case Format_RGB16: |
| ((quint16 *)s)[x] = qt_colorConvert<quint16, quint32p>(p, 0); |
| break; |
| case Format_ARGB8565_Premultiplied: |
| ((qargb8565*)s)[x] = qt_colorConvert<qargb8565, quint32p>(p, 0); |
| break; |
| case Format_RGB666: |
| ((qrgb666*)s)[x] = qt_colorConvert<qrgb666, quint32p>(p, 0); |
| break; |
| case Format_ARGB6666_Premultiplied: |
| ((qargb6666*)s)[x] = qt_colorConvert<qargb6666, quint32p>(p, 0); |
| break; |
| case Format_RGB555: |
| ((qrgb555*)s)[x] = qt_colorConvert<qrgb555, quint32p>(p, 0); |
| break; |
| case Format_ARGB8555_Premultiplied: |
| ((qargb8555*)s)[x] = qt_colorConvert<qargb8555, quint32p>(p, 0); |
| break; |
| case Format_RGB888: |
| ((qrgb888*)s)[x] = qt_colorConvert<qrgb888, quint32p>(p, 0); |
| break; |
| case Format_RGB444: |
| ((qrgb444*)s)[x] = qt_colorConvert<qrgb444, quint32p>(p, 0); |
| break; |
| case Format_ARGB4444_Premultiplied: |
| ((qargb4444*)s)[x] = qt_colorConvert<qargb4444, quint32p>(p, 0); |
| break; |
| case Format_Invalid: |
| case NImageFormats: |
| Q_ASSERT(false); |
| } |
| } |
| |
| #ifdef QT3_SUPPORT |
| /*! |
| Converts the bit order of the image to the given \a bitOrder and |
| returns the converted image. The original image is not changed. |
| Returns this image if the given \a bitOrder is equal to the image |
| current bit order, or a null image if this image cannot be |
| converted. |
| |
| Use convertToFormat() instead. |
| */ |
| |
| QImage QImage::convertBitOrder(Endian bitOrder) const |
| { |
| if (!d || isNull() || d->depth != 1 || !(bitOrder == BigEndian || bitOrder == LittleEndian)) |
| return QImage(); |
| |
| if ((d->format == Format_Mono && bitOrder == BigEndian) |
| || (d->format == Format_MonoLSB && bitOrder == LittleEndian)) |
| return *this; |
| |
| QImage image(d->width, d->height, d->format == Format_Mono ? Format_MonoLSB : Format_Mono); |
| |
| const uchar *data = d->data; |
| const uchar *end = data + d->nbytes; |
| uchar *ndata = image.d->data; |
| while (data < end) |
| *ndata++ = bitflip[*data++]; |
| |
| image.setDotsPerMeterX(dotsPerMeterX()); |
| image.setDotsPerMeterY(dotsPerMeterY()); |
| |
| image.d->colortable = d->colortable; |
| return image; |
| } |
| #endif |
| /*! |
| Returns true if all the colors in the image are shades of gray |
| (i.e. their red, green and blue components are equal); otherwise |
| false. |
| |
| Note that this function is slow for images without color table. |
| |
| \sa isGrayscale() |
| */ |
| bool QImage::allGray() const |
| { |
| if (!d) |
| return true; |
| |
| if (d->depth == 32) { |
| int p = width()*height(); |
| const QRgb* b = (const QRgb*)bits(); |
| while (p--) |
| if (!qIsGray(*b++)) |
| return false; |
| } else if (d->depth == 16) { |
| int p = width()*height(); |
| const ushort* b = (const ushort *)bits(); |
| while (p--) |
| if (!qIsGray(qt_colorConvert<quint32, quint16>(*b++, 0))) |
| return false; |
| } else if (d->format == QImage::Format_RGB888) { |
| int p = width()*height(); |
| const qrgb888* b = (const qrgb888 *)bits(); |
| while (p--) |
| if (!qIsGray(qt_colorConvert<quint32, qrgb888>(*b++, 0))) |
| return false; |
| } else { |
| if (d->colortable.isEmpty()) |
| return true; |
| for (int i = 0; i < colorCount(); i++) |
| if (!qIsGray(d->colortable.at(i))) |
| return false; |
| } |
| return true; |
| } |
| |
| /*! |
| For 32-bit images, this function is equivalent to allGray(). |
| |
| For 8-bpp images, this function returns true if color(i) is |
| QRgb(i, i, i) for all indexes of the color table; otherwise |
| returns false. |
| |
| \sa allGray(), {QImage#Image Formats}{Image Formats} |
| */ |
| bool QImage::isGrayscale() const |
| { |
| if (!d) |
| return false; |
| |
| switch (depth()) { |
| case 32: |
| case 24: |
| case 16: |
| return allGray(); |
| case 8: { |
| for (int i = 0; i < colorCount(); i++) |
| if (d->colortable.at(i) != qRgb(i,i,i)) |
| return false; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| |
| /*! |
| \fn QImage QImage::smoothScale(int width, int height, Qt::AspectRatioMode mode) const |
| |
| Use scaled() instead. |
| |
| \oldcode |
| QImage image; |
| image.smoothScale(width, height, mode); |
| \newcode |
| QImage image; |
| image.scaled(width, height, mode, Qt::SmoothTransformation); |
| \endcode |
| */ |
| |
| /*! |
| \fn QImage QImage::smoothScale(const QSize &size, Qt::AspectRatioMode mode) const |
| \overload |
| |
| Use scaled() instead. |
| |
| \oldcode |
| QImage image; |
| image.smoothScale(size, mode); |
| \newcode |
| QImage image; |
| image.scaled(size, mode, Qt::SmoothTransformation); |
| \endcode |
| */ |
| |
| /*! |
| \fn QImage QImage::scaled(int width, int height, Qt::AspectRatioMode aspectRatioMode, |
| Qt::TransformationMode transformMode) const |
| \overload |
| |
| Returns a copy of the image scaled to a rectangle with the given |
| \a width and \a height according to the given \a aspectRatioMode |
| and \a transformMode. |
| |
| If either the \a width or the \a height is zero or negative, this |
| function returns a null image. |
| */ |
| |
| /*! |
| \fn QImage QImage::scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode, |
| Qt::TransformationMode transformMode) const |
| |
| Returns a copy of the image scaled to a rectangle defined by the |
| given \a size according to the given \a aspectRatioMode and \a |
| transformMode. |
| |
| \image qimage-scaling.png |
| |
| \list |
| \i If \a aspectRatioMode is Qt::IgnoreAspectRatio, the image |
| is scaled to \a size. |
| \i If \a aspectRatioMode is Qt::KeepAspectRatio, the image is |
| scaled to a rectangle as large as possible inside \a size, preserving the aspect ratio. |
| \i If \a aspectRatioMode is Qt::KeepAspectRatioByExpanding, |
| the image is scaled to a rectangle as small as possible |
| outside \a size, preserving the aspect ratio. |
| \endlist |
| |
| If the given \a size is empty, this function returns a null image. |
| |
| \sa isNull(), {QImage#Image Transformations}{Image |
| Transformations} |
| */ |
| QImage QImage::scaled(const QSize& s, Qt::AspectRatioMode aspectMode, Qt::TransformationMode mode) const |
| { |
| if (!d) { |
| qWarning("QImage::scaled: Image is a null image"); |
| return QImage(); |
| } |
| if (s.isEmpty()) |
| return QImage(); |
| |
| QSize newSize = size(); |
| newSize.scale(s, aspectMode); |
| newSize.rwidth() = qMax(newSize.width(), 1); |
| newSize.rheight() = qMax(newSize.height(), 1); |
| if (newSize == size()) |
| return *this; |
| |
| QTransform wm = QTransform::fromScale((qreal)newSize.width() / width(), (qreal)newSize.height() / height()); |
| QImage img = transformed(wm, mode); |
| return img; |
| } |
| |
| /*! |
| \fn QImage QImage::scaledToWidth(int width, Qt::TransformationMode mode) const |
| |
| Returns a scaled copy of the image. The returned image is scaled |
| to the given \a width using the specified transformation \a |
| mode. |
| |
| This function automatically calculates the height of the image so |
| that its aspect ratio is preserved. |
| |
| If the given \a width is 0 or negative, a null image is returned. |
| |
| \sa {QImage#Image Transformations}{Image Transformations} |
| */ |
| QImage QImage::scaledToWidth(int w, Qt::TransformationMode mode) const |
| { |
| if (!d) { |
| qWarning("QImage::scaleWidth: Image is a null image"); |
| return QImage(); |
| } |
| if (w <= 0) |
| return QImage(); |
| |
| qreal factor = (qreal) w / width(); |
| QTransform wm = QTransform::fromScale(factor, factor); |
| return transformed(wm, mode); |
| } |
| |
| /*! |
| \fn QImage QImage::scaledToHeight(int height, Qt::TransformationMode mode) const |
| |
| Returns a scaled copy of the image. The returned image is scaled |
| to the given \a height using the specified transformation \a |
| mode. |
| |
| This function automatically calculates the width of the image so that |
| the ratio of the image is preserved. |
| |
| If the given \a height is 0 or negative, a null image is returned. |
| |
| \sa {QImage#Image Transformations}{Image Transformations} |
| */ |
| QImage QImage::scaledToHeight(int h, Qt::TransformationMode mode) const |
| { |
| if (!d) { |
| qWarning("QImage::scaleHeight: Image is a null image"); |
| return QImage(); |
| } |
| if (h <= 0) |
| return QImage(); |
| |
| qreal factor = (qreal) h / height(); |
| QTransform wm = QTransform::fromScale(factor, factor); |
| return transformed(wm, mode); |
| } |
| |
| |
| /*! |
| \fn QMatrix QImage::trueMatrix(const QMatrix &matrix, int width, int height) |
| |
| Returns the actual matrix used for transforming an image with the |
| given \a width, \a height and \a matrix. |
| |
| When transforming an image using the transformed() function, the |
| transformation matrix is internally adjusted to compensate for |
| unwanted translation, i.e. transformed() returns the smallest |
| image containing all transformed points of the original image. |
| This function returns the modified matrix, which maps points |
| correctly from the original image into the new image. |
| |
| \sa transformed(), {QImage#Image Transformations}{Image |
| Transformations} |
| */ |
| QMatrix QImage::trueMatrix(const QMatrix &matrix, int w, int h) |
| { |
| return trueMatrix(QTransform(matrix), w, h).toAffine(); |
| } |
| |
| /*! |
| Returns a copy of the image that is transformed using the given |
| transformation \a matrix and transformation \a mode. |
| |
| The transformation \a matrix is internally adjusted to compensate |
| for unwanted translation; i.e. the image produced is the smallest |
| image that contains all the transformed points of the original |
| image. Use the trueMatrix() function to retrieve the actual matrix |
| used for transforming an image. |
| |
| \sa trueMatrix(), {QImage#Image Transformations}{Image |
| Transformations} |
| */ |
| QImage QImage::transformed(const QMatrix &matrix, Qt::TransformationMode mode) const |
| { |
| return transformed(QTransform(matrix), mode); |
| } |
| |
| /*! |
| Builds and returns a 1-bpp mask from the alpha buffer in this |
| image. Returns a null image if the image's format is |
| QImage::Format_RGB32. |
| |
| The \a flags argument is a bitwise-OR of the |
| Qt::ImageConversionFlags, and controls the conversion |
| process. Passing 0 for flags sets all the default options. |
| |
| The returned image has little-endian bit order (i.e. the image's |
| format is QImage::Format_MonoLSB), which you can convert to |
| big-endian (QImage::Format_Mono) using the convertToFormat() |
| function. |
| |
| \sa createHeuristicMask(), {QImage#Image Transformations}{Image |
| Transformations} |
| */ |
| QImage QImage::createAlphaMask(Qt::ImageConversionFlags flags) const |
| { |
| if (!d || d->format == QImage::Format_RGB32) |
| return QImage(); |
| |
| if (d->depth == 1) { |
| // A monochrome pixmap, with alpha channels on those two colors. |
| // Pretty unlikely, so use less efficient solution. |
| return convertToFormat(Format_Indexed8, flags).createAlphaMask(flags); |
| } |
| |
| QImage mask(d->width, d->height, Format_MonoLSB); |
| if (!mask.isNull()) |
| dither_to_Mono(mask.d, d, flags, true); |
| return mask; |
| } |
| |
| #ifndef QT_NO_IMAGE_HEURISTIC_MASK |
| /*! |
| Creates and returns a 1-bpp heuristic mask for this image. |
| |
| The function works by selecting a color from one of the corners, |
| then chipping away pixels of that color starting at all the edges. |
| The four corners vote for which color is to be masked away. In |
| case of a draw (this generally means that this function is not |
| applicable to the image), the result is arbitrary. |
| |
| The returned image has little-endian bit order (i.e. the image's |
| format is QImage::Format_MonoLSB), which you can convert to |
| big-endian (QImage::Format_Mono) using the convertToFormat() |
| function. |
| |
| If \a clipTight is true (the default) the mask is just large |
| enough to cover the pixels; otherwise, the mask is larger than the |
| data pixels. |
| |
| Note that this function disregards the alpha buffer. |
| |
| \sa createAlphaMask(), {QImage#Image Transformations}{Image |
| Transformations} |
| */ |
| |
| QImage QImage::createHeuristicMask(bool clipTight) const |
| { |
| if (!d) |
| return QImage(); |
| |
| if (d->depth != 32) { |
| QImage img32 = convertToFormat(Format_RGB32); |
| return img32.createHeuristicMask(clipTight); |
| } |
| |
| #define PIX(x,y) (*((QRgb*)scanLine(y)+x) & 0x00ffffff) |
| |
| int w = width(); |
| int h = height(); |
| QImage m(w, h, Format_MonoLSB); |
| QIMAGE_SANITYCHECK_MEMORY(m); |
| m.setColorCount(2); |
| m.setColor(0, QColor(Qt::color0).rgba()); |
| m.setColor(1, QColor(Qt::color1).rgba()); |
| m.fill(0xff); |
| |
| QRgb background = PIX(0,0); |
| if (background != PIX(w-1,0) && |
| background != PIX(0,h-1) && |
| background != PIX(w-1,h-1)) { |
| background = PIX(w-1,0); |
| if (background != PIX(w-1,h-1) && |
| background != PIX(0,h-1) && |
| PIX(0,h-1) == PIX(w-1,h-1)) { |
| background = PIX(w-1,h-1); |
| } |
| } |
| |
| int x,y; |
| bool done = false; |
| uchar *ypp, *ypc, *ypn; |
| while(!done) { |
| done = true; |
| ypn = m.scanLine(0); |
| ypc = 0; |
| for (y = 0; y < h; y++) { |
| ypp = ypc; |
| ypc = ypn; |
| ypn = (y == h-1) ? 0 : m.scanLine(y+1); |
| QRgb *p = (QRgb *)scanLine(y); |
| for (x = 0; x < w; x++) { |
| // slowness here - it's possible to do six of these tests |
| // together in one go. oh well. |
| if ((x == 0 || y == 0 || x == w-1 || y == h-1 || |
| !(*(ypc + ((x-1) >> 3)) & (1 << ((x-1) & 7))) || |
| !(*(ypc + ((x+1) >> 3)) & (1 << ((x+1) & 7))) || |
| !(*(ypp + (x >> 3)) & (1 << (x & 7))) || |
| !(*(ypn + (x >> 3)) & (1 << (x & 7)))) && |
| ( (*(ypc + (x >> 3)) & (1 << (x & 7)))) && |
| ((*p & 0x00ffffff) == background)) { |
| done = false; |
| *(ypc + (x >> 3)) &= ~(1 << (x & 7)); |
| } |
| p++; |
| } |
| } |
| } |
| |
| if (!clipTight) { |
| ypn = m.scanLine(0); |
| ypc = 0; |
| for (y = 0; y < h; y++) { |
| ypp = ypc; |
| ypc = ypn; |
| ypn = (y == h-1) ? 0 : m.scanLine(y+1); |
| QRgb *p = (QRgb *)scanLine(y); |
| for (x = 0; x < w; x++) { |
| if ((*p & 0x00ffffff) != background) { |
| if (x > 0) |
| *(ypc + ((x-1) >> 3)) |= (1 << ((x-1) & 7)); |
| if (x < w-1) |
| *(ypc + ((x+1) >> 3)) |= (1 << ((x+1) & 7)); |
| if (y > 0) |
| *(ypp + (x >> 3)) |= (1 << (x & 7)); |
| if (y < h-1) |
| *(ypn + (x >> 3)) |= (1 << (x & 7)); |
| } |
| p++; |
| } |
| } |
| } |
| |
| #undef PIX |
| |
| return m; |
| } |
| #endif //QT_NO_IMAGE_HEURISTIC_MASK |
| |
| /*! |
| Creates and returns a mask for this image based on the given \a |
| color value. If the \a mode is MaskInColor (the default value), |
| all pixels matching \a color will be opaque pixels in the mask. If |
| \a mode is MaskOutColor, all pixels matching the given color will |
| be transparent. |
| |
| \sa createAlphaMask(), createHeuristicMask() |
| */ |
| |
| QImage QImage::createMaskFromColor(QRgb color, Qt::MaskMode mode) const |
| { |
| if (!d) |
| return QImage(); |
| QImage maskImage(size(), QImage::Format_MonoLSB); |
| QIMAGE_SANITYCHECK_MEMORY(maskImage); |
| maskImage.fill(0); |
| uchar *s = maskImage.bits(); |
| |
| if (depth() == 32) { |
| for (int h = 0; h < d->height; h++) { |
| const uint *sl = (uint *) scanLine(h); |
| for (int w = 0; w < d->width; w++) { |
| if (sl[w] == color) |
| *(s + (w >> 3)) |= (1 << (w & 7)); |
| } |
| s += maskImage.bytesPerLine(); |
| } |
| } else { |
| for (int h = 0; h < d->height; h++) { |
| for (int w = 0; w < d->width; w++) { |
| if ((uint) pixel(w, h) == color) |
| *(s + (w >> 3)) |= (1 << (w & 7)); |
| } |
| s += maskImage.bytesPerLine(); |
| } |
| } |
| if (mode == Qt::MaskOutColor) |
| maskImage.invertPixels(); |
| return maskImage; |
| } |
| |
| |
| /* |
| This code is contributed by Philipp Lang, |
| GeneriCom Software Germany (www.generi.com) |
| under the terms of the QPL, Version 1.0 |
| */ |
| |
| /*! |
| \fn QImage QImage::mirror(bool horizontal, bool vertical) const |
| |
| Use mirrored() instead. |
| */ |
| |
| /*! |
| Returns a mirror of the image, mirrored in the horizontal and/or |
| the vertical direction depending on whether \a horizontal and \a |
| vertical are set to true or false. |
| |
| Note that the original image is not changed. |
| |
| \sa {QImage#Image Transformations}{Image Transformations} |
| */ |
| QImage QImage::mirrored(bool horizontal, bool vertical) const |
| { |
| if (!d) |
| return QImage(); |
| |
| if ((d->width <= 1 && d->height <= 1) || (!horizontal && !vertical)) |
| return *this; |
| |
| int w = d->width; |
| int h = d->height; |
| // Create result image, copy colormap |
| QImage result(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(result); |
| |
| // check if we ran out of of memory.. |
| if (!result.d) |
| return QImage(); |
| |
| result.d->colortable = d->colortable; |
| result.d->has_alpha_clut = d->has_alpha_clut; |
| |
| if (depth() == 1) |
| w = (w+7)/8; |
| int dxi = horizontal ? -1 : 1; |
| int dxs = horizontal ? w-1 : 0; |
| int dyi = vertical ? -1 : 1; |
| int dy = vertical ? h-1: 0; |
| |
| // 1 bit, 8 bit |
| if (d->depth == 1 || d->depth == 8) { |
| for (int sy = 0; sy < h; sy++, dy += dyi) { |
| quint8* ssl = (quint8*)(d->data + sy*d->bytes_per_line); |
| quint8* dsl = (quint8*)(result.d->data + dy*result.d->bytes_per_line); |
| int dx = dxs; |
| for (int sx = 0; sx < w; sx++, dx += dxi) |
| dsl[dx] = ssl[sx]; |
| } |
| } |
| // 16 bit |
| else if (d->depth == 16) { |
| for (int sy = 0; sy < h; sy++, dy += dyi) { |
| quint16* ssl = (quint16*)(d->data + sy*d->bytes_per_line); |
| quint16* dsl = (quint16*)(result.d->data + dy*result.d->bytes_per_line); |
| int dx = dxs; |
| for (int sx = 0; sx < w; sx++, dx += dxi) |
| dsl[dx] = ssl[sx]; |
| } |
| } |
| // 24 bit |
| else if (d->depth == 24) { |
| for (int sy = 0; sy < h; sy++, dy += dyi) { |
| quint24* ssl = (quint24*)(d->data + sy*d->bytes_per_line); |
| quint24* dsl = (quint24*)(result.d->data + dy*result.d->bytes_per_line); |
| int dx = dxs; |
| for (int sx = 0; sx < w; sx++, dx += dxi) |
| dsl[dx] = ssl[sx]; |
| } |
| } |
| // 32 bit |
| else if (d->depth == 32) { |
| for (int sy = 0; sy < h; sy++, dy += dyi) { |
| quint32* ssl = (quint32*)(d->data + sy*d->bytes_per_line); |
| quint32* dsl = (quint32*)(result.d->data + dy*result.d->bytes_per_line); |
| int dx = dxs; |
| for (int sx = 0; sx < w; sx++, dx += dxi) |
| dsl[dx] = ssl[sx]; |
| } |
| } |
| |
| // special handling of 1 bit images for horizontal mirroring |
| if (horizontal && d->depth == 1) { |
| int shift = width() % 8; |
| for (int y = h-1; y >= 0; y--) { |
| quint8* a0 = (quint8*)(result.d->data + y*d->bytes_per_line); |
| // Swap bytes |
| quint8* a = a0+dxs; |
| while (a >= a0) { |
| *a = bitflip[*a]; |
| a--; |
| } |
| // Shift bits if unaligned |
| if (shift != 0) { |
| a = a0+dxs; |
| quint8 c = 0; |
| if (format() == Format_MonoLSB) { |
| while (a >= a0) { |
| quint8 nc = *a << shift; |
| *a = (*a >> (8-shift)) | c; |
| --a; |
| c = nc; |
| } |
| } else { |
| while (a >= a0) { |
| quint8 nc = *a >> shift; |
| *a = (*a << (8-shift)) | c; |
| --a; |
| c = nc; |
| } |
| } |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /*! |
| \fn QImage QImage::swapRGB() const |
| |
| Use rgbSwapped() instead. |
| |
| \omit |
| Returns a QImage in which the values of the red and blue |
| components of all pixels have been swapped, effectively converting |
| an RGB image to an BGR image. The original QImage is not changed. |
| \endomit |
| */ |
| |
| /*! |
| Returns a QImage in which the values of the red and blue |
| components of all pixels have been swapped, effectively converting |
| an RGB image to an BGR image. |
| |
| The original QImage is not changed. |
| |
| \sa {QImage#Image Transformations}{Image Transformations} |
| */ |
| QImage QImage::rgbSwapped() const |
| { |
| if (isNull()) |
| return *this; |
| QImage res; |
| switch (d->format) { |
| case Format_Invalid: |
| case NImageFormats: |
| Q_ASSERT(false); |
| break; |
| case Format_Mono: |
| case Format_MonoLSB: |
| case Format_Indexed8: |
| res = copy(); |
| for (int i = 0; i < res.d->colortable.size(); i++) { |
| QRgb c = res.d->colortable.at(i); |
| res.d->colortable[i] = QRgb(((c << 16) & 0xff0000) | ((c >> 16) & 0xff) | (c & 0xff00ff00)); |
| } |
| break; |
| case Format_RGB32: |
| case Format_ARGB32: |
| case Format_ARGB32_Premultiplied: |
| res = QImage(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(res); |
| for (int i = 0; i < d->height; i++) { |
| uint *q = (uint*)res.scanLine(i); |
| uint *p = (uint*)constScanLine(i); |
| uint *end = p + d->width; |
| while (p < end) { |
| *q = ((*p << 16) & 0xff0000) | ((*p >> 16) & 0xff) | (*p & 0xff00ff00); |
| p++; |
| q++; |
| } |
| } |
| break; |
| case Format_RGB16: |
| res = QImage(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(res); |
| for (int i = 0; i < d->height; i++) { |
| ushort *q = (ushort*)res.scanLine(i); |
| const ushort *p = (const ushort*)constScanLine(i); |
| const ushort *end = p + d->width; |
| while (p < end) { |
| *q = ((*p << 11) & 0xf800) | ((*p >> 11) & 0x1f) | (*p & 0x07e0); |
| p++; |
| q++; |
| } |
| } |
| break; |
| case Format_ARGB8565_Premultiplied: |
| res = QImage(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(res); |
| for (int i = 0; i < d->height; i++) { |
| const quint8 *p = constScanLine(i); |
| quint8 *q = res.scanLine(i); |
| const quint8 *end = p + d->width * sizeof(qargb8565); |
| while (p < end) { |
| q[0] = p[0]; |
| q[1] = (p[1] & 0xe0) | (p[2] >> 3); |
| q[2] = (p[2] & 0x07) | (p[1] << 3); |
| p += sizeof(qargb8565); |
| q += sizeof(qargb8565); |
| } |
| } |
| break; |
| case Format_RGB666: |
| res = QImage(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(res); |
| for (int i = 0; i < d->height; i++) { |
| qrgb666 *q = reinterpret_cast<qrgb666*>(res.scanLine(i)); |
| const qrgb666 *p = reinterpret_cast<const qrgb666*>(constScanLine(i)); |
| const qrgb666 *end = p + d->width; |
| while (p < end) { |
| const QRgb rgb = quint32(*p++); |
| *q++ = qRgb(qBlue(rgb), qGreen(rgb), qRed(rgb)); |
| } |
| } |
| break; |
| case Format_ARGB6666_Premultiplied: |
| res = QImage(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(res); |
| for (int i = 0; i < d->height; i++) { |
| const quint8 *p = constScanLine(i); |
| const quint8 *end = p + d->width * sizeof(qargb6666); |
| quint8 *q = res.scanLine(i); |
| while (p < end) { |
| q[0] = (p[1] >> 4) | ((p[2] & 0x3) << 4) | (p[0] & 0xc0); |
| q[1] = (p[1] & 0xf) | (p[0] << 4); |
| q[2] = (p[2] & 0xfc) | ((p[0] >> 4) & 0x3); |
| p += sizeof(qargb6666); |
| q += sizeof(qargb6666); |
| } |
| } |
| break; |
| case Format_RGB555: |
| res = QImage(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(res); |
| for (int i = 0; i < d->height; i++) { |
| quint16 *q = (quint16*)res.scanLine(i); |
| const quint16 *p = (const quint16*)constScanLine(i); |
| const quint16 *end = p + d->width; |
| while (p < end) { |
| *q = ((*p << 10) & 0x7c00) | ((*p >> 10) & 0x1f) | (*p & 0x3e0); |
| p++; |
| q++; |
| } |
| } |
| break; |
| case Format_ARGB8555_Premultiplied: |
| res = QImage(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(res); |
| for (int i = 0; i < d->height; i++) { |
| const quint8 *p = constScanLine(i); |
| quint8 *q = res.scanLine(i); |
| const quint8 *end = p + d->width * sizeof(qargb8555); |
| while (p < end) { |
| q[0] = p[0]; |
| q[1] = (p[1] & 0xe0) | (p[2] >> 2); |
| q[2] = (p[2] & 0x03) | ((p[1] << 2) & 0x7f); |
| p += sizeof(qargb8555); |
| q += sizeof(qargb8555); |
| } |
| } |
| break; |
| case Format_RGB888: |
| res = QImage(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(res); |
| for (int i = 0; i < d->height; i++) { |
| quint8 *q = res.scanLine(i); |
| const quint8 *p = constScanLine(i); |
| const quint8 *end = p + d->width * sizeof(qrgb888); |
| while (p < end) { |
| q[0] = p[2]; |
| q[1] = p[1]; |
| q[2] = p[0]; |
| q += sizeof(qrgb888); |
| p += sizeof(qrgb888); |
| } |
| } |
| break; |
| case Format_RGB444: |
| case Format_ARGB4444_Premultiplied: |
| res = QImage(d->width, d->height, d->format); |
| QIMAGE_SANITYCHECK_MEMORY(res); |
| for (int i = 0; i < d->height; i++) { |
| quint16 *q = reinterpret_cast<quint16*>(res.scanLine(i)); |
| const quint16 *p = reinterpret_cast<const quint16*>(constScanLine(i)); |
| const quint16 *end = p + d->width; |
| while (p < end) { |
| *q = (*p & 0xf0f0) | ((*p & 0x0f) << 8) | ((*p & 0xf00) >> 8); |
| p++; |
| q++; |
| } |
| } |
| break; |
| } |
| return res; |
| } |
| |
| /*! |
| Loads an image from the file with the given \a fileName. Returns true if |
| the image was successfully loaded; otherwise returns false. |
| |
| The loader attempts to read the image using the specified \a format, e.g., |
| PNG or JPG. If \a format is not specified (which is the default), the |
| loader probes the file for a header to guess the file format. |
| |
| The file name can either refer to an actual file on disk or to one |
| of the application's embedded resources. See the |
| \l{resources.html}{Resource System} overview for details on how to |
| embed images and other resource files in the application's |
| executable. |
| |
| \sa {QImage#Reading and Writing Image Files}{Reading and Writing Image Files} |
| */ |
| |
| bool QImage::load(const QString &fileName, const char* format) |
| { |
| if (fileName.isEmpty()) |
| return false; |
| |
| QImage image = QImageReader(fileName, format).read(); |
| if (!image.isNull()) { |
| operator=(image); |
| return true; |
| } |
| return false; |
| } |
| |
| /*! |
| \overload |
| |
| This function reads a QImage from the given \a device. This can, |
| for example, be used to load an image directly into a QByteArray. |
| */ |
| |
| bool QImage::load(QIODevice* device, const char* format) |
| { |
| QImage image = QImageReader(device, format).read(); |
| if(!image.isNull()) { |
| operator=(image); |
| return true; |
| } |
| return false; |
| } |
| |
| /*! |
| \fn bool QImage::loadFromData(const uchar *data, int len, const char *format) |
| |
| Loads an image from the first \a len bytes of the given binary \a |
| data. Returns true if the image was successfully loaded; otherwise |
| returns false. |
| |
| The loader attempts to read the image using the specified \a format, e.g., |
| PNG or JPG. If \a format is not specified (which is the default), the |
| loader probes the file for a header to guess the file format. |
| |
| \sa {QImage#Reading and Writing Image Files}{Reading and Writing Image Files} |
| */ |
| |
| bool QImage::loadFromData(const uchar *data, int len, const char *format) |
| { |
| QImage image = fromData(data, len, format); |
| if (!image.isNull()) { |
| operator=(image); |
| return true; |
| } |
| return false; |
| } |
| |
| /*! |
| \fn bool QImage::loadFromData(const QByteArray &data, const char *format) |
| |
| \overload |
| |
| Loads an image from the given QByteArray \a data. |
| */ |
| |
| /*! |
| \fn QImage QImage::fromData(const uchar *data, int size, const char *format) |
| |
| Constructs a QImage from the first \a size bytes of the given |
| binary \a data. The loader attempts to read the image using the |
| specified \a format. If \a format is not specified (which is the default), |
| the loader probes the file for a header to guess the file format. |
| binary \a data. The loader attempts to read the image, either using the |
| optional image \a format specified or by determining the image format from |
| the data. |
| |
| If \a format is not specified (which is the default), the loader probes the |
| file for a header to determine the file format. If \a format is specified, |
| it must be one of the values returned by QImageReader::supportedImageFormats(). |
| |
| If the loading of the image fails, the image returned will be a null image. |
| |
| \sa load(), save(), {QImage#Reading and Writing Image Files}{Reading and Writing Image Files} |
| */ |
| |
| QImage QImage::fromData(const uchar *data, int size, const char *format) |
| { |
| QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(data), size); |
| QBuffer b; |
| b.setData(a); |
| b.open(QIODevice::ReadOnly); |
| return QImageReader(&b, format).read(); |
| } |
| |
| /*! |
| \fn QImage QImage::fromData(const QByteArray &data, const char *format) |
| |
| \overload |
| |
| Loads an image from the given QByteArray \a data. |
| */ |
| |
| /*! |
| Saves the image to the file with the given \a fileName, using the |
| given image file \a format and \a quality factor. If \a format is |
| 0, QImage will attempt to guess the format by looking at \a fileName's |
| suffix. |
| |
| The \a quality factor must be in the range 0 to 100 or -1. Specify |
| 0 to obtain small compressed files, 100 for large uncompressed |
| files, and -1 (the default) to use the default settings. |
| |
| Returns true if the image was successfully saved; otherwise |
| returns false. |
| |
| \sa {QImage#Reading and Writing Image Files}{Reading and Writing |
| Image Files} |
| */ |
| bool QImage::save(const QString &fileName, const char *format, int quality) const |
| { |
| if (isNull()) |
| return false; |
| QImageWriter writer(fileName, format); |
| return d->doImageIO(this, &writer, quality); |
| } |
| |
| /*! |
| \overload |
| |
| This function writes a QImage to the given \a device. |
| |
| This can, for example, be used to save an image directly into a |
| QByteArray: |
| |
| \snippet doc/src/snippets/image/image.cpp 0 |
| */ |
| |
| bool QImage::save(QIODevice* device, const char* format, int quality) const |
| { |
| if (isNull()) |
| return false; // nothing to save |
| QImageWriter writer(device, format); |
| return d->doImageIO(this, &writer, quality); |
| } |
| |
| /* \internal |
| */ |
| |
| bool QImageData::doImageIO(const QImage *image, QImageWriter *writer, int quality) const |
| { |
| if (quality > 100 || quality < -1) |
| qWarning("QPixmap::save: Quality out of range [-1, 100]"); |
| if (quality >= 0) |
| writer->setQuality(qMin(quality,100)); |
| return writer->write(*image); |
| } |
| |
| /***************************************************************************** |
| QImage stream functions |
| *****************************************************************************/ |
| #if !defined(QT_NO_DATASTREAM) |
| /*! |
| \fn QDataStream &operator<<(QDataStream &stream, const QImage &image) |
| \relates QImage |
| |
| Writes the given \a image to the given \a stream as a PNG image, |
| or as a BMP image if the stream's version is 1. Note that writing |
| the stream to a file will not produce a valid image file. |
| |
| \sa QImage::save(), {Serializing Qt Data Types} |
| */ |
| |
| QDataStream &operator<<(QDataStream &s, const QImage &image) |
| { |
| 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; |
| } |
| |
| /*! |
| \fn QDataStream &operator>>(QDataStream &stream, QImage &image) |
| \relates QImage |
| |
| Reads an image from the given \a stream and stores it in the given |
| \a image. |
| |
| \sa QImage::load(), {Serializing Qt Data Types} |
| */ |
| |
| QDataStream &operator>>(QDataStream &s, QImage &image) |
| { |
| if (s.version() >= 5) { |
| qint32 nullMarker; |
| s >> nullMarker; |
| if (!nullMarker) { |
| image = QImage(); // null image |
| return s; |
| } |
| } |
| image = QImageReader(s.device(), 0).read(); |
| return s; |
| } |
| #endif // QT_NO_DATASTREAM |
| |
| |
| #ifdef QT3_SUPPORT |
| /*! |
| \fn QImage QImage::convertDepthWithPalette(int depth, QRgb* palette, int palette_count, Qt::ImageConversionFlags flags) const |
| |
| Returns an image with the given \a depth, using the \a |
| palette_count colors pointed to by \a palette. If \a depth is 1 or |
| 8, the returned image will have its color table ordered in the |
| same way as \a palette. |
| |
| If the image needs to be modified to fit in a lower-resolution |
| result (e.g. converting from 32-bit to 8-bit), use the \a flags to |
| specify how you'd prefer this to happen. |
| |
| Note: currently no closest-color search is made. If colors are |
| found that are not in the palette, the palette may not be used at |
| all. This result should not be considered valid because it may |
| change in future implementations. |
| |
| Currently inefficient for non-32-bit images. |
| |
| Use the convertToFormat() function in combination with the |
| setColorTable() function instead. |
| */ |
| QImage QImage::convertDepthWithPalette(int d, QRgb* palette, int palette_count, Qt::ImageConversionFlags flags) const |
| { |
| Format f = formatFor(d, QImage::LittleEndian); |
| QVector<QRgb> colortable; |
| for (int i = 0; i < palette_count; ++i) |
| colortable.append(palette[i]); |
| return convertToFormat(f, colortable, flags); |
| } |
| |
| /*! |
| \relates QImage |
| |
| Copies a block of pixels from \a src to \a dst. The pixels |
| copied from source (src) are converted according to |
| \a flags if it is incompatible with the destination |
| (\a dst). |
| |
| \a sx, \a sy is the top-left pixel in \a src, \a dx, \a dy is the |
| top-left position in \a dst and \a sw, \a sh is the size of the |
| copied block. The copying is clipped if areas outside \a src or \a |
| dst are specified. If \a sw is -1, it is adjusted to |
| src->width(). Similarly, if \a sh is -1, it is adjusted to |
| src->height(). |
| |
| Currently inefficient for non 32-bit images. |
| |
| Use copy() or QPainter::drawImage() instead. |
| */ |
| void bitBlt(QImage *dst, int dx, int dy, const QImage *src, int sx, int sy, int sw, int sh, |
| Qt::ImageConversionFlags flags) |
| { |
| if (dst->isNull() || src->isNull()) |
| return; |
| QPainter p(dst); |
| p.drawImage(QPoint(dx, dy), *src, QRect(sx, sy, sw, sh), flags); |
| } |
| #endif |
| |
| /*! |
| \fn bool QImage::operator==(const QImage & image) const |
| |
| Returns true if this image and the given \a image have the same |
| contents; otherwise returns false. |
| |
| The comparison can be slow, unless there is some obvious |
| difference (e.g. different size or format), in which case the |
| function will return quickly. |
| |
| \sa operator=() |
| */ |
| |
| bool QImage::operator==(const QImage & i) const |
| { |
| // same object, or shared? |
| if (i.d == d) |
| return true; |
| if (!i.d || !d) |
| return false; |
| |
| // obviously different stuff? |
| if (i.d->height != d->height || i.d->width != d->width || i.d->format != d->format) |
| return false; |
| |
| if (d->format != Format_RGB32) { |
| if (d->format >= Format_ARGB32) { // all bits defined |
| const int n = d->width * d->depth / 8; |
| if (n == d->bytes_per_line && n == i.d->bytes_per_line) { |
| if (memcmp(bits(), i.bits(), d->nbytes)) |
| return false; |
| } else { |
| for (int y = 0; y < d->height; ++y) { |
| if (memcmp(scanLine(y), i.scanLine(y), n)) |
| return false; |
| } |
| } |
| } else { |
| const int w = width(); |
| const int h = height(); |
| const QVector<QRgb> &colortable = d->colortable; |
| const QVector<QRgb> &icolortable = i.d->colortable; |
| for (int y=0; y<h; ++y) { |
| for (int x=0; x<w; ++x) { |
| if (colortable[pixelIndex(x, y)] != icolortable[i.pixelIndex(x, y)]) |
| return false; |
| } |
| } |
| } |
| } else { |
| //alpha channel undefined, so we must mask it out |
| for(int l = 0; l < d->height; l++) { |
| int w = d->width; |
| const uint *p1 = reinterpret_cast<const uint*>(scanLine(l)); |
| const uint *p2 = reinterpret_cast<const uint*>(i.scanLine(l)); |
| while (w--) { |
| if ((*p1++ & 0x00ffffff) != (*p2++ & 0x00ffffff)) |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| |
| /*! |
| \fn bool QImage::operator!=(const QImage & image) const |
| |
| Returns true if this image and the given \a image have different |
| contents; otherwise returns false. |
| |
| The comparison can be slow, unless there is some obvious |
| difference, such as different widths, in which case the function |
| will return quickly. |
| |
| \sa operator=() |
| */ |
| |
| bool QImage::operator!=(const QImage & i) const |
| { |
| return !(*this == i); |
| } |
| |
| |
| |
| |
| /*! |
| Returns the number of pixels that fit horizontally in a physical |
| meter. Together with dotsPerMeterY(), this number defines the |
| intended scale and aspect ratio of the image. |
| |
| \sa setDotsPerMeterX(), {QImage#Image Information}{Image |
| Information} |
| */ |
| int QImage::dotsPerMeterX() const |
| { |
| return d ? qRound(d->dpmx) : 0; |
| } |
| |
| /*! |
| Returns the number of pixels that fit vertically in a physical |
| meter. Together with dotsPerMeterX(), this number defines the |
| intended scale and aspect ratio of the image. |
| |
| \sa setDotsPerMeterY(), {QImage#Image Information}{Image |
| Information} |
| */ |
| int QImage::dotsPerMeterY() const |
| { |
| return d ? qRound(d->dpmy) : 0; |
| } |
| |
| /*! |
| Sets the number of pixels that fit horizontally in a physical |
| meter, to \a x. |
| |
| Together with dotsPerMeterY(), this number defines the intended |
| scale and aspect ratio of the image, and determines the scale |
| at which QPainter will draw graphics on the image. It does not |
| change the scale or aspect ratio of the image when it is rendered |
| on other paint devices. |
| |
| \sa dotsPerMeterX(), {QImage#Image Information}{Image Information} |
| */ |
| void QImage::setDotsPerMeterX(int x) |
| { |
| if (!d || !x) |
| return; |
| detach(); |
| |
| if (d) |
| d->dpmx = x; |
| } |
| |
| /*! |
| Sets the number of pixels that fit vertically in a physical meter, |
| to \a y. |
| |
| Together with dotsPerMeterX(), this number defines the intended |
| scale and aspect ratio of the image, and determines the scale |
| at which QPainter will draw graphics on the image. It does not |
| change the scale or aspect ratio of the image when it is rendered |
| on other paint devices. |
| |
| \sa dotsPerMeterY(), {QImage#Image Information}{Image Information} |
| */ |
| void QImage::setDotsPerMeterY(int y) |
| { |
| if (!d || !y) |
| return; |
| detach(); |
| |
| if (d) |
| d->dpmy = y; |
| } |
| |
| /*! |
| \fn QPoint QImage::offset() const |
| |
| Returns the number of pixels by which the image is intended to be |
| offset by when positioning relative to other images. |
| |
| \sa setOffset(), {QImage#Image Information}{Image Information} |
| */ |
| QPoint QImage::offset() const |
| { |
| return d ? d->offset : QPoint(); |
| } |
| |
| |
| /*! |
| \fn void QImage::setOffset(const QPoint& offset) |
| |
| Sets the number of pixels by which the image is intended to be |
| offset by when positioning relative to other images, to \a offset. |
| |
| \sa offset(), {QImage#Image Information}{Image Information} |
| */ |
| void QImage::setOffset(const QPoint& p) |
| { |
| if (!d) |
| return; |
| detach(); |
| |
| if (d) |
| d->offset = p; |
| } |
| #ifndef QT_NO_IMAGE_TEXT |
| |
| /*! |
| Returns the text keys for this image. |
| |
| You can use these keys with text() to list the image text for a |
| certain key. |
| |
| \sa text() |
| */ |
| QStringList QImage::textKeys() const |
| { |
| return d ? QStringList(d->text.keys()) : QStringList(); |
| } |
| |
| /*! |
| Returns the image text associated with the given \a key. If the |
| specified \a key is an empty string, the whole image text is |
| returned, with each key-text pair separated by a newline. |
| |
| \sa setText(), textKeys() |
| */ |
| QString QImage::text(const QString &key) const |
| { |
| if (!d) |
| return QString(); |
| |
| if (!key.isEmpty()) |
| return d->text.value(key); |
| |
| QString tmp; |
| foreach (const QString &key, d->text.keys()) { |
| if (!tmp.isEmpty()) |
| tmp += QLatin1String("\n\n"); |
| tmp += key + QLatin1String(": ") + d->text.value(key).simplified(); |
| } |
| return tmp; |
| } |
| |
| /*! |
| \fn void QImage::setText(const QString &key, const QString &text) |
| |
| Sets the image text to the given \a text and associate it with the |
| given \a key. |
| |
| If you just want to store a single text block (i.e., a "comment" |
| or just a description), you can either pass an empty key, or use a |
| generic key like "Description". |
| |
| The image text is embedded into the image data when you |
| call save() or QImageWriter::write(). |
| |
| Not all image formats support embedded text. You can find out |
| if a specific image or format supports embedding text |
| by using QImageWriter::supportsOption(). We give an example: |
| |
| \snippet doc/src/snippets/image/supportedformat.cpp 0 |
| |
| You can use QImageWriter::supportedImageFormats() to find out |
| which image formats are available to you. |
| |
| \sa text(), textKeys() |
| */ |
| void QImage::setText(const QString &key, const QString &value) |
| { |
| if (!d) |
| return; |
| detach(); |
| |
| if (d) |
| d->text.insert(key, value); |
| } |
| |
| /*! |
| \fn QString QImage::text(const char* key, const char* language) const |
| \obsolete |
| |
| Returns the text recorded for the given \a key in the given \a |
| language, or in a default language if \a language is 0. |
| |
| Use text() instead. |
| |
| The language the text is recorded in is no longer relevant since |
| the text is always set using QString and UTF-8 representation. |
| */ |
| QString QImage::text(const char* key, const char* lang) const |
| { |
| if (!d) |
| return QString(); |
| QString k = QString::fromAscii(key); |
| if (lang && *lang) |
| k += QLatin1Char('/') + QString::fromAscii(lang); |
| return d->text.value(k); |
| } |
| |
| /*! |
| \fn QString QImage::text(const QImageTextKeyLang& keywordAndLanguage) const |
| \overload |
| \obsolete |
| |
| Returns the text recorded for the given \a keywordAndLanguage. |
| |
| Use text() instead. |
| |
| The language the text is recorded in is no longer relevant since |
| the text is always set using QString and UTF-8 representation. |
| */ |
| QString QImage::text(const QImageTextKeyLang& kl) const |
| { |
| if (!d) |
| return QString(); |
| QString k = QString::fromAscii(kl.key); |
| if (!kl.lang.isEmpty()) |
| k += QLatin1Char('/') + QString::fromAscii(kl.lang); |
| return d->text.value(k); |
| } |
| |
| /*! |
| \obsolete |
| |
| Returns the language identifiers for which some texts are |
| recorded. Note that if you want to iterate over the list, you |
| should iterate over a copy. |
| |
| The language the text is recorded in is no longer relevant since |
| the text is always set using QString and UTF-8 representation. |
| */ |
| QStringList QImage::textLanguages() const |
| { |
| if (!d) |
| return QStringList(); |
| QStringList keys = textKeys(); |
| QStringList languages; |
| for (int i = 0; i < keys.size(); ++i) { |
| int index = keys.at(i).indexOf(QLatin1Char('/')); |
| if (index > 0) |
| languages += keys.at(i).mid(index+1); |
| } |
| |
| return languages; |
| } |
| |
| /*! |
| \obsolete |
| |
| Returns a list of QImageTextKeyLang objects that enumerate all the |
| texts key/language pairs set for this image. |
| |
| Use textKeys() instead. |
| |
| The language the text is recorded in is no longer relevant since |
| the text is always set using QString and UTF-8 representation. |
| */ |
| QList<QImageTextKeyLang> QImage::textList() const |
| { |
| QList<QImageTextKeyLang> imageTextKeys; |
| if (!d) |
| return imageTextKeys; |
| QStringList keys = textKeys(); |
| for (int i = 0; i < keys.size(); ++i) { |
| int index = keys.at(i).indexOf(QLatin1Char('/')); |
| if (index > 0) { |
| QImageTextKeyLang tkl; |
| tkl.key = keys.at(i).left(index).toAscii(); |
| tkl.lang = keys.at(i).mid(index+1).toAscii(); |
| imageTextKeys += tkl; |
| } |
| } |
| |
| return imageTextKeys; |
| } |
| |
| /*! |
| \fn void QImage::setText(const char* key, const char* language, const QString& text) |
| \obsolete |
| |
| Sets the image text to the given \a text and associate it with the |
| given \a key. The text is recorded in the specified \a language, |
| or in a default language if \a language is 0. |
| |
| Use setText() instead. |
| |
| The language the text is recorded in is no longer relevant since |
| the text is always set using QString and UTF-8 representation. |
| |
| \omit |
| Records string \a for the keyword \a key. The \a key should be |
| a portable keyword recognizable by other software - some suggested |
| values can be found in |
| \l{http://www.libpng.org/pub/png/spec/1.2/png-1.2-pdg.html#C.Anc-text} |
| {the PNG specification}. \a s can be any text. \a lang should |
| specify the language code (see |
| \l{http://www.rfc-editor.org/rfc/rfc1766.txt}{RFC 1766}) or 0. |
| \endomit |
| */ |
| void QImage::setText(const char* key, const char* lang, const QString& s) |
| { |
| if (!d) |
| return; |
| detach(); |
| |
| // In case detach() ran out of memory |
| if (!d) |
| return; |
| |
| QString k = QString::fromAscii(key); |
| if (lang && *lang) |
| k += QLatin1Char('/') + QString::fromAscii(lang); |
| d->text.insert(k, s); |
| } |
| |
| #endif // QT_NO_IMAGE_TEXT |
| |
| /* |
| Sets the image bits to the \a pixmap contents and returns a |
| reference to the image. |
| |
| If the image shares data with other images, it will first |
| dereference the shared data. |
| |
| Makes a call to QPixmap::convertToImage(). |
| */ |
| |
| /*! \fn QImage::Endian QImage::systemBitOrder() |
| |
| Determines the bit order of the display hardware. Returns |
| QImage::LittleEndian (LSB first) or QImage::BigEndian (MSB first). |
| |
| This function is no longer relevant for QImage. Use QSysInfo |
| instead. |
| */ |
| |
| |
| /*! |
| \internal |
| |
| Used by QPainter to retrieve a paint engine for the image. |
| */ |
| |
| QPaintEngine *QImage::paintEngine() const |
| { |
| if (!d) |
| return 0; |
| |
| if (!d->paintEngine) { |
| #ifdef Q_OS_SYMBIAN |
| d->paintEngine = new QSymbianRasterPaintEngine(const_cast<QImage *>(this)); |
| #else |
| d->paintEngine = new QRasterPaintEngine(const_cast<QImage *>(this)); |
| #endif |
| } |
| |
| return d->paintEngine; |
| } |
| |
| |
| /*! |
| \internal |
| |
| Returns the size for the specified \a metric on the device. |
| */ |
| int QImage::metric(PaintDeviceMetric metric) const |
| { |
| if (!d) |
| return 0; |
| |
| switch (metric) { |
| case PdmWidth: |
| return d->width; |
| break; |
| |
| case PdmHeight: |
| return d->height; |
| break; |
| |
| case PdmWidthMM: |
| return qRound(d->width * 1000 / d->dpmx); |
| break; |
| |
| case PdmHeightMM: |
| return qRound(d->height * 1000 / d->dpmy); |
| break; |
| |
| case PdmNumColors: |
| return d->colortable.size(); |
| break; |
| |
| case PdmDepth: |
| return d->depth; |
| break; |
| |
| case PdmDpiX: |
| return qRound(d->dpmx * 0.0254); |
| break; |
| |
| case PdmDpiY: |
| return qRound(d->dpmy * 0.0254); |
| break; |
| |
| case PdmPhysicalDpiX: |
| return qRound(d->dpmx * 0.0254); |
| break; |
| |
| case PdmPhysicalDpiY: |
| return qRound(d->dpmy * 0.0254); |
| break; |
| |
| default: |
| qWarning("QImage::metric(): Unhandled metric type %d", metric); |
| break; |
| } |
| return 0; |
| } |
| |
| |
| |
| /***************************************************************************** |
| QPixmap (and QImage) helper functions |
| *****************************************************************************/ |
| /* |
| This internal function contains the common (i.e. platform independent) code |
| to do a transformation of pixel data. It is used by QPixmap::transform() and by |
| QImage::transform(). |
| |
| \a trueMat is the true transformation matrix (see QPixmap::trueMatrix()) and |
| \a xoffset is an offset to the matrix. |
| |
| \a msbfirst specifies for 1bpp images, if the MSB or LSB comes first and \a |
| depth specifies the colordepth of the data. |
| |
| \a dptr is a pointer to the destination data, \a dbpl specifies the bits per |
| line for the destination data, \a p_inc is the offset that we advance for |
| every scanline and \a dHeight is the height of the destination image. |
| |
| \a sprt is the pointer to the source data, \a sbpl specifies the bits per |
| line of the source data, \a sWidth and \a sHeight are the width and height of |
| the source data. |
| */ |
| |
| #undef IWX_MSB |
| #define IWX_MSB(b) if (trigx < maxws && trigy < maxhs) { \ |
| if (*(sptr+sbpl*(trigy>>12)+(trigx>>15)) & \ |
| (1 << (7-((trigx>>12)&7)))) \ |
| *dptr |= b; \ |
| } \ |
| trigx += m11; \ |
| trigy += m12; |
| // END OF MACRO |
| #undef IWX_LSB |
| #define IWX_LSB(b) if (trigx < maxws && trigy < maxhs) { \ |
| if (*(sptr+sbpl*(trigy>>12)+(trigx>>15)) & \ |
| (1 << ((trigx>>12)&7))) \ |
| *dptr |= b; \ |
| } \ |
| trigx += m11; \ |
| trigy += m12; |
| // END OF MACRO |
| #undef IWX_PIX |
| #define IWX_PIX(b) if (trigx < maxws && trigy < maxhs) { \ |
| if ((*(sptr+sbpl*(trigy>>12)+(trigx>>15)) & \ |
| (1 << (7-((trigx>>12)&7)))) == 0) \ |
| *dptr &= ~b; \ |
| } \ |
| trigx += m11; \ |
| trigy += m12; |
| // END OF MACRO |
| bool qt_xForm_helper(const QTransform &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) |
| { |
| int m11 = int(trueMat.m11()*4096.0); |
| int m12 = int(trueMat.m12()*4096.0); |
| int m21 = int(trueMat.m21()*4096.0); |
| int m22 = int(trueMat.m22()*4096.0); |
| int dx = qRound(trueMat.dx()*4096.0); |
| int dy = qRound(trueMat.dy()*4096.0); |
| |
| int m21ydx = dx + (xoffset<<16) + (m11 + m21) / 2; |
| int m22ydy = dy + (m12 + m22) / 2; |
| 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; |
| } |
| #undef IWX_MSB |
| #undef IWX_LSB |
| #undef IWX_PIX |
| |
| /*! |
| \fn QImage QImage::xForm(const QMatrix &matrix) const |
| |
| Use transformed() instead. |
| |
| \oldcode |
| QImage image; |
| ... |
| image.xForm(matrix); |
| \newcode |
| QImage image; |
| ... |
| image.transformed(matrix); |
| \endcode |
| */ |
| |
| /*! \obsolete |
| Returns a number that identifies the contents of this |
| QImage object. Distinct QImage objects can only have the same |
| serial number if they refer to the same contents (but they don't |
| have to). |
| |
| Use cacheKey() instead. |
| |
| \warning The serial number doesn't necessarily change when the |
| image is altered. This means that it may be dangerous to use |
| it as a cache key. |
| |
| \sa operator==() |
| */ |
| |
| int QImage::serialNumber() const |
| { |
| if (!d) |
| return 0; |
| else |
| return d->ser_no; |
| } |
| |
| /*! |
| Returns a number that identifies the contents of this QImage |
| object. Distinct QImage objects can only have the same key if they |
| refer to the same contents. |
| |
| The key will change when the image is altered. |
| */ |
| qint64 QImage::cacheKey() const |
| { |
| if (!d) |
| return 0; |
| else |
| return (((qint64) d->ser_no) << 32) | ((qint64) d->detach_no); |
| } |
| |
| /*! |
| \internal |
| |
| Returns true if the image is detached; otherwise returns false. |
| |
| \sa detach(), {Implicit Data Sharing} |
| */ |
| |
| bool QImage::isDetached() const |
| { |
| return d && d->ref == 1; |
| } |
| |
| |
| /*! |
| \obsolete |
| Sets the alpha channel of this image to the given \a alphaChannel. |
| |
| If \a alphaChannel is an 8 bit grayscale image, the intensity values are |
| written into this buffer directly. Otherwise, \a alphaChannel is converted |
| to 32 bit and the intensity of the RGB pixel values is used. |
| |
| Note that the image will be converted to the Format_ARGB32_Premultiplied |
| format if the function succeeds. |
| |
| Use one of the composition modes in QPainter::CompositionMode instead. |
| |
| \warning This function is expensive. |
| |
| \sa alphaChannel(), {QImage#Image Transformations}{Image |
| Transformations}, {QImage#Image Formats}{Image Formats} |
| */ |
| |
| void QImage::setAlphaChannel(const QImage &alphaChannel) |
| { |
| if (!d) |
| return; |
| |
| int w = d->width; |
| int h = d->height; |
| |
| if (w != alphaChannel.d->width || h != alphaChannel.d->height) { |
| qWarning("QImage::setAlphaChannel: " |
| "Alpha channel must have same dimensions as the target image"); |
| return; |
| } |
| |
| if (d->paintEngine && d->paintEngine->isActive()) { |
| qWarning("QImage::setAlphaChannel: " |
| "Unable to set alpha channel while image is being painted on"); |
| return; |
| } |
| |
| if (d->format == QImage::Format_ARGB32_Premultiplied) |
| detach(); |
| else |
| *this = convertToFormat(QImage::Format_ARGB32_Premultiplied); |
| |
| if (isNull()) |
| return; |
| |
| // Slight optimization since alphachannels are returned as 8-bit grays. |
| if (alphaChannel.d->depth == 8 && alphaChannel.isGrayscale()) { |
| const uchar *src_data = alphaChannel.d->data; |
| const uchar *dest_data = d->data; |
| for (int y=0; y<h; ++y) { |
| const uchar *src = src_data; |
| QRgb *dest = (QRgb *)dest_data; |
| for (int x=0; x<w; ++x) { |
| int alpha = *src; |
| int destAlpha = qt_div_255(alpha * qAlpha(*dest)); |
| *dest = ((destAlpha << 24) |
| | (qt_div_255(qRed(*dest) * alpha) << 16) |
| | (qt_div_255(qGreen(*dest) * alpha) << 8) |
| | (qt_div_255(qBlue(*dest) * alpha))); |
| ++dest; |
| ++src; |
| } |
| src_data += alphaChannel.d->bytes_per_line; |
| dest_data += d->bytes_per_line; |
| } |
| |
| } else { |
| const QImage sourceImage = alphaChannel.convertToFormat(QImage::Format_RGB32); |
| const uchar *src_data = sourceImage.d->data; |
| const uchar *dest_data = d->data; |
| for (int y=0; y<h; ++y) { |
| const QRgb *src = (const QRgb *) src_data; |
| QRgb *dest = (QRgb *) dest_data; |
| for (int x=0; x<w; ++x) { |
| int alpha = qGray(*src); |
| int destAlpha = qt_div_255(alpha * qAlpha(*dest)); |
| *dest = ((destAlpha << 24) |
| | (qt_div_255(qRed(*dest) * alpha) << 16) |
| | (qt_div_255(qGreen(*dest) * alpha) << 8) |
| | (qt_div_255(qBlue(*dest) * alpha))); |
| ++dest; |
| ++src; |
| } |
| src_data += sourceImage.d->bytes_per_line; |
| dest_data += d->bytes_per_line; |
| } |
| } |
| } |
| |
| |
| /*! |
| \obsolete |
| |
| Returns the alpha channel of the image as a new grayscale QImage in which |
| each pixel's red, green, and blue values are given the alpha value of the |
| original image. The color depth of the returned image is 8-bit. |
| |
| You can see an example of use of this function in QPixmap's |
| \l{QPixmap::}{alphaChannel()}, which works in the same way as |
| this function on QPixmaps. |
| |
| Most usecases for this function can be replaced with QPainter and |
| using composition modes. |
| |
| \warning This is an expensive function. |
| |
| \sa setAlphaChannel(), hasAlphaChannel(), |
| {QPixmap#Pixmap Information}{Pixmap}, |
| {QImage#Image Transformations}{Image Transformations} |
| */ |
| |
| QImage QImage::alphaChannel() const |
| { |
| if (!d) |
| return QImage(); |
| |
| int w = d->width; |
| int h = d->height; |
| |
| QImage image(w, h, Format_Indexed8); |
| image.setColorCount(256); |
| |
| // set up gray scale table. |
| for (int i=0; i<256; ++i) |
| image.setColor(i, qRgb(i, i, i)); |
| |
| if (!hasAlphaChannel()) { |
| image.fill(255); |
| return image; |
| } |
| |
| if (d->format == Format_Indexed8) { |
| const uchar *src_data = d->data; |
| uchar *dest_data = image.d->data; |
| for (int y=0; y<h; ++y) { |
| const uchar *src = src_data; |
| uchar *dest = dest_data; |
| for (int x=0; x<w; ++x) { |
| *dest = qAlpha(d->colortable.at(*src)); |
| ++dest; |
| ++src; |
| } |
| src_data += d->bytes_per_line; |
| dest_data += image.d->bytes_per_line; |
| } |
| } else { |
| QImage alpha32 = *this; |
| if (d->format != Format_ARGB32 && d->format != Format_ARGB32_Premultiplied) |
| alpha32 = convertToFormat(Format_ARGB32); |
| |
| const uchar *src_data = alpha32.d->data; |
| uchar *dest_data = image.d->data; |
| for (int y=0; y<h; ++y) { |
| const QRgb *src = (const QRgb *) src_data; |
| uchar *dest = dest_data; |
| for (int x=0; x<w; ++x) { |
| *dest = qAlpha(*src); |
| ++dest; |
| ++src; |
| } |
| src_data += alpha32.d->bytes_per_line; |
| dest_data += image.d->bytes_per_line; |
| } |
| } |
| |
| return image; |
| } |
| |
| /*! |
| Returns true if the image has a format that respects the alpha |
| channel, otherwise returns false. |
| |
| \sa {QImage#Image Information}{Image Information} |
| */ |
| bool QImage::hasAlphaChannel() const |
| { |
| return d && (d->format == Format_ARGB32_Premultiplied |
| || d->format == Format_ARGB32 |
| || d->format == Format_ARGB8565_Premultiplied |
| || d->format == Format_ARGB8555_Premultiplied |
| || d->format == Format_ARGB6666_Premultiplied |
| || d->format == Format_ARGB4444_Premultiplied |
| || (d->has_alpha_clut && (d->format == Format_Indexed8 |
| || d->format == Format_Mono |
| || d->format == Format_MonoLSB))); |
| } |
| |
| |
| /*! |
| \since 4.7 |
| Returns the number of bit planes in the image. |
| |
| The number of bit planes is the number of bits of color and |
| transparency information for each pixel. This is different from |
| (i.e. smaller than) the depth when the image format contains |
| unused bits. |
| |
| \sa depth(), format(), {QImage#Image Formats}{Image Formats} |
| */ |
| int QImage::bitPlaneCount() const |
| { |
| if (!d) |
| return 0; |
| int bpc = 0; |
| switch (d->format) { |
| case QImage::Format_Invalid: |
| break; |
| case QImage::Format_RGB32: |
| bpc = 24; |
| break; |
| case QImage::Format_RGB666: |
| bpc = 18; |
| break; |
| case QImage::Format_RGB555: |
| bpc = 15; |
| break; |
| case QImage::Format_ARGB8555_Premultiplied: |
| bpc = 23; |
| break; |
| case QImage::Format_RGB444: |
| bpc = 12; |
| break; |
| default: |
| bpc = depthForFormat(d->format); |
| break; |
| } |
| return bpc; |
| } |
| |
| |
| #ifdef QT3_SUPPORT |
| #if defined(Q_WS_X11) |
| QT_BEGIN_INCLUDE_NAMESPACE |
| #include <private/qt_x11_p.h> |
| QT_END_INCLUDE_NAMESPACE |
| #endif |
| |
| QImage::Endian QImage::systemBitOrder() |
| { |
| #if defined(Q_WS_X11) |
| return BitmapBitOrder(X11->display) == MSBFirst ? BigEndian : LittleEndian; |
| #else |
| return BigEndian; |
| #endif |
| } |
| #endif |
| |
| /*! |
| \fn QImage QImage::copy(const QRect &rect, Qt::ImageConversionFlags flags) const |
| \compat |
| |
| Use copy() instead. |
| */ |
| |
| /*! |
| \fn QImage QImage::copy(int x, int y, int w, int h, Qt::ImageConversionFlags flags) const |
| \compat |
| |
| Use copy() instead. |
| */ |
| |
| /*! |
| \fn QImage QImage::scaleWidth(int w) const |
| \compat |
| |
| Use scaledToWidth() instead. |
| */ |
| |
| /*! |
| \fn QImage QImage::scaleHeight(int h) const |
| \compat |
| |
| Use scaledToHeight() instead. |
| */ |
| |
| static QImage smoothScaled(const QImage &source, int w, int h) { |
| QImage src = source; |
| if (src.format() == QImage::Format_ARGB32) |
| src = src.convertToFormat(QImage::Format_ARGB32_Premultiplied); |
| else if (src.depth() < 32) { |
| if (src.hasAlphaChannel()) |
| src = src.convertToFormat(QImage::Format_ARGB32_Premultiplied); |
| else |
| src = src.convertToFormat(QImage::Format_RGB32); |
| } |
| |
| return qSmoothScaleImage(src, w, h); |
| } |
| |
| |
| static QImage rotated90(const QImage &image) { |
| QImage out(image.height(), image.width(), image.format()); |
| if (image.colorCount() > 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: |
| qt_memrotate270(reinterpret_cast<const quint32*>(image.bits()), |
| w, h, image.bytesPerLine(), |
| reinterpret_cast<quint32*>(out.bits()), |
| out.bytesPerLine()); |
| break; |
| case QImage::Format_RGB666: |
| case QImage::Format_ARGB6666_Premultiplied: |
| case QImage::Format_ARGB8565_Premultiplied: |
| case QImage::Format_ARGB8555_Premultiplied: |
| case QImage::Format_RGB888: |
| qt_memrotate270(reinterpret_cast<const quint24*>(image.bits()), |
| w, h, image.bytesPerLine(), |
| reinterpret_cast<quint24*>(out.bits()), |
| out.bytesPerLine()); |
| break; |
| case QImage::Format_RGB555: |
| case QImage::Format_RGB16: |
| case QImage::Format_ARGB4444_Premultiplied: |
| qt_memrotate270(reinterpret_cast<const quint16*>(image.bits()), |
| w, h, image.bytesPerLine(), |
| reinterpret_cast<quint16*>(out.bits()), |
| out.bytesPerLine()); |
| break; |
| case QImage::Format_Indexed8: |
| qt_memrotate270(reinterpret_cast<const quint8*>(image.bits()), |
| w, h, image.bytesPerLine(), |
| reinterpret_cast<quint8*>(out.bits()), |
| out.bytesPerLine()); |
| break; |
| default: |
| for (int y=0; y<h; ++y) { |
| if (image.colorCount()) |
| 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; |
| } |
| |
| |
| static QImage rotated180(const QImage &image) { |
| return image.mirrored(true, true); |
| } |
| |
| |
| static QImage rotated270(const QImage &image) { |
| QImage out(image.height(), image.width(), image.format()); |
| if (image.colorCount() > 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: |
| qt_memrotate90(reinterpret_cast<const quint32*>(image.bits()), |
| w, h, image.bytesPerLine(), |
| reinterpret_cast<quint32*>(out.bits()), |
| out.bytesPerLine()); |
| break; |
| case QImage::Format_RGB666: |
| case QImage::Format_ARGB6666_Premultiplied: |
| case QImage::Format_ARGB8565_Premultiplied: |
| case QImage::Format_ARGB8555_Premultiplied: |
| case QImage::Format_RGB888: |
| qt_memrotate90(reinterpret_cast<const quint24*>(image.bits()), |
| w, h, image.bytesPerLine(), |
| reinterpret_cast<quint24*>(out.bits()), |
| out.bytesPerLine()); |
| break; |
| case QImage::Format_RGB555: |
| case QImage::Format_RGB16: |
| case QImage::Format_ARGB4444_Premultiplied: |
| qt_memrotate90(reinterpret_cast<const quint16*>(image.bits()), |
| w, h, image.bytesPerLine(), |
| reinterpret_cast<quint16*>(out.bits()), |
| out.bytesPerLine()); |
| break; |
| case QImage::Format_Indexed8: |
| qt_memrotate90(reinterpret_cast<const quint8*>(image.bits()), |
| w, h, image.bytesPerLine(), |
| reinterpret_cast<quint8*>(out.bits()), |
| out.bytesPerLine()); |
| break; |
| default: |
| for (int y=0; y<h; ++y) { |
| if (image.colorCount()) |
| 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; |
| } |
| |
| /*! |
| Returns a copy of the image that is transformed using the given |
| transformation \a matrix and transformation \a mode. |
| |
| The transformation \a matrix is internally adjusted to compensate |
| for unwanted translation; i.e. the image produced is the smallest |
| image that contains all the transformed points of the original |
| image. Use the trueMatrix() function to retrieve the actual matrix |
| used for transforming an image. |
| |
| Unlike the other overload, this function can be used to perform perspective |
| transformations on images. |
| |
| \sa trueMatrix(), {QImage#Image Transformations}{Image |
| Transformations} |
| */ |
| |
| QImage QImage::transformed(const QTransform &matrix, Qt::TransformationMode mode ) const |
| { |
| if (!d) |
| return QImage(); |
| |
| // source image data |
| int ws = width(); |
| int hs = height(); |
| |
| // target image data |
| int wd; |
| int hd; |
| |
| // compute size of target image |
| QTransform mat = trueMatrix(matrix, ws, hs); |
| bool complex_xform = false; |
| bool scale_xform = false; |
| if (mat.type() <= QTransform::TxScale) { |
| if (mat.type() == QTransform::TxNone) // identity matrix |
| return *this; |
| else if (mat.m11() == -1. && mat.m22() == -1.) |
| return rotated180(*this); |
| |
| if (mode == Qt::FastTransformation) { |
| hd = qRound(qAbs(mat.m22()) * hs); |
| wd = qRound(qAbs(mat.m11()) * ws); |
| } else { |
| hd = int(qAbs(mat.m22()) * hs + 0.9999); |
| wd = int(qAbs(mat.m11()) * ws + 0.9999); |
| } |
| scale_xform = true; |
| } else { |
| if (mat.type() <= QTransform::TxRotate && mat.m11() == 0 && mat.m22() == 0) { |
| if (mat.m12() == 1. && mat.m21() == -1.) |
| return rotated90(*this); |
| else if (mat.m12() == -1. && mat.m21() == 1.) |
| return rotated270(*this); |
| } |
| |
| QPolygonF a(QRectF(0, 0, ws, hs)); |
| a = mat.map(a); |
| QRect r = a.boundingRect().toAlignedRect(); |
| wd = r.width(); |
| hd = r.height(); |
| complex_xform = true; |
| } |
| |
| if (wd == 0 || hd == 0) |
| return QImage(); |
| |
| // Make use of the optimized algorithm when we're scaling |
| if (scale_xform && mode == Qt::SmoothTransformation) { |
| if (mat.m11() < 0.0F && mat.m22() < 0.0F) { // horizontal/vertical flip |
| return smoothScaled(mirrored(true, true), wd, hd); |
| } else if (mat.m11() < 0.0F) { // horizontal flip |
| return smoothScaled(mirrored(true, false), wd, hd); |
| } else if (mat.m22() < 0.0F) { // vertical flip |
| return smoothScaled(mirrored(false, true), wd, hd); |
| } else { // no flipping |
| return smoothScaled(*this, wd, hd); |
| } |
| } |
| |
| int bpp = depth(); |
| |
| int sbpl = bytesPerLine(); |
| const uchar *sptr = bits(); |
| |
| QImage::Format target_format = d->format; |
| |
| if (complex_xform || mode == Qt::SmoothTransformation) { |
| if (d->format < QImage::Format_RGB32 || !hasAlphaChannel()) { |
| switch(d->format) { |
| case QImage::Format_RGB16: |
| target_format = Format_ARGB8565_Premultiplied; |
| break; |
| case QImage::Format_RGB555: |
| target_format = Format_ARGB8555_Premultiplied; |
| break; |
| case QImage::Format_RGB666: |
| target_format = Format_ARGB6666_Premultiplied; |
| break; |
| case QImage::Format_RGB444: |
| target_format = Format_ARGB4444_Premultiplied; |
| break; |
| default: |
| target_format = Format_ARGB32_Premultiplied; |
| break; |
| } |
| } |
| } |
| |
| QImage dImage(wd, hd, target_format); |
| QIMAGE_SANITYCHECK_MEMORY(dImage); |
| |
| if (target_format == QImage::Format_MonoLSB |
| || target_format == QImage::Format_Mono |
| || target_format == QImage::Format_Indexed8) { |
| dImage.d->colortable = d->colortable; |
| dImage.d->has_alpha_clut = d->has_alpha_clut | complex_xform; |
| } |
| |
| dImage.d->dpmx = dotsPerMeterX(); |
| dImage.d->dpmy = dotsPerMeterY(); |
| |
| switch (bpp) { |
| // initizialize the data |
| case 8: |
| if (dImage.d->colortable.size() < 256) { |
| // colors are left in the color table, so pick that one as transparent |
| dImage.d->colortable.append(0x0); |
| memset(dImage.bits(), dImage.d->colortable.size() - 1, dImage.byteCount()); |
| } else { |
| memset(dImage.bits(), 0, dImage.byteCount()); |
| } |
| break; |
| case 1: |
| case 16: |
| case 24: |
| case 32: |
| memset(dImage.bits(), 0x00, dImage.byteCount()); |
| break; |
| } |
| |
| if (target_format >= QImage::Format_RGB32) { |
| QPainter p(&dImage); |
| if (mode == Qt::SmoothTransformation) { |
| p.setRenderHint(QPainter::Antialiasing); |
| p.setRenderHint(QPainter::SmoothPixmapTransform); |
| } |
| p.setTransform(mat); |
| p.drawImage(QPoint(0, 0), *this); |
| } else { |
| bool invertible; |
| mat = mat.inverted(&invertible); // invert matrix |
| if (!invertible) // error, return null image |
| return QImage(); |
| |
| // create target image (some of the code is from QImage::copy()) |
| int type = format() == Format_Mono ? QT_XFORM_TYPE_MSBFIRST : QT_XFORM_TYPE_LSBFIRST; |
| int dbpl = dImage.bytesPerLine(); |
| qt_xForm_helper(mat, 0, type, bpp, dImage.bits(), dbpl, 0, hd, sptr, sbpl, ws, hs); |
| } |
| return dImage; |
| } |
| |
| /*! |
| \fn QTransform QImage::trueMatrix(const QTransform &matrix, int width, int height) |
| |
| Returns the actual matrix used for transforming an image with the |
| given \a width, \a height and \a matrix. |
| |
| When transforming an image using the transformed() function, the |
| transformation matrix is internally adjusted to compensate for |
| unwanted translation, i.e. transformed() returns the smallest |
| image containing all transformed points of the original image. |
| This function returns the modified matrix, which maps points |
| correctly from the original image into the new image. |
| |
| Unlike the other overload, this function creates transformation |
| matrices that can be used to perform perspective |
| transformations on images. |
| |
| \sa transformed(), {QImage#Image Transformations}{Image |
| Transformations} |
| */ |
| |
| QTransform QImage::trueMatrix(const QTransform &matrix, int w, int h) |
| { |
| const QRectF rect(0, 0, w, h); |
| const QRect mapped = matrix.mapRect(rect).toAlignedRect(); |
| const QPoint delta = mapped.topLeft(); |
| return matrix * QTransform().translate(-delta.x(), -delta.y()); |
| } |
| |
| bool QImageData::convertInPlace(QImage::Format newFormat, Qt::ImageConversionFlags flags) |
| { |
| if (format == newFormat) |
| return true; |
| |
| // No in-place conversion if we have to detach |
| if (ref > 1) |
| return false; |
| |
| const InPlace_Image_Converter *const converterPtr = &inplace_converter_map[format][newFormat]; |
| InPlace_Image_Converter converter = *converterPtr; |
| if (converter) |
| return converter(this, flags); |
| else |
| return false; |
| } |
| |
| /*! |
| \typedef QImage::DataPtr |
| \internal |
| */ |
| |
| /*! |
| \fn DataPtr & QImage::data_ptr() |
| \internal |
| */ |
| |
| QT_END_NAMESPACE |