// Copyright (C) 2016 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:significant reason:default

#ifndef QPAINTENGINE_RASTER_P_H

#define QPAINTENGINE_RASTER_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists for the convenience

// of other Qt classes.  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 "private/qpaintengineex_p.h"

#include "QtGui/qpainterpath.h"

#include "private/qdatabuffer_p.h"

#include "private/qdrawhelper_p.h"

#include "private/qpaintengine_p.h"

#include "private/qrasterizer_p.h"

#include "private/qstroker_p.h"

#include "private/qpainter_p.h"

#include "private/qtextureglyphcache_p.h"

#include "private/qoutlinemapper_p.h"

#include <stdlib.h>

QT_BEGIN_NAMESPACE

class QOutlineMapper;

class QRasterPaintEnginePrivate;

class QRasterBuffer;

class QClipData;

class QRasterPaintEngineState : public QPainterState

{

public:

    QRasterPaintEngineState(const QRasterPaintEngineState &other);

    QRasterPaintEngineState();

    ~QRasterPaintEngineState();

    QPen lastPen;

    QSpanData penData;

    QStrokerOps *stroker;

    uint strokeFlags;

    QBrush lastBrush;

    QSpanData brushData;

    uint fillFlags;

    uint pixmapFlags;

    int intOpacity;

    qreal txscale;

    QClipData *clip;

//     QRect clipRect;

//     QRegion clipRegion;

//     QPainter::RenderHints hints;

//     QPainter::CompositionMode compositionMode;

    uint dirty;

    struct Flags {

        uint has_clip_ownership : 1;        // should delete the clip member..

        uint fast_pen : 1;                  // cosmetic 1-width pens, using midpoint drawlines

        uint non_complex_pen : 1;           // can use rasterizer, rather than stroker

        uint antialiased : 1;

        uint bilinear : 1;

        uint fast_text : 1;

        uint tx_noshear : 1;

        uint fast_images : 1;

        uint cosmetic_brush : 1;

    };

    union {

        Flags flags;

        uint flag_bits;

    };

};

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

 * QRasterPaintEngine

 */

class Q_GUI_EXPORT QRasterPaintEngine : public QPaintEngineEx

{

    Q_DECLARE_PRIVATE(QRasterPaintEngine)

public:

    QRasterPaintEngine(QPaintDevice *device);

    ~QRasterPaintEngine();

    bool begin(QPaintDevice *device) override;

    bool end() override;

    void penChanged() override;

    void brushChanged() override;

    void brushOriginChanged() override;

    void opacityChanged() override;

    void compositionModeChanged() override;

    void renderHintsChanged() override;

    void transformChanged() override;

    void clipEnabledChanged() override;

    void setState(QPainterState *s) override;

    QPainterState *createState(QPainterState *orig) const override;

    inline QRasterPaintEngineState *state() {

        return static_cast<QRasterPaintEngineState *>(QPaintEngineEx::state());

    }

    inline const QRasterPaintEngineState *state() const {

        return static_cast<const QRasterPaintEngineState *>(QPaintEngineEx::state());

    }

    void updateBrush(const QBrush &brush);

    void updatePen(const QPen &pen);

    void updateMatrix(const QTransform &matrix);

    virtual void fillPath(const QPainterPath &path, QSpanData *fillData);

    virtual void fillPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);

    void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode) override;

    void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode) override;

    void drawEllipse(const QRectF &rect) override;

    void fillRect(const QRectF &rect, const QBrush &brush) override;

    void fillRect(const QRectF &rect, const QColor &color) override;

    void drawRects(const QRect  *rects, int rectCount) override;

    void drawRects(const QRectF *rects, int rectCount) override;

    void drawPixmap(const QPointF &p, const QPixmap &pm) override;

    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) override;

    void drawImage(const QPointF &p, const QImage &img) override;

    void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,

                   Qt::ImageConversionFlags flags = Qt::AutoColor) override;

    void drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &sr) override;

    void drawTextItem(const QPointF &p, const QTextItem &textItem) override;

    void drawLines(const QLine *line, int lineCount) override;

    void drawLines(const QLineF *line, int lineCount) override;

    void drawPoints(const QPointF *points, int pointCount) override;

    void drawPoints(const QPoint *points, int pointCount) override;

    void stroke(const QVectorPath &path, const QPen &pen) override;

    void fill(const QVectorPath &path, const QBrush &brush) override;

    void clip(const QVectorPath &path, Qt::ClipOperation op) override;

    void clip(const QRect &rect, Qt::ClipOperation op) override;

    void clip(const QRegion &region, Qt::ClipOperation op) override;

    inline const QClipData *clipData() const;

    void drawStaticTextItem(QStaticTextItem *textItem) override;

    virtual bool drawCachedGlyphs(int numGlyphs, const glyph_t *glyphs, const QFixedPoint *positions,

                                  QFontEngine *fontEngine);

    enum ClipType {

        RectClip,

        ComplexClip

    };

    ClipType clipType() const;

    QRectF clipBoundingRect() const;

#ifdef Q_OS_WIN

    void setDC(HDC hdc);

    HDC getDC() const;

    void releaseDC(HDC hdc) const;

    static bool clearTypeFontsEnabled();

#endif

    QRasterBuffer *rasterBuffer();

    void alphaPenBlt(const void* src, int bpl, int depth, int rx,int ry,int w,int h, bool useGammaCorrection);

    Type type() const override { return Raster; }

    QPoint coordinateOffset() const override;

    bool requiresPretransformedGlyphPositions(QFontEngine *fontEngine, const QTransform &m) const override;

    bool shouldDrawCachedGlyphs(QFontEngine *fontEngine, const QTransform &m) const override;

protected:

    QRasterPaintEngine(QRasterPaintEnginePrivate &d, QPaintDevice *);

private:

    friend struct QSpanData;

    friend class QBlitterPaintEngine;

    friend class QBlitterPaintEnginePrivate;

    void init();

    void fillRect(const QRectF &rect, QSpanData *data);

    void drawBitmap(const QPointF &pos, const QImage &image, QSpanData *fill);

    bool setClipRectInDeviceCoords(const QRect &r, Qt::ClipOperation op);

    QRect toNormalizedFillRect(const QRectF &rect);

    inline void ensureBrush(const QBrush &brush) {

        if (!qbrush_fast_equals(state()->lastBrush, brush) || state()->fillFlags)

            updateBrush(brush);

    }

    inline void ensureBrush() { ensureBrush(state()->brush); }

    inline void ensurePen(const QPen &pen) {

        if (!qpen_fast_equals(state()->lastPen, pen) || (pen.style() != Qt::NoPen && state()->strokeFlags))

            updatePen(pen);

    }

    inline void ensurePen() { ensurePen(state()->pen); }

    void updateOutlineMapper();

    inline void ensureOutlineMapper();

    void updateRasterState();

    inline void ensureRasterState() {

        if (state()->dirty)

            updateRasterState();

    }

};

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

 * QRasterPaintEnginePrivate

 */

class QRasterPaintEnginePrivate : public QPaintEngineExPrivate

{

    Q_DECLARE_PUBLIC(QRasterPaintEngine)

public:

    QRasterPaintEnginePrivate();

    void rasterizeLine_dashed(QLineF line, qreal width,

                              int *dashIndex, qreal *dashOffset, bool *inDash);

    void rasterize(QT_FT_Outline *outline, ProcessSpans callback, QSpanData *spanData, QRasterBuffer *rasterBuffer);

    void rasterize(QT_FT_Outline *outline, ProcessSpans callback, void *userData, QRasterBuffer *rasterBuffer);

    void updateMatrixData(QSpanData *spanData, const QBrush &brush, const QTransform &brushMatrix);

    void updateClipping();

    void systemStateChanged() override;

    void drawImage(const QPointF &pt, const QImage &img, SrcOverBlendFunc func,

                   const QRect &clip, int alpha, const QRect &sr = QRect());

    void blitImage(const QPointF &pt, const QImage &img,

                   const QRect &clip, const QRect &sr = QRect());

    QTransform brushMatrix() const {

        Q_Q(const QRasterPaintEngine);

        const QRasterPaintEngineState *s = q->state();

        QTransform m(s->matrix);

        m.translate(s->brushOrigin.x(), s->brushOrigin.y());

        return m;

    }

    bool isUnclipped_normalized(const QRect &rect) const;

    bool isUnclipped(const QRect &rect, int penWidth) const;

    bool isUnclipped(const QRectF &rect, int penWidth) const;

    ProcessSpans getPenFunc(const QRectF &rect, const QSpanData *data) const;

    ProcessSpans getBrushFunc(const QRect &rect, const QSpanData *data) const;

    ProcessSpans getBrushFunc(const QRectF &rect, const QSpanData *data) const;

    inline const QClipData *clip() const;

    void initializeRasterizer(QSpanData *data);

    void recalculateFastImages();

    bool canUseFastImageBlending(QPainter::CompositionMode mode, const QImage &image) const;

    bool canUseImageBlitting(QPainter::CompositionMode mode, const QImage &image, const QPointF &pt, const QRectF &sr) const;

    QPaintDevice *device;

    QScopedPointer<QOutlineMapper> outlineMapper;

    QScopedPointer<QRasterBuffer>  rasterBuffer;

#if defined (Q_OS_WIN)

    HDC hdc;

#endif

    QRect deviceRect;

    QRect deviceRectUnclipped;

    QStroker basicStroker;

    QScopedPointer<QDashStroker> dashStroker;

    QScopedPointer<QT_FT_Raster> grayRaster;

    QDataBuffer<QLineF> cachedLines;

    QSpanData image_filler;

    QSpanData image_filler_xform;

    QSpanData solid_color_filler;

    QFontEngine::GlyphFormat glyphCacheFormat;

    QScopedPointer<QClipData> baseClip;

    int deviceDepth;

    uint mono_surface : 1;

    uint outlinemapper_xform_dirty : 1;

    QScopedPointer<QRasterizer> rasterizer;

};

class QClipData {

public:

    QClipData(int height);

    ~QClipData();

    int clipSpanHeight;

    struct ClipLine {

        int count;

        QT_FT_Span *spans;

    } *m_clipLines;

    void initialize();

    inline ClipLine *clipLines() {

        if (!m_clipLines)

            initialize();

        return m_clipLines;

    }

    inline QT_FT_Span *spans() {

        if (!m_spans)

            initialize();

        return m_spans;

    }

    int allocated;

    int count;

    QT_FT_Span *m_spans;

    int xmin, xmax, ymin, ymax;

    QRect clipRect;

    QRegion clipRegion;

    uint enabled : 1;

    uint hasRectClip : 1;

    uint hasRegionClip : 1;

    void appendSpan(int x, int length, int y, int coverage);

    void appendSpans(const QT_FT_Span *s, int num);

    // ### Should optimize and actually kill the QSpans if the rect is

    // ### a subset of The current region. Thus the "fast" clipspan

    // ### callback can be used

    void setClipRect(const QRect &rect);

    void setClipRegion(const QRegion &region);

    void fixup();

};

inline void QClipData::appendSpan(int x, int length, int y, int coverage)

{

    Q_ASSERT(m_spans); // initialize() has to be called prior to adding spans..

    if (count == allocated) {

        allocated *= 2;

        m_spans = static_cast<QT_FT_Span*>(q_check_ptr(realloc(m_spans, allocated * sizeof(QT_FT_Span))));

    }

    m_spans[count].x = x;

    m_spans[count].len = length;

    m_spans[count].y = y;

    m_spans[count].coverage = coverage;

    ++count;

}

inline void QClipData::appendSpans(const QT_FT_Span *s, int num)

{

    Q_ASSERT(m_spans);

    if (count + num > allocated) {

        do {

            allocated *= 2;

        } while (count + num > allocated);

        m_spans = static_cast<QT_FT_Span*>(q_check_ptr(realloc(m_spans, allocated * sizeof(QT_FT_Span))));

    }

    memcpy(m_spans+count, s, num*sizeof(QT_FT_Span));

    count += num;

}

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

 * QRasterBuffer

 */

class QRasterBuffer

{

public:

    QRasterBuffer() : m_width(0), m_height(0), m_buffer(nullptr) { init(); }

    ~QRasterBuffer();

    void init();

    QImage::Format prepare(QImage *image);

    uchar *scanLine(int y) { Q_ASSERT(y>=0); Q_ASSERT(y<m_height); return m_buffer + y * bytes_per_line; }

    int width() const { return m_width; }

    int height() const { return m_height; }

    qsizetype bytesPerLine() const { return bytes_per_line; }

    int bytesPerPixel() const { return bytes_per_pixel; }

    template<typename T>

    int stride() { return static_cast<int>(bytes_per_line / sizeof(T)); }

int QRasterBuffer::stride<unsigned int>()

Line

Count

Source

409

990k

    int stride() { return static_cast<int>(bytes_per_line / sizeof(T)); }

Unexecuted instantiation: int QRasterBuffer::stride<unsigned short>()

    uchar *buffer() const { return m_buffer; }

    bool monoDestinationWithClut;

    QRgb destColor0;

    QRgb destColor1;

    QPainter::CompositionMode compositionMode;

    QImage::Format format;

    QColorSpace colorSpace;

    QImage colorizeBitmap(const QImage &image, const QColor &color);

private:

    int m_width;

    int m_height;

    qsizetype bytes_per_line;

    int bytes_per_pixel;

    uchar *m_buffer;

};

inline void QRasterPaintEngine::ensureOutlineMapper() {

    if (d_func()->outlinemapper_xform_dirty)

        updateOutlineMapper();

}

inline const QClipData *QRasterPaintEnginePrivate::clip() const {

    Q_Q(const QRasterPaintEngine);

    if (q->state() && q->state()->clip && q->state()->clip->enabled)

        return q->state()->clip;

    return baseClip.data();

}

inline const QClipData *QRasterPaintEngine::clipData() const {

    Q_D(const QRasterPaintEngine);

    if (state() && state()->clip && state()->clip->enabled)

        return state()->clip;

    return d->baseClip.data();

}

QT_END_NAMESPACE

#endif // QPAINTENGINE_RASTER_P_H