/src/qtbase/src/gui/image/qimage_p.h

Source
// Copyright (C) 2021 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

#ifndef QIMAGE_P_H
#define QIMAGE_P_H

//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//

#include <QtGui/private/qtguiglobal_p.h>
#include <QtGui/qcolorspace.h>
#include <QtGui/qimage.h>
#include <QtCore/private/qnumeric_p.h>
#include <QtCore/qlist.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qmap.h>
#include <QtCore/qttypetraits.h>


QT_BEGIN_NAMESPACE

Q_DECLARE_LOGGING_CATEGORY(lcImageIo)

class QImageWriter;

struct Q_GUI_EXPORT QImageData {        // internal image data
    QImageData();
    ~QImageData();
    static QImageData *create(const QSize &size, QImage::Format format);
    static QImageData *create(uchar *data, int w, int h,  qsizetype bpl, QImage::Format format, bool readOnly, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr);

    static QImageData *get(QImage &img) noexcept { return img.d; }
    static const QImageData *get(const QImage &img) noexcept { return img.d; }

    QAtomicInt ref;

    int width;
    int height;
    int depth;
    qsizetype nbytes;               // number of bytes data
    qreal devicePixelRatio;
    QList<QRgb> colortable;
    uchar *data;
    QImage::Format format; // invariants: > Format_Invalid, < NImageFormats
    qsizetype bytes_per_line;
    int ser_no;               // serial number
    int detach_no;

    qreal  dpmx;                // dots per meter X (or 0)
    qreal  dpmy;                // dots per meter Y (or 0)
    QPoint  offset;           // offset in pixels

    uint own_data : 1;
    uint ro_data : 1;
    uint has_alpha_clut : 1;
    uint is_cached : 1;

    QImageCleanupFunction cleanupFunction;
    void* cleanupInfo;

    bool checkForAlphaPixels() const;

    // Convert the image in-place, minimizing memory reallocation
    // Return false if the conversion cannot be done in-place.
    bool convertInPlace(QImage::Format newFormat, Qt::ImageConversionFlags);

    QMap<QString, QString> text;

    bool doImageIO(const QImage *image, QImageWriter* io, int quality) const;

    QPaintEngine *paintEngine;

    QColorSpace colorSpace;

    struct ImageSizeParameters {
        qsizetype bytesPerLine;
        qsizetype totalSize;
        bool isValid() const { return bytesPerLine > 0 && totalSize > 0; }
    };
    static ImageSizeParameters calculateImageParameters(qsizetype width, qsizetype height, qsizetype depth);
};

inline QImageData::ImageSizeParameters
QImageData::calculateImageParameters(qsizetype width, qsizetype height, qsizetype depth)
{
    ImageSizeParameters invalid = { -1, -1 };
    if (height <= 0)
        return invalid;

    // calculate the size, taking care of overflows
    qsizetype bytes_per_line;
    if (qMulOverflow(width, depth, &bytes_per_line))
        return invalid;
    if (qAddOverflow(bytes_per_line, qsizetype(31), &bytes_per_line))
        return invalid;
    // bytes per scanline (must be multiple of 4)
    bytes_per_line = (bytes_per_line >> 5) << 2;    // can't overflow

    qsizetype total_size;
    if (qMulOverflow(height, bytes_per_line, &total_size))
        return invalid;
    qsizetype dummy;
    if (qMulOverflow(height, qsizetype(sizeof(uchar *)), &dummy))
        return invalid;                                 // why is this here?
    // Disallow images where width * depth calculations might overflow
    if (width > (INT_MAX - 31) / depth)
        return invalid;

    return { bytes_per_line, total_size };
}

typedef void (*Image_Converter)(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags);
typedef bool (*InPlace_Image_Converter)(QImageData *data, Qt::ImageConversionFlags);

extern Image_Converter qimage_converter_map[QImage::NImageFormats][QImage::NImageFormats];
extern InPlace_Image_Converter qimage_inplace_converter_map[QImage::NImageFormats][QImage::NImageFormats];

void convert_generic(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags);
void convert_generic_over_rgb64(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags);
bool convert_generic_inplace(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);
bool convert_generic_inplace_over_rgb64(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);
#if QT_CONFIG(raster_fp)
void convert_generic_over_rgba32f(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags);
bool convert_generic_inplace_over_rgba32f(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);
#endif

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

const uchar *qt_get_bitflip_array();
Q_GUI_EXPORT void qGamma_correct_back_to_linear_cs(QImage *image);

#if defined(_M_ARM) && defined(_MSC_VER) // QTBUG-42038
#pragma optimize("", off)
#endif
inline int qt_depthForFormat(QImage::Format format)
{
    int depth = 0;
    switch(format) {
    case QImage::Format_Invalid:
    case QImage::NImageFormats:
        Q_UNREACHABLE();
    case QImage::Format_Mono:
    case QImage::Format_MonoLSB:
        depth = 1;
        break;
    case QImage::Format_Indexed8:
    case QImage::Format_Alpha8:
    case QImage::Format_Grayscale8:
        depth = 8;
        break;
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32:
    case QImage::Format_ARGB32_Premultiplied:
    case QImage::Format_RGBX8888:
    case QImage::Format_RGBA8888:
    case QImage::Format_RGBA8888_Premultiplied:
    case QImage::Format_BGR30:
    case QImage::Format_A2BGR30_Premultiplied:
    case QImage::Format_RGB30:
    case QImage::Format_A2RGB30_Premultiplied:
        depth = 32;
        break;
    case QImage::Format_RGB555:
    case QImage::Format_RGB16:
    case QImage::Format_RGB444:
    case QImage::Format_ARGB4444_Premultiplied:
    case QImage::Format_Grayscale16:
        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:
    case QImage::Format_BGR888:
        depth = 24;
        break;
    case QImage::Format_RGBX64:
    case QImage::Format_RGBA64:
    case QImage::Format_RGBA64_Premultiplied:
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:
        depth = 64;
        break;
    case QImage::Format_RGBX32FPx4:
    case QImage::Format_RGBA32FPx4:
    case QImage::Format_RGBA32FPx4_Premultiplied:
        depth = 128;
        break;
    case QImage::Format_CMYK8888:
        depth = 32;
        break;
    }
    return depth;
}

#if defined(_M_ARM) && defined(_MSC_VER)
#pragma optimize("", on)
#endif

inline QImage::Format qt_opaqueVersion(QImage::Format format)
{
    switch (format) {
    case QImage::Format_ARGB8565_Premultiplied:
        return  QImage::Format_RGB16;
    case QImage::Format_ARGB8555_Premultiplied:
        return QImage::Format_RGB555;
    case QImage::Format_ARGB6666_Premultiplied:
        return  QImage::Format_RGB666;
    case QImage::Format_ARGB4444_Premultiplied:
        return QImage::Format_RGB444;
    case QImage::Format_RGBA8888:
    case QImage::Format_RGBA8888_Premultiplied:
        return QImage::Format_RGBX8888;
    case QImage::Format_A2BGR30_Premultiplied:
        return QImage::Format_BGR30;
    case QImage::Format_A2RGB30_Premultiplied:
        return QImage::Format_RGB30;
    case QImage::Format_RGBA64:
    case QImage::Format_RGBA64_Premultiplied:
        return QImage::Format_RGBX64;
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:
        return QImage::Format_RGBX16FPx4;
    case QImage::Format_RGBA32FPx4:
    case QImage::Format_RGBA32FPx4_Premultiplied:
        return QImage::Format_RGBX32FPx4;
    case QImage::Format_ARGB32_Premultiplied:
    case QImage::Format_ARGB32:
        return QImage::Format_RGB32;
    case QImage::Format_RGB16:
    case QImage::Format_RGB32:
    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_RGBX64:
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBX32FPx4:
    case QImage::Format_Grayscale8:
    case QImage::Format_Grayscale16:
    case QImage::Format_CMYK8888:
        return format;
    case QImage::Format_Mono:
    case QImage::Format_MonoLSB:
    case QImage::Format_Indexed8:
    case QImage::Format_Alpha8:
    case QImage::Format_Invalid:
    case QImage::NImageFormats:
        break;
    }
    return QImage::Format_RGB32;
}

inline QImage::Format qt_alphaVersion(QImage::Format format)
{
    switch (format) {
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32:
        return QImage::Format_ARGB32_Premultiplied;
    case QImage::Format_RGB16:
        return QImage::Format_ARGB8565_Premultiplied;
    case QImage::Format_RGB555:
        return QImage::Format_ARGB8555_Premultiplied;
    case QImage::Format_RGB666:
        return QImage::Format_ARGB6666_Premultiplied;
    case QImage::Format_RGB444:
        return QImage::Format_ARGB4444_Premultiplied;
    case QImage::Format_RGBX8888:
    case QImage::Format_RGBA8888:
        return QImage::Format_RGBA8888_Premultiplied;
    case QImage::Format_BGR30:
        return QImage::Format_A2BGR30_Premultiplied;
    case QImage::Format_RGB30:
        return QImage::Format_A2RGB30_Premultiplied;
    case QImage::Format_RGBX64:
    case QImage::Format_RGBA64:
    case QImage::Format_Grayscale16:
        return QImage::Format_RGBA64_Premultiplied;
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:
        return QImage::Format_RGBA16FPx4_Premultiplied;
    case QImage::Format_RGBX32FPx4:
    case QImage::Format_RGBA32FPx4:
        return QImage::Format_RGBA32FPx4_Premultiplied;
    case QImage::Format_ARGB32_Premultiplied:
    case QImage::Format_ARGB8565_Premultiplied:
    case QImage::Format_ARGB8555_Premultiplied:
    case QImage::Format_ARGB6666_Premultiplied:
    case QImage::Format_ARGB4444_Premultiplied:
    case QImage::Format_RGBA8888_Premultiplied:
    case QImage::Format_A2BGR30_Premultiplied:
    case QImage::Format_A2RGB30_Premultiplied:
    case QImage::Format_RGBA64_Premultiplied:
    case QImage::Format_RGBA16FPx4_Premultiplied:
    case QImage::Format_RGBA32FPx4_Premultiplied:
        return format;
    case QImage::Format_Mono:
    case QImage::Format_MonoLSB:
    case QImage::Format_Indexed8:
    case QImage::Format_RGB888:
    case QImage::Format_BGR888:
    case QImage::Format_Alpha8:
    case QImage::Format_Grayscale8:
    case QImage::Format_Invalid:
    case QImage::Format_CMYK8888:
    case QImage::NImageFormats:
        break;
    }
    return QImage::Format_ARGB32_Premultiplied;
}

// Returns an opaque version that is compatible with format
inline QImage::Format qt_maybeDataCompatibleOpaqueVersion(QImage::Format format)
{
    switch (format) {
    case QImage::Format_ARGB6666_Premultiplied:
        return QImage::Format_RGB666;
    case QImage::Format_ARGB4444_Premultiplied:
        return QImage::Format_RGB444;
    case QImage::Format_RGBA8888:
    case QImage::Format_RGBA8888_Premultiplied:
        return QImage::Format_RGBX8888;
    case QImage::Format_A2BGR30_Premultiplied:
        return QImage::Format_BGR30;
    case QImage::Format_A2RGB30_Premultiplied:
        return QImage::Format_RGB30;
    case QImage::Format_RGBA64:
    case QImage::Format_RGBA64_Premultiplied:
        return QImage::Format_RGBX64;
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:
        return QImage::Format_RGBX16FPx4;
    case QImage::Format_RGBA32FPx4:
    case QImage::Format_RGBA32FPx4_Premultiplied:
        return QImage::Format_RGBX32FPx4;
    case QImage::Format_ARGB32_Premultiplied:
    case QImage::Format_ARGB32:
        return QImage::Format_RGB32;
    case QImage::Format_RGB16:
    case QImage::Format_RGB32:
    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_RGBX64:
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBX32FPx4:
    case QImage::Format_Grayscale8:
    case QImage::Format_Grayscale16:
    case QImage::Format_CMYK8888:
        return format; // Already opaque
    case QImage::Format_Mono:
    case QImage::Format_MonoLSB:
    case QImage::Format_Indexed8:
    case QImage::Format_ARGB8565_Premultiplied:
    case QImage::Format_ARGB8555_Premultiplied:
    case QImage::Format_Alpha8:
    case QImage::Format_Invalid:
    case QImage::NImageFormats:
        break;
    }
    return format; // No compatible opaque versions
}

constexpr QImage::Format qt_toUnpremultipliedFormat(QImage::Format format)
{
    // Assumes input is already a premultiplied format with an unpremultiplied counterpart
    // This abuses the fact unpremultiplied formats are always before their premultiplied counterparts.
    return static_cast<QImage::Format>(qToUnderlying(format) - 1);
}

constexpr QImage::Format qt_toPremultipliedFormat(QImage::Format format)
{
    // Assumes input is already an unpremultiplied format
    // This abuses the fact unpremultiplied formats are always before their premultiplied counterparts.
    return static_cast<QImage::Format>(qToUnderlying(format) + 1);
}

inline bool qt_highColorPrecision(QImage::Format format, bool opaque = false)
{
    // Formats with higher color precision than ARGB32_Premultiplied.
    switch (format) {
    case QImage::Format_ARGB32:
    case QImage::Format_RGBA8888:
        return !opaque;
    case QImage::Format_BGR30:
    case QImage::Format_RGB30:
    case QImage::Format_A2BGR30_Premultiplied:
    case QImage::Format_A2RGB30_Premultiplied:
    case QImage::Format_RGBX64:
    case QImage::Format_RGBA64:
    case QImage::Format_RGBA64_Premultiplied:
    case QImage::Format_Grayscale16:
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:
    case QImage::Format_RGBX32FPx4:
    case QImage::Format_RGBA32FPx4:
    case QImage::Format_RGBA32FPx4_Premultiplied:
        return true;
    default:
        break;
    }
    return false;
}

inline bool qt_fpColorPrecision(QImage::Format format)
{
    switch (format) {
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:
    case QImage::Format_RGBX32FPx4:
    case QImage::Format_RGBA32FPx4:
    case QImage::Format_RGBA32FPx4_Premultiplied:
        return true;
    default:
        break;
    }
    return false;
}

inline QColorSpace::ColorModel qt_csColorData(QPixelFormat::ColorModel format)
{
    switch (format) {
    case QPixelFormat::ColorModel::RGB:
    case QPixelFormat::ColorModel::BGR:
    case QPixelFormat::ColorModel::Indexed:
        return QColorSpace::ColorModel::Rgb;
    case QPixelFormat::ColorModel::Alpha:
        return QColorSpace::ColorModel::Undefined; // No valid colors
    case QPixelFormat::ColorModel::Grayscale:
        return QColorSpace::ColorModel::Gray;
    case QPixelFormat::ColorModel::CMYK:
        return QColorSpace::ColorModel::Cmyk;
    default:
        break;
    }
    return QColorSpace::ColorModel::Undefined;
}

inline bool qt_compatibleColorModelBase(QPixelFormat::ColorModel data, QColorSpace::ColorModel cs)
{
    QColorSpace::ColorModel dataCs = qt_csColorData(data);

    if (data == QPixelFormat::ColorModel::Alpha)
        return true; // Alpha data has no colors and can be handled by any color space

    if (cs == QColorSpace::ColorModel::Undefined || dataCs == QColorSpace::ColorModel::Undefined)
        return false;

    return (dataCs == cs); // Matching color models
}

inline bool qt_compatibleColorModelSource(QPixelFormat::ColorModel data, QColorSpace::ColorModel cs)
{
    if (qt_compatibleColorModelBase(data, cs))
        return true;

    if (data == QPixelFormat::ColorModel::Grayscale && cs == QColorSpace::ColorModel::Rgb)
        return true; // Can apply Rgb CS to Gray input data

    return false;
}

inline bool qt_compatibleColorModelTarget(QPixelFormat::ColorModel data, QColorSpace::ColorModel cs, QColorSpace::TransformModel tm)
{
    if (qt_compatibleColorModelBase(data, cs))
        return true;

    if (data == QPixelFormat::ColorModel::Grayscale && tm == QColorSpace::TransformModel::ThreeComponentMatrix)
        return true; // Can apply three-component matrix CS to gray output

    return false;
}

inline QImage::Format qt_maybeDataCompatibleAlphaVersion(QImage::Format format)
{
    switch (format) {
    case QImage::Format_RGB32:
        return QImage::Format_ARGB32_Premultiplied;
    case QImage::Format_RGB666:
        return QImage::Format_ARGB6666_Premultiplied;
    case QImage::Format_RGB444:
        return QImage::Format_ARGB4444_Premultiplied;
    case QImage::Format_RGBX8888:
        return QImage::Format_RGBA8888_Premultiplied;
    case QImage::Format_BGR30:
        return QImage::Format_A2BGR30_Premultiplied;
    case QImage::Format_RGB30:
        return QImage::Format_A2RGB30_Premultiplied;
    case QImage::Format_RGBX64:
        return QImage::Format_RGBA64_Premultiplied;
    case QImage::Format_RGBX16FPx4:
        return QImage::Format_RGBA16FPx4_Premultiplied;
    case QImage::Format_RGBX32FPx4:
        return QImage::Format_RGBA32FPx4_Premultiplied;
    case QImage::Format_ARGB32:
    case QImage::Format_ARGB32_Premultiplied:
    case QImage::Format_ARGB8565_Premultiplied:
    case QImage::Format_ARGB8555_Premultiplied:
    case QImage::Format_ARGB6666_Premultiplied:
    case QImage::Format_ARGB4444_Premultiplied:
    case QImage::Format_RGBA8888:
    case QImage::Format_RGBA8888_Premultiplied:
    case QImage::Format_A2BGR30_Premultiplied:
    case QImage::Format_A2RGB30_Premultiplied:
    case QImage::Format_Alpha8:
    case QImage::Format_RGBA64:
    case QImage::Format_RGBA64_Premultiplied:
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:
    case QImage::Format_RGBA32FPx4:
    case QImage::Format_RGBA32FPx4_Premultiplied:
        return format; // Already alpha versions
    case QImage::Format_Mono:
    case QImage::Format_MonoLSB:
    case QImage::Format_Indexed8:
    case QImage::Format_RGB16:
    case QImage::Format_RGB555:
    case QImage::Format_RGB888:
    case QImage::Format_BGR888:
    case QImage::Format_Grayscale8:
    case QImage::Format_Grayscale16:
    case QImage::Format_CMYK8888:
    case QImage::Format_Invalid:
    case QImage::NImageFormats:
        break;
    }
    return format; // No data-compatible alpha version
}

inline QImage::Format qt_opaqueVersionForPainting(QImage::Format format)
{
    QImage::Format toFormat = qt_opaqueVersion(format);
    // If we are switching depth anyway upgrade to RGB32
    if (qt_depthForFormat(format) != qt_depthForFormat(toFormat) && qt_depthForFormat(toFormat) <= 32)
        toFormat = QImage::Format_RGB32;
    return toFormat;
}

inline QImage::Format qt_alphaVersionForPainting(QImage::Format format)
{
    QImage::Format toFormat = qt_alphaVersion(format);
#if defined(__ARM_NEON__) || defined(__SSE2__) || defined(QT_COMPILER_SUPPORT_LSX)
    // If we are switching depth anyway and we have optimized ARGB32PM routines, upgrade to that.
    if (qt_depthForFormat(format) != qt_depthForFormat(toFormat) && qt_depthForFormat(toFormat) <= 32)
        toFormat = QImage::Format_ARGB32_Premultiplied;
#endif
    return toFormat;
}

Q_GUI_EXPORT QMap<QString, QString> qt_getImageText(const QImage &image, const QString &description);
Q_GUI_EXPORT QMap<QString, QString> qt_getImageTextFromDescription(const QString &description);

QT_END_NAMESPACE

#endif // QIMAGE_P_H

Coverage Report

Created: 2026-01-25 07:18

Line	Count	Source
1		// Copyright (C) 2021 The Qt Company Ltd.
2		// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4		#ifndef QIMAGE_P_H
5		#define QIMAGE_P_H
6
7		//
8		// W A R N I N G
9		// -------------
10		//
11		// This file is not part of the Qt API. It exists purely as an
12		// implementation detail. This header file may change from version to
13		// version without notice, or even be removed.
14		//
15		// We mean it.
16		//
17
18		#include <QtGui/private/qtguiglobal_p.h>
19		#include <QtGui/qcolorspace.h>
20		#include <QtGui/qimage.h>
21		#include <QtCore/private/qnumeric_p.h>
22		#include <QtCore/qlist.h>
23		#include <QtCore/qloggingcategory.h>
24		#include <QtCore/qmap.h>
25		#include <QtCore/qttypetraits.h>
26
27
28		QT_BEGIN_NAMESPACE
29
30		Q_DECLARE_LOGGING_CATEGORY(lcImageIo)
31
32		class QImageWriter;
33
34		struct Q_GUI_EXPORT QImageData { // internal image data
35		QImageData();
36		~QImageData();
37		static QImageData *create(const QSize &size, QImage::Format format);
38		static QImageData create(uchar data, int w, int h, qsizetype bpl, QImage::Format format, bool readOnly, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr);
39
40	7	static QImageData *get(QImage &img) noexcept { return img.d; }
41	7	static const QImageData *get(const QImage &img) noexcept { return img.d; }
42
43		QAtomicInt ref;
44
45		int width;
46		int height;
47		int depth;
48		qsizetype nbytes; // number of bytes data
49		qreal devicePixelRatio;
50		QList<QRgb> colortable;
51		uchar *data;
52		QImage::Format format; // invariants: > Format_Invalid, < NImageFormats
53		qsizetype bytes_per_line;
54		int ser_no; // serial number
55		int detach_no;
56
57		qreal dpmx; // dots per meter X (or 0)
58		qreal dpmy; // dots per meter Y (or 0)
59		QPoint offset; // offset in pixels
60
61		uint own_data : 1;
62		uint ro_data : 1;
63		uint has_alpha_clut : 1;
64		uint is_cached : 1;
65
66		QImageCleanupFunction cleanupFunction;
67		void* cleanupInfo;
68
69		bool checkForAlphaPixels() const;
70
71		// Convert the image in-place, minimizing memory reallocation
72		// Return false if the conversion cannot be done in-place.
73		bool convertInPlace(QImage::Format newFormat, Qt::ImageConversionFlags);
74
75		QMap<QString, QString> text;
76
77		bool doImageIO(const QImage image, QImageWriter io, int quality) const;
78
79		QPaintEngine *paintEngine;
80
81		QColorSpace colorSpace;
82
83		struct ImageSizeParameters {
84		qsizetype bytesPerLine;
85		qsizetype totalSize;
86	731k	bool isValid() const { return bytesPerLine > 0 && totalSize > 0; }
87		};
88		static ImageSizeParameters calculateImageParameters(qsizetype width, qsizetype height, qsizetype depth);
89		};
90
91		inline QImageData::ImageSizeParameters
92		QImageData::calculateImageParameters(qsizetype width, qsizetype height, qsizetype depth)
93	731k	{
94	731k	ImageSizeParameters invalid = { -1, -1 };
95	731k	if (height <= 0)
96	0	return invalid;
97
98		// calculate the size, taking care of overflows
99	731k	qsizetype bytes_per_line;
100	731k	if (qMulOverflow(width, depth, &bytes_per_line))
101	0	return invalid;
102	731k	if (qAddOverflow(bytes_per_line, qsizetype(31), &bytes_per_line))
103	0	return invalid;
104		// bytes per scanline (must be multiple of 4)
105	731k	bytes_per_line = (bytes_per_line >> 5) << 2; // can't overflow
106
107	731k	qsizetype total_size;
108	731k	if (qMulOverflow(height, bytes_per_line, &total_size))
109	0	return invalid;
110	731k	qsizetype dummy;
111	731k	if (qMulOverflow(height, qsizetype(sizeof(uchar *)), &dummy))
112	0	return invalid; // why is this here?
113		// Disallow images where width * depth calculations might overflow
114	731k	if (width > (INT_MAX - 31) / depth)
115	9	return invalid;
116
117	731k	return { bytes_per_line, total_size };
118	731k	}
119
120		typedef void (Image_Converter)(QImageData dest, const QImageData *src, Qt::ImageConversionFlags);
121		typedef bool (InPlace_Image_Converter)(QImageData data, Qt::ImageConversionFlags);
122
123		extern Image_Converter qimage_converter_map[QImage::NImageFormats][QImage::NImageFormats];
124		extern InPlace_Image_Converter qimage_inplace_converter_map[QImage::NImageFormats][QImage::NImageFormats];
125
126		void convert_generic(QImageData dest, const QImageData src, Qt::ImageConversionFlags);
127		void convert_generic_over_rgb64(QImageData dest, const QImageData src, Qt::ImageConversionFlags);
128		bool convert_generic_inplace(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);
129		bool convert_generic_inplace_over_rgb64(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);
130		#if QT_CONFIG(raster_fp)
131		void convert_generic_over_rgba32f(QImageData dest, const QImageData src, Qt::ImageConversionFlags);
132		bool convert_generic_inplace_over_rgba32f(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);
133		#endif
134
135		void dither_to_Mono(QImageData dst, const QImageData src, Qt::ImageConversionFlags flags, bool fromalpha);
136
137		const uchar *qt_get_bitflip_array();
138		Q_GUI_EXPORT void qGamma_correct_back_to_linear_cs(QImage *image);
139
140		#if defined(_M_ARM) && defined(_MSC_VER) // QTBUG-42038
141		#pragma optimize("", off)
142		#endif
143		inline int qt_depthForFormat(QImage::Format format)
144	1.17M	{
145	1.17M	int depth = 0;
146	1.17M	switch(format) {
147	0	case QImage::Format_Invalid:
148	0	case QImage::NImageFormats:
149	0	Q_UNREACHABLE();
150	214k	case QImage::Format_Mono:
151	218k	case QImage::Format_MonoLSB:
152	218k	depth = 1;
153	218k	break;
154	33.3k	case QImage::Format_Indexed8:
155	191k	case QImage::Format_Alpha8:
156	385k	case QImage::Format_Grayscale8:
157	385k	depth = 8;
158	385k	break;
159	122k	case QImage::Format_RGB32:
160	338k	case QImage::Format_ARGB32:
161	566k	case QImage::Format_ARGB32_Premultiplied:
162	566k	case QImage::Format_RGBX8888:
163	566k	case QImage::Format_RGBA8888:
164	566k	case QImage::Format_RGBA8888_Premultiplied:
165	566k	case QImage::Format_BGR30:
166	566k	case QImage::Format_A2BGR30_Premultiplied:
167	566k	case QImage::Format_RGB30:
168	566k	case QImage::Format_A2RGB30_Premultiplied:
169	566k	depth = 32;
170	566k	break;
171	0	case QImage::Format_RGB555:
172	0	case QImage::Format_RGB16:
173	0	case QImage::Format_RGB444:
174	0	case QImage::Format_ARGB4444_Premultiplied:
175	101	case QImage::Format_Grayscale16:
176	101	depth = 16;
177	101	break;
178	0	case QImage::Format_RGB666:
179	0	case QImage::Format_ARGB6666_Premultiplied:
180	0	case QImage::Format_ARGB8565_Premultiplied:
181	0	case QImage::Format_ARGB8555_Premultiplied:
182	0	case QImage::Format_RGB888:
183	0	case QImage::Format_BGR888:
184	0	depth = 24;
185	0	break;
186	0	case QImage::Format_RGBX64:
187	0	case QImage::Format_RGBA64:
188	0	case QImage::Format_RGBA64_Premultiplied:
189	0	case QImage::Format_RGBX16FPx4:
190	0	case QImage::Format_RGBA16FPx4:
191	0	case QImage::Format_RGBA16FPx4_Premultiplied:
192	0	depth = 64;
193	0	break;
194	0	case QImage::Format_RGBX32FPx4:
195	0	case QImage::Format_RGBA32FPx4:
196	0	case QImage::Format_RGBA32FPx4_Premultiplied:
197	0	depth = 128;
198	0	break;
199	452	case QImage::Format_CMYK8888:
200	452	depth = 32;
201	452	break;
202	1.17M	}
203	1.17M	return depth;
204	1.17M	}
205
206		#if defined(_M_ARM) && defined(_MSC_VER)
207		#pragma optimize("", on)
208		#endif
209
210		inline QImage::Format qt_opaqueVersion(QImage::Format format)
211	0	{
212	0	switch (format) {
213	0	case QImage::Format_ARGB8565_Premultiplied:
214	0	return QImage::Format_RGB16;
215	0	case QImage::Format_ARGB8555_Premultiplied:
216	0	return QImage::Format_RGB555;
217	0	case QImage::Format_ARGB6666_Premultiplied:
218	0	return QImage::Format_RGB666;
219	0	case QImage::Format_ARGB4444_Premultiplied:
220	0	return QImage::Format_RGB444;
221	0	case QImage::Format_RGBA8888:
222	0	case QImage::Format_RGBA8888_Premultiplied:
223	0	return QImage::Format_RGBX8888;
224	0	case QImage::Format_A2BGR30_Premultiplied:
225	0	return QImage::Format_BGR30;
226	0	case QImage::Format_A2RGB30_Premultiplied:
227	0	return QImage::Format_RGB30;
228	0	case QImage::Format_RGBA64:
229	0	case QImage::Format_RGBA64_Premultiplied:
230	0	return QImage::Format_RGBX64;
231	0	case QImage::Format_RGBA16FPx4:
232	0	case QImage::Format_RGBA16FPx4_Premultiplied:
233	0	return QImage::Format_RGBX16FPx4;
234	0	case QImage::Format_RGBA32FPx4:
235	0	case QImage::Format_RGBA32FPx4_Premultiplied:
236	0	return QImage::Format_RGBX32FPx4;
237	0	case QImage::Format_ARGB32_Premultiplied:
238	0	case QImage::Format_ARGB32:
239	0	return QImage::Format_RGB32;
240	0	case QImage::Format_RGB16:
241	0	case QImage::Format_RGB32:
242	0	case QImage::Format_RGB444:
243	0	case QImage::Format_RGB555:
244	0	case QImage::Format_RGB666:
245	0	case QImage::Format_RGB888:
246	0	case QImage::Format_BGR888:
247	0	case QImage::Format_RGBX8888:
248	0	case QImage::Format_BGR30:
249	0	case QImage::Format_RGB30:
250	0	case QImage::Format_RGBX64:
251	0	case QImage::Format_RGBX16FPx4:
252	0	case QImage::Format_RGBX32FPx4:
253	0	case QImage::Format_Grayscale8:
254	0	case QImage::Format_Grayscale16:
255	0	case QImage::Format_CMYK8888:
256	0	return format;
257	0	case QImage::Format_Mono:
258	0	case QImage::Format_MonoLSB:
259	0	case QImage::Format_Indexed8:
260	0	case QImage::Format_Alpha8:
261	0	case QImage::Format_Invalid:
262	0	case QImage::NImageFormats:
263	0	break;
264	0	}
265	0	return QImage::Format_RGB32;
266	0	}
267
268		inline QImage::Format qt_alphaVersion(QImage::Format format)
269	88.1k	{
270	88.1k	switch (format) {
271	3.49k	case QImage::Format_RGB32:
272	53.9k	case QImage::Format_ARGB32:
273	53.9k	return QImage::Format_ARGB32_Premultiplied;
274	0	case QImage::Format_RGB16:
275	0	return QImage::Format_ARGB8565_Premultiplied;
276	0	case QImage::Format_RGB555:
277	0	return QImage::Format_ARGB8555_Premultiplied;
278	0	case QImage::Format_RGB666:
279	0	return QImage::Format_ARGB6666_Premultiplied;
280	0	case QImage::Format_RGB444:
281	0	return QImage::Format_ARGB4444_Premultiplied;
282	0	case QImage::Format_RGBX8888:
283	0	case QImage::Format_RGBA8888:
284	0	return QImage::Format_RGBA8888_Premultiplied;
285	0	case QImage::Format_BGR30:
286	0	return QImage::Format_A2BGR30_Premultiplied;
287	0	case QImage::Format_RGB30:
288	0	return QImage::Format_A2RGB30_Premultiplied;
289	0	case QImage::Format_RGBX64:
290	0	case QImage::Format_RGBA64:
291	0	case QImage::Format_Grayscale16:
292	0	return QImage::Format_RGBA64_Premultiplied;
293	0	case QImage::Format_RGBX16FPx4:
294	0	case QImage::Format_RGBA16FPx4:
295	0	return QImage::Format_RGBA16FPx4_Premultiplied;
296	0	case QImage::Format_RGBX32FPx4:
297	0	case QImage::Format_RGBA32FPx4:
298	0	return QImage::Format_RGBA32FPx4_Premultiplied;
299	0	case QImage::Format_ARGB32_Premultiplied:
300	0	case QImage::Format_ARGB8565_Premultiplied:
301	0	case QImage::Format_ARGB8555_Premultiplied:
302	0	case QImage::Format_ARGB6666_Premultiplied:
303	0	case QImage::Format_ARGB4444_Premultiplied:
304	0	case QImage::Format_RGBA8888_Premultiplied:
305	0	case QImage::Format_A2BGR30_Premultiplied:
306	0	case QImage::Format_A2RGB30_Premultiplied:
307	0	case QImage::Format_RGBA64_Premultiplied:
308	0	case QImage::Format_RGBA16FPx4_Premultiplied:
309	0	case QImage::Format_RGBA32FPx4_Premultiplied:
310	0	return format;
311	27.6k	case QImage::Format_Mono:
312	27.6k	case QImage::Format_MonoLSB:
313	34.1k	case QImage::Format_Indexed8:
314	34.1k	case QImage::Format_RGB888:
315	34.1k	case QImage::Format_BGR888:
316	34.1k	case QImage::Format_Alpha8:
317	34.1k	case QImage::Format_Grayscale8:
318	34.1k	case QImage::Format_Invalid:
319	34.1k	case QImage::Format_CMYK8888:
320	34.1k	case QImage::NImageFormats:
321	34.1k	break;
322	88.1k	}
323	34.1k	return QImage::Format_ARGB32_Premultiplied;
324	88.1k	}
325
326		// Returns an opaque version that is compatible with format
327		inline QImage::Format qt_maybeDataCompatibleOpaqueVersion(QImage::Format format)
328	0	{
329	0	switch (format) {
330	0	case QImage::Format_ARGB6666_Premultiplied:
331	0	return QImage::Format_RGB666;
332	0	case QImage::Format_ARGB4444_Premultiplied:
333	0	return QImage::Format_RGB444;
334	0	case QImage::Format_RGBA8888:
335	0	case QImage::Format_RGBA8888_Premultiplied:
336	0	return QImage::Format_RGBX8888;
337	0	case QImage::Format_A2BGR30_Premultiplied:
338	0	return QImage::Format_BGR30;
339	0	case QImage::Format_A2RGB30_Premultiplied:
340	0	return QImage::Format_RGB30;
341	0	case QImage::Format_RGBA64:
342	0	case QImage::Format_RGBA64_Premultiplied:
343	0	return QImage::Format_RGBX64;
344	0	case QImage::Format_RGBA16FPx4:
345	0	case QImage::Format_RGBA16FPx4_Premultiplied:
346	0	return QImage::Format_RGBX16FPx4;
347	0	case QImage::Format_RGBA32FPx4:
348	0	case QImage::Format_RGBA32FPx4_Premultiplied:
349	0	return QImage::Format_RGBX32FPx4;
350	0	case QImage::Format_ARGB32_Premultiplied:
351	0	case QImage::Format_ARGB32:
352	0	return QImage::Format_RGB32;
353	0	case QImage::Format_RGB16:
354	0	case QImage::Format_RGB32:
355	0	case QImage::Format_RGB444:
356	0	case QImage::Format_RGB555:
357	0	case QImage::Format_RGB666:
358	0	case QImage::Format_RGB888:
359	0	case QImage::Format_BGR888:
360	0	case QImage::Format_RGBX8888:
361	0	case QImage::Format_BGR30:
362	0	case QImage::Format_RGB30:
363	0	case QImage::Format_RGBX64:
364	0	case QImage::Format_RGBX16FPx4:
365	0	case QImage::Format_RGBX32FPx4:
366	0	case QImage::Format_Grayscale8:
367	0	case QImage::Format_Grayscale16:
368	0	case QImage::Format_CMYK8888:
369	0	return format; // Already opaque
370	0	case QImage::Format_Mono:
371	0	case QImage::Format_MonoLSB:
372	0	case QImage::Format_Indexed8:
373	0	case QImage::Format_ARGB8565_Premultiplied:
374	0	case QImage::Format_ARGB8555_Premultiplied:
375	0	case QImage::Format_Alpha8:
376	0	case QImage::Format_Invalid:
377	0	case QImage::NImageFormats:
378	0	break;
379	0	}
380	0	return format; // No compatible opaque versions
381	0	}
382
383		constexpr QImage::Format qt_toUnpremultipliedFormat(QImage::Format format)
384	0	{
385	0	// Assumes input is already a premultiplied format with an unpremultiplied counterpart
386	0	// This abuses the fact unpremultiplied formats are always before their premultiplied counterparts.
387	0	return static_cast<QImage::Format>(qToUnderlying(format) - 1);
388	0	}
389
390		constexpr QImage::Format qt_toPremultipliedFormat(QImage::Format format)
391	0	{
392		// Assumes input is already an unpremultiplied format
393		// This abuses the fact unpremultiplied formats are always before their premultiplied counterparts.
394	0	return static_cast<QImage::Format>(qToUnderlying(format) + 1);
395	0	}
396
397		inline bool qt_highColorPrecision(QImage::Format format, bool opaque = false)
398	158k	{
399		// Formats with higher color precision than ARGB32_Premultiplied.
400	158k	switch (format) {
401	52.2k	case QImage::Format_ARGB32:
402	52.2k	case QImage::Format_RGBA8888:
403	52.2k	return !opaque;
404	0	case QImage::Format_BGR30:
405	0	case QImage::Format_RGB30:
406	0	case QImage::Format_A2BGR30_Premultiplied:
407	0	case QImage::Format_A2RGB30_Premultiplied:
408	0	case QImage::Format_RGBX64:
409	0	case QImage::Format_RGBA64:
410	0	case QImage::Format_RGBA64_Premultiplied:
411	0	case QImage::Format_Grayscale16:
412	0	case QImage::Format_RGBX16FPx4:
413	0	case QImage::Format_RGBA16FPx4:
414	0	case QImage::Format_RGBA16FPx4_Premultiplied:
415	0	case QImage::Format_RGBX32FPx4:
416	0	case QImage::Format_RGBA32FPx4:
417	0	case QImage::Format_RGBA32FPx4_Premultiplied:
418	0	return true;
419	105k	default:
420	105k	break;
421	158k	}
422	105k	return false;
423	158k	}
424
425		inline bool qt_fpColorPrecision(QImage::Format format)
426	1.40k	{
427	1.40k	switch (format) {
428	0	case QImage::Format_RGBX16FPx4:
429	0	case QImage::Format_RGBA16FPx4:
430	0	case QImage::Format_RGBA16FPx4_Premultiplied:
431	0	case QImage::Format_RGBX32FPx4:
432	0	case QImage::Format_RGBA32FPx4:
433	0	case QImage::Format_RGBA32FPx4_Premultiplied:
434	0	return true;
435	1.40k	default:
436	1.40k	break;
437	1.40k	}
438	1.40k	return false;
439	1.40k	}
440
441		inline QColorSpace::ColorModel qt_csColorData(QPixelFormat::ColorModel format)
442	13	{
443	13	switch (format) {
444	13	case QPixelFormat::ColorModel::RGB:
445	13	case QPixelFormat::ColorModel::BGR:
446	13	case QPixelFormat::ColorModel::Indexed:
447	13	return QColorSpace::ColorModel::Rgb;
448	0	case QPixelFormat::ColorModel::Alpha:
449	0	return QColorSpace::ColorModel::Undefined; // No valid colors
450	0	case QPixelFormat::ColorModel::Grayscale:
451	0	return QColorSpace::ColorModel::Gray;
452	0	case QPixelFormat::ColorModel::CMYK:
453	0	return QColorSpace::ColorModel::Cmyk;
454	0	default:
455	0	break;
456	13	}
457	0	return QColorSpace::ColorModel::Undefined;
458	13	}
459
460		inline bool qt_compatibleColorModelBase(QPixelFormat::ColorModel data, QColorSpace::ColorModel cs)
461	13	{
462	13	QColorSpace::ColorModel dataCs = qt_csColorData(data);
463
464	13	if (data == QPixelFormat::ColorModel::Alpha)
465	0	return true; // Alpha data has no colors and can be handled by any color space
466
467	13	if (cs == QColorSpace::ColorModel::Undefined \|\| dataCs == QColorSpace::ColorModel::Undefined)
468	0	return false;
469
470	13	return (dataCs == cs); // Matching color models
471	13	}
472
473		inline bool qt_compatibleColorModelSource(QPixelFormat::ColorModel data, QColorSpace::ColorModel cs)
474	13	{
475	13	if (qt_compatibleColorModelBase(data, cs))
476	13	return true;
477
478	0	if (data == QPixelFormat::ColorModel::Grayscale && cs == QColorSpace::ColorModel::Rgb)
479	0	return true; // Can apply Rgb CS to Gray input data
480
481	0	return false;
482	0	}
483
484		inline bool qt_compatibleColorModelTarget(QPixelFormat::ColorModel data, QColorSpace::ColorModel cs, QColorSpace::TransformModel tm)
485	0	{
486	0	if (qt_compatibleColorModelBase(data, cs))
487	0	return true;
488
489	0	if (data == QPixelFormat::ColorModel::Grayscale && tm == QColorSpace::TransformModel::ThreeComponentMatrix)
490	0	return true; // Can apply three-component matrix CS to gray output
491
492	0	return false;
493	0	}
494
495		inline QImage::Format qt_maybeDataCompatibleAlphaVersion(QImage::Format format)
496	0	{
497	0	switch (format) {
498	0	case QImage::Format_RGB32:
499	0	return QImage::Format_ARGB32_Premultiplied;
500	0	case QImage::Format_RGB666:
501	0	return QImage::Format_ARGB6666_Premultiplied;
502	0	case QImage::Format_RGB444:
503	0	return QImage::Format_ARGB4444_Premultiplied;
504	0	case QImage::Format_RGBX8888:
505	0	return QImage::Format_RGBA8888_Premultiplied;
506	0	case QImage::Format_BGR30:
507	0	return QImage::Format_A2BGR30_Premultiplied;
508	0	case QImage::Format_RGB30:
509	0	return QImage::Format_A2RGB30_Premultiplied;
510	0	case QImage::Format_RGBX64:
511	0	return QImage::Format_RGBA64_Premultiplied;
512	0	case QImage::Format_RGBX16FPx4:
513	0	return QImage::Format_RGBA16FPx4_Premultiplied;
514	0	case QImage::Format_RGBX32FPx4:
515	0	return QImage::Format_RGBA32FPx4_Premultiplied;
516	0	case QImage::Format_ARGB32:
517	0	case QImage::Format_ARGB32_Premultiplied:
518	0	case QImage::Format_ARGB8565_Premultiplied:
519	0	case QImage::Format_ARGB8555_Premultiplied:
520	0	case QImage::Format_ARGB6666_Premultiplied:
521	0	case QImage::Format_ARGB4444_Premultiplied:
522	0	case QImage::Format_RGBA8888:
523	0	case QImage::Format_RGBA8888_Premultiplied:
524	0	case QImage::Format_A2BGR30_Premultiplied:
525	0	case QImage::Format_A2RGB30_Premultiplied:
526	0	case QImage::Format_Alpha8:
527	0	case QImage::Format_RGBA64:
528	0	case QImage::Format_RGBA64_Premultiplied:
529	0	case QImage::Format_RGBA16FPx4:
530	0	case QImage::Format_RGBA16FPx4_Premultiplied:
531	0	case QImage::Format_RGBA32FPx4:
532	0	case QImage::Format_RGBA32FPx4_Premultiplied:
533	0	return format; // Already alpha versions
534	0	case QImage::Format_Mono:
535	0	case QImage::Format_MonoLSB:
536	0	case QImage::Format_Indexed8:
537	0	case QImage::Format_RGB16:
538	0	case QImage::Format_RGB555:
539	0	case QImage::Format_RGB888:
540	0	case QImage::Format_BGR888:
541	0	case QImage::Format_Grayscale8:
542	0	case QImage::Format_Grayscale16:
543	0	case QImage::Format_CMYK8888:
544	0	case QImage::Format_Invalid:
545	0	case QImage::NImageFormats:
546	0	break;
547	0	}
548	0	return format; // No data-compatible alpha version
549	0	}
550
551		inline QImage::Format qt_opaqueVersionForPainting(QImage::Format format)
552	0	{
553	0	QImage::Format toFormat = qt_opaqueVersion(format);
554		// If we are switching depth anyway upgrade to RGB32
555	0	if (qt_depthForFormat(format) != qt_depthForFormat(toFormat) && qt_depthForFormat(toFormat) <= 32)
556	0	toFormat = QImage::Format_RGB32;
557	0	return toFormat;
558	0	}
559
560		inline QImage::Format qt_alphaVersionForPainting(QImage::Format format)
561	88.1k	{
562	88.1k	QImage::Format toFormat = qt_alphaVersion(format);
563	88.1k	#if defined(__ARM_NEON__) \|\| defined(__SSE2__) \|\| defined(QT_COMPILER_SUPPORT_LSX)
564		// If we are switching depth anyway and we have optimized ARGB32PM routines, upgrade to that.
565	88.1k	if (qt_depthForFormat(format) != qt_depthForFormat(toFormat) && qt_depthForFormat(toFormat) <= 32)
566	34.1k	toFormat = QImage::Format_ARGB32_Premultiplied;
567	88.1k	#endif
568	88.1k	return toFormat;
569	88.1k	}
570
571		Q_GUI_EXPORT QMap<QString, QString> qt_getImageText(const QImage &image, const QString &description);
572		Q_GUI_EXPORT QMap<QString, QString> qt_getImageTextFromDescription(const QString &description);
573
574		QT_END_NAMESPACE
575
576		#endif // QIMAGE_P_H