// Copyright (C) 2022 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:critical reason:data-parser

#include "qimage.h"

#include "qbuffer.h"

#include "qdatastream.h"

#include "qcolortransform.h"

#include "qfloat16.h"

#include "qmap.h"

#include "qtransform.h"

#include "qimagereader.h"

#include "qimagewriter.h"

#include "qrgbafloat.h"

#include "qstringlist.h"

#include "qvariant.h"

#include "qimagepixmapcleanuphooks_p.h"

#include <qpa/qplatformintegration.h>

#include <private/qguiapplication_p.h>

#include <ctype.h>

#include <stdlib.h>

#include <limits.h>

#include <qpa/qplatformpixmap.h>

#include <qalloc.h>

#include <private/qcolorspace_p.h>

#include <private/qcolortransform_p.h>

#include <private/qmemrotate_p.h>

#include <private/qimagescale_p.h>

#include <private/qpixellayout_p.h>

#include <private/qsimd_p.h>

#include <qhash.h>

#include <private/qpaintengine_raster_p.h>

#include <private/qimage_p.h>

#include <private/qfont_p.h>

#if QT_CONFIG(qtgui_threadpool)

#include <private/qlatch_p.h>

#include <qthreadpool.h>

#include <private/qthreadpool_p.h>

#endif

#include <qtgui_tracepoints_p.h>

#include <memory>

#define QT_XFORM_TYPE_MSBFIRST 0

#define QT_XFORM_TYPE_LSBFIRST 1

QT_BEGIN_NAMESPACE

class QCmyk32;

using namespace Qt::StringLiterals;

// MSVC 19.28 does show spurious warning "C4723: potential divide by 0" for code that divides

// by height() in release builds. Anyhow, all the code paths in this file are only executed

// for valid QImage's, where height() cannot be 0. Therefore disable the warning.

QT_WARNING_DISABLE_MSVC(4723)

#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(); \

    }

Q_TRACE_PREFIX(qtgui,

   "#include <qimagereader.h>"

);

Q_TRACE_METADATA(qtgui,

"ENUM { } QImage::Format;" \

"FLAGS { } Qt::ImageConversionFlags;"

);

Q_TRACE_PARAM_REPLACE(Qt::AspectRatioMode, int);

Q_TRACE_PARAM_REPLACE(Qt::TransformationMode, int);

static QImage rotated90(const QImage &src);

static QImage rotated180(const QImage &src);

static QImage rotated270(const QImage &src);

static int next_qimage_serial_number()

{

    Q_CONSTINIT static QBasicAtomicInt serial = Q_BASIC_ATOMIC_INITIALIZER(0);

    return 1 + serial.fetchAndAddRelaxed(1);

}

QImageData::QImageData()

    : ref(0), width(0), height(0), depth(0), nbytes(0), devicePixelRatio(1.0), data(nullptr),

      format(QImage::Format_ARGB32), bytes_per_line(0),

      ser_no(next_qimage_serial_number()),

      detach_no(0),

      offset(0, 0), own_data(true), ro_data(false), has_alpha_clut(false),

      is_cached(false), cleanupFunction(nullptr), cleanupInfo(nullptr),

      paintEngine(nullptr)

{

    QPoint dpis = qt_defaultDpis();

    dpmx = dpis.x() * 100 / qreal(2.54);

    dpmy = dpis.y() * 100 / qreal(2.54);

}

/*! \fn QImageData * QImageData::create(const QSize &size, QImage::Format format)

    \internal

    Creates a new image data.

    Returns \nullptr if invalid parameters are give or anything else failed.

*/

QImageData * Q_TRACE_INSTRUMENT(qtgui) QImageData::create(const QSize &size, QImage::Format format)

{

    if (size.isEmpty() || format <= QImage::Format_Invalid || format >= QImage::NImageFormats)

        return nullptr;                             // invalid parameter(s)

    Q_TRACE_SCOPE(QImageData_create, size, format);

    int width = size.width();

    int height = size.height();

    int depth = qt_depthForFormat(format);

    auto params = calculateImageParameters(width, height, depth);

    if (!params.isValid())

        return nullptr;

    auto d = std::make_unique<QImageData>();

    switch (format) {

    case QImage::Format_Mono:

    case QImage::Format_MonoLSB:

        d->colortable.resize(2);

        d->colortable[0] = QColor(Qt::black).rgba();

        d->colortable[1] = QColor(Qt::white).rgba();

        break;

    default:

        break;

    }

    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 = params.bytesPerLine;

    d->nbytes = params.totalSize;

    d->data  = (uchar *)malloc(d->nbytes);

    if (!d->data)

        return nullptr;

    d->ref.ref();

    return d.release();

}

QImageData::~QImageData()

{

    if (cleanupFunction)

        cleanupFunction(cleanupInfo);

    if (is_cached)

        QImagePixmapCleanupHooks::executeImageHooks((((qint64) ser_no) << 32) | ((qint64) detach_no));

    delete paintEngine;

    if (data && own_data)

        QtPrivate::sizedFree(data, nbytes);

    data = nullptr;

}

#if defined(_M_ARM) && defined(_MSC_VER)

#pragma optimize("", off)

#endif

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_Alpha8:

        has_alpha_pixels = true;

        break;

    case QImage::Format_ARGB32:

    case QImage::Format_ARGB32_Premultiplied: {

        const uchar *bits = data;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            uint alphaAnd = 0xff000000;

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

                alphaAnd &= reinterpret_cast<const uint*>(bits)[x];

            has_alpha_pixels = (alphaAnd != 0xff000000);

            bits += bytes_per_line;

        }

    } break;

    case QImage::Format_RGBA8888:

    case QImage::Format_RGBA8888_Premultiplied: {

        const uchar *bits = data;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            uchar alphaAnd = 0xff;

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

                alphaAnd &= bits[x * 4+ 3];

            has_alpha_pixels = (alphaAnd != 0xff);

            bits += bytes_per_line;

        }

    } break;

    case QImage::Format_A2BGR30_Premultiplied:

    case QImage::Format_A2RGB30_Premultiplied: {

        const uchar *bits = data;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            uint alphaAnd = 0xc0000000;

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

                alphaAnd &= reinterpret_cast<const uint*>(bits)[x];

            has_alpha_pixels = (alphaAnd != 0xc0000000);

            bits += bytes_per_line;

        }

    } break;

    case QImage::Format_ARGB8555_Premultiplied:

    case QImage::Format_ARGB8565_Premultiplied: {

        const uchar *bits = data;

        const uchar *end_bits = data + bytes_per_line;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            uchar alphaAnd = 0xff;

            while (bits < end_bits) {

                alphaAnd &= bits[0];

                bits += 3;

            }

            has_alpha_pixels = (alphaAnd != 0xff);

            bits = end_bits;

            end_bits += bytes_per_line;

        }

    } break;

    case QImage::Format_ARGB6666_Premultiplied: {

        const uchar *bits = data;

        const uchar *end_bits = data + bytes_per_line;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            uchar alphaAnd = 0xfc;

            while (bits < end_bits) {

                alphaAnd &= bits[0];

                bits += 3;

            }

            has_alpha_pixels = (alphaAnd != 0xfc);

            bits = end_bits;

            end_bits += bytes_per_line;

        }

    } break;

    case QImage::Format_ARGB4444_Premultiplied: {

        const uchar *bits = data;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

            ushort alphaAnd = 0xf000;

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

                alphaAnd &= reinterpret_cast<const ushort*>(bits)[x];

            has_alpha_pixels = (alphaAnd != 0xf000);

            bits += bytes_per_line;

        }

    } break;

    case QImage::Format_RGBA64:

    case QImage::Format_RGBA64_Premultiplied: {

        uchar *bits = data;

        for (int y=0; y<height && !has_alpha_pixels; ++y) {

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

                has_alpha_pixels |= !(((QRgba64 *)bits)[x].isOpaque());

            }

            bits += bytes_per_line;

        }

    } break;

    case QImage::Format_RGBA16FPx4:

    case QImage::Format_RGBA16FPx4_Premultiplied: {

        uchar *bits = data;

        for (int y = 0; y < height && !has_alpha_pixels; ++y) {

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

                has_alpha_pixels |= ((qfloat16 *)bits)[x * 4 + 3] < 1.0f;

            bits += bytes_per_line;

        }

    } break;

    case QImage::Format_RGBA32FPx4:

    case QImage::Format_RGBA32FPx4_Premultiplied: {

        uchar *bits = data;

        for (int y = 0; y < height && !has_alpha_pixels; ++y) {

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

                has_alpha_pixels |= ((float *)bits)[x * 4 + 3] < 1.0f;

            bits += bytes_per_line;

        }

    } break;

    case QImage::Format_RGB32:

    case QImage::Format_RGB16:

    case QImage::Format_RGB444:

    case QImage::Format_RGB555:

    case QImage::Format_RGB666:

    case QImage::Format_RGB888:

    case QImage::Format_BGR888:

    case QImage::Format_RGBX8888:

    case QImage::Format_BGR30:

    case QImage::Format_RGB30:

    case QImage::Format_Grayscale8:

    case QImage::Format_Grayscale16:

    case QImage::Format_RGBX64:

    case QImage::Format_RGBX16FPx4:

    case QImage::Format_RGBX32FPx4:

    case QImage::Format_CMYK8888:

        break;

    case QImage::Format_Invalid:

    case QImage::NImageFormats:

        Q_UNREACHABLE();

        break;

    }

    return has_alpha_pixels;

}

#if defined(_M_ARM) && defined(_MSC_VER)

#pragma optimize("", on)

#endif

/*!

    \class QImage

    \inmodule QtGui

    \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}{Plugin HowTo}.

    \warning Painting on a QImage with the format

    QImage::Format_Indexed8 or QImage::Format_CMYK8888 is not supported.

    \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 \li Format \li Description                      \li Qt's support

    \row    \li BMP    \li Windows Bitmap                   \li Read/write

    \row    \li GIF    \li Graphic Interchange Format (optional) \li Read

    \row    \li JPG    \li Joint Photographic Experts Group \li Read/write

    \row    \li JPEG   \li Joint Photographic Experts Group \li Read/write

    \row    \li PNG    \li Portable Network Graphics        \li Read/write

    \row    \li PBM    \li Portable Bitmap                  \li Read

    \row    \li PGM    \li Portable Graymap                 \li Read

    \row    \li PPM    \li Portable Pixmap                  \li Read/write

    \row    \li XBM    \li X11 Bitmap                       \li Read/write

    \row    \li XPM    \li X11 Pixmap                       \li 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

    \li \li Available Functions

    \row

    \li Geometry

    \li

    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

    \li Colors

    \li

    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 independent 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

    \li Text

    \li

    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

    \li Low-level information

    \li

    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 sizeInBytes() 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

    \li {2,1}32-bit

    \row

    \li \inlineimage qimage-32bit_scaled.png

                     {3x3 pixel grid with ARGB color values}

    \li

    \snippet 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

    \li {2,1} 8-bit

    \row

    \li \inlineimage qimage-8bit_scaled.png

                     {3x3 pixel grid with indexed colors and color table}

    \li

    \snippet code/src_gui_image_qimage.cpp 1

    \endtable

    For images with more than 8-bit per color-channel. The methods

    setPixelColor() and pixelColor() can be used to set and get

    with QColor values.

    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

    QList<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 \li Function \li Description

    \row

    \li setDotsPerMeterX()

    \li Defines the aspect ratio by setting the number of pixels that fit

    horizontally in a physical meter.

    \row

    \li setDotsPerMeterY()

    \li Defines the aspect ratio by setting the number of pixels that fit

    vertically in a physical meter.

    \row

    \li fill()

    \li Fills the entire image with the given pixel value.

    \row

    \li invertPixels()

    \li Inverts all pixel values in the image using the given InvertMode value.

    \row

    \li setColorTable()

    \li Sets the color table used to translate color indexes. Only

    monochrome and 8-bit formats.

    \row

    \li setColorCount()

    \li Resizes the color table. Only monochrome and 8-bit formats.

    \endtable

    \sa QImageReader, QImageWriter, QPixmap, QSvgRenderer,

        {Image Composition Example}, {Scribble Example}

*/

/*!

    \fn QImage::QImage(QImage &&other)

    Move-constructs a QImage instance, making it point at the same

    object that \a other was pointing to.

    \since 5.2

*/

/*!

    \fn QImage &QImage::operator=(QImage &&other)

    Move-assigns \a other to this QImage instance.

    \since 5.2

*/

/*!

    \typedef QImageCleanupFunction

    \relates QImage

    \since 5.0

    A function with the following signature that can be used to

    implement basic image memory management:

    \code

    void myImageCleanupHandler(void *info);

    \endcode

*/

/*!

    \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.

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

    \value [since 5.2]

           Format_RGBX8888   The image is stored using a 32-bit byte-ordered RGB(x) format (8-8-8-8).

                             This is the same as the Format_RGBA8888 except alpha must always be 255.

    \value [since 5.2]

           Format_RGBA8888   The image is stored using a 32-bit byte-ordered RGBA format (8-8-8-8).

    \value [since 5.2]

           Format_RGBA8888_Premultiplied    The image is stored using a

                            premultiplied 32-bit byte-ordered RGBA format (8-8-8-8).

    \value [since 5.4]

           Format_BGR30      The image is stored using a 32-bit BGR format (x-10-10-10).

    \value [since 5.4]

           Format_A2BGR30_Premultiplied    The image is stored using a 32-bit premultiplied ABGR format (2-10-10-10).

    \value [since 5.4]

           Format_RGB30      The image is stored using a 32-bit RGB format (x-10-10-10).

    \value [since 5.4]

           Format_A2RGB30_Premultiplied    The image is stored using a 32-bit premultiplied ARGB format (2-10-10-10).

    \value [since 5.5]

           Format_Alpha8     The image is stored using an 8-bit alpha only format.

    \value [since 5.5]

           Format_Grayscale8 The image is stored using an 8-bit grayscale format.

    \value [since 5.13]

           Format_Grayscale16 The image is stored using an 16-bit grayscale format.

    \value [since 5.12]

           Format_RGBX64     The image is stored using a 64-bit halfword-ordered RGB(x) format (16-16-16-16).

                             This is the same as the Format_RGBA64 except alpha must always be 65535.

    \value [since 5.12]

           Format_RGBA64     The image is stored using a 64-bit halfword-ordered RGBA format (16-16-16-16).

    \value [since 5.12]

           Format_RGBA64_Premultiplied    The image is stored using a premultiplied 64-bit halfword-ordered

                             RGBA format (16-16-16-16).

    \value [since 5.14]

           Format_BGR888     The image is stored using a 24-bit BGR format.

    \value [since 6.2]

           Format_RGBX16FPx4 The image is stored using a four 16-bit halfword floating point RGBx format (16FP-16FP-16FP-16FP).

                             This is the same as the Format_RGBA16FPx4 except alpha must always be 1.0.

    \value [since 6.2]

           Format_RGBA16FPx4 The image is stored using a four 16-bit halfword floating point RGBA format (16FP-16FP-16FP-16FP).

    \value [since 6.2]

           Format_RGBA16FPx4_Premultiplied    The image is stored using a premultiplied four 16-bit halfword floating point

                             RGBA format (16FP-16FP-16FP-16FP).

    \value [since 6.2]

           Format_RGBX32FPx4 The image is stored using a four 32-bit floating point RGBx format (32FP-32FP-32FP-32FP).

                             This is the same as the Format_RGBA32FPx4 except alpha must always be 1.0.

    \value [since 6.2]

           Format_RGBA32FPx4 The image is stored using a four 32-bit floating point RGBA format (32FP-32FP-32FP-32FP).

    \value [since 6.2]

           Format_RGBA32FPx4_Premultiplied    The image is stored using a premultiplied four 32-bit floating point

                             RGBA format (32FP-32FP-32FP-32FP).

    \value [since 6.8]

           Format_CMYK8888   The image is stored using a 32-bit byte-ordered CMYK format.

    Byte-ordered formats have a QPixelFormat::typeInterpretation() of

    QPixelFormat::UnsignedByte, meaning the individual color components

    are stored in memory in a fixed order, e.g 0xRR, 0xGG, 0xBB, 0xAA,

    regardless of the endianness of the platform. These formats should be

    read as individual bytes, or interpreted as QPixelFormat::BigEndian

    if read in larger chunks.

    \note Drawing into a QImage with format QImage::Format_Indexed8 or QImage::Format_CMYK8888 is not

    supported.

    \note Avoid most rendering directly to most of these formats using QPainter. Rendering

    is best optimized to the \c Format_RGB32 and \c Format_ARGB32_Premultiplied formats, and secondarily for rendering to the

    \c Format_RGB16, \c Format_RGBX8888, \c Format_RGBA8888_Premultiplied, \c Format_RGBX64 and \c Format_RGBA64_Premultiplied formats

    \sa format(), convertToFormat()

*/

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

  QImage member functions

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

/*!

    Constructs a null image.

    \sa isNull()

*/

QImage::QImage() noexcept

    : QPaintDevice()

{

    d = nullptr;

}

/*!

    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)

    : QImage(QSize(width, height), format)

{

}

/*!

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

}

QImageData *QImageData::create(uchar *data, int width, int height,  qsizetype bpl, QImage::Format format, bool readOnly, QImageCleanupFunction cleanupFunction, void *cleanupInfo)

{

    if (width <= 0 || height <= 0 || !data || format <= QImage::Format_Invalid || format >= QImage::NImageFormats)

        return nullptr;

    const int depth = qt_depthForFormat(format);

    auto params = calculateImageParameters(width, height, depth);

    if (!params.isValid())

        return nullptr;

    if (bpl > 0) {

        // can't overflow, because has calculateImageParameters already done this multiplication

        const qsizetype min_bytes_per_line = (qsizetype(width) * depth + 7)/8;

        if (bpl < min_bytes_per_line)

            return nullptr;

        // recalculate the total with this value

        params.bytesPerLine = bpl;

        if (qMulOverflow<qsizetype>(bpl, height, &params.totalSize))

            return nullptr;

    }

    QImageData *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 = params.bytesPerLine;

    d->nbytes = params.totalSize;

    d->cleanupFunction = cleanupFunction;

    d->cleanupInfo = cleanupInfo;

    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 and

    all copies that have not been modified or otherwise detached from

    the original buffer. The image does not delete the buffer at destruction.

    You can provide a function pointer \a cleanupFunction along with an

    extra pointer \a cleanupInfo that will be called when the last copy

    is destroyed.

    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, QImageCleanupFunction cleanupFunction, void *cleanupInfo)

    : QPaintDevice()

{

    d = QImageData::create(data, width, height, 0, format, false, cleanupFunction, cleanupInfo);

}

/*!

    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.

    You can provide a function pointer \a cleanupFunction along with an

    extra pointer \a cleanupInfo that will be called when the last copy

    is destroyed.

    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, QImageCleanupFunction cleanupFunction, void *cleanupInfo)

    : QPaintDevice()

{

    d = QImageData::create(const_cast<uchar*>(data), width, height, 0, format, true, cleanupFunction, cleanupInfo);

}

/*!

    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 and

    all copies that have not been modified or otherwise detached from

    the original buffer. The image does not delete the buffer at destruction.

    You can provide a function pointer \a cleanupFunction along with an

    extra pointer \a cleanupInfo that will be called when the last copy

    is destroyed.

    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, qsizetype bytesPerLine, Format format, QImageCleanupFunction cleanupFunction, void *cleanupInfo)

    :QPaintDevice()

{

    d = QImageData::create(data, width, height, bytesPerLine, format, false, cleanupFunction, cleanupInfo);

}

/*!

    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 and

    all copies that have not been modified or otherwise detached from

    the original buffer. The image does not delete the buffer at destruction.

    You can provide a function pointer \a cleanupFunction along with an

    extra pointer \a cleanupInfo that will be called when the last copy

    is destroyed.

    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, qsizetype bytesPerLine, Format format, QImageCleanupFunction cleanupFunction, void *cleanupInfo)

    :QPaintDevice()

{

    d = QImageData::create(const_cast<uchar*>(data), width, height, bytesPerLine, format, true, cleanupFunction, cleanupInfo);

}

/*!

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

    it is auto-detected based on the file's suffix and header. For

    details, see {QImageReader::setAutoDetectImageFormat()}{QImageReader}.

    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 = nullptr;

    load(fileName, format);

}

#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 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 = nullptr;

    if (!xpm)

        return;

    if (!qt_read_xpm_image_or_array(nullptr, xpm, *this))

        // Issue: Warning because the constructor may be ambiguous

        qWarning("QImage::QImage(), XPM is not supported");

}

#endif // QT_NO_IMAGEFORMAT_XPM

/*!

    Constructs a shallow copy of the given \a image.

    For more information about shallow copies, see the \l {Implicit

    Data Sharing} documentation.