Attachment #888014 for bug #917343

Lines 4654-4660 QImage QImage::smoothScaled(int w, int h) const Link Here

(-)a/src/gui/image/qimage.cpp (-2 / +2 lines)
4654	case QImage::Format_RGBX8888:	4654	case QImage::Format_RGBX8888:
4655	#endif	4655	#endif
4656	case QImage::Format_RGBA8888_Premultiplied:	4656	case QImage::Format_RGBA8888_Premultiplied:
4657	#if QT_CONFIG(raster_64bit)	4657	#if 0
4658	case QImage::Format_RGBX64:	4658	case QImage::Format_RGBX64:
4659	case QImage::Format_RGBA64_Premultiplied:	4659	case QImage::Format_RGBA64_Premultiplied:
4660	break;	4660	break;
Lines 4845-4851 QImage Q_TRACE_INSTRUMENT(qtgui) QImage::transformed(const QTransform &matrix, Q Link Here
4845	case QImage::Format_RGBX8888:	4845	case QImage::Format_RGBX8888:
4846	#endif	4846	#endif
4847	case QImage::Format_RGBA8888_Premultiplied:	4847	case QImage::Format_RGBA8888_Premultiplied:
4848	#if QT_CONFIG(raster_64bit)	4848	#if 0
4849	case QImage::Format_RGBX64:	4849	case QImage::Format_RGBX64:
4850	case QImage::Format_RGBA64_Premultiplied:	4850	case QImage::Format_RGBA64_Premultiplied:
4851	#endif	4851	#endif




    { ::memcpy(dest, src, len * sizeof(Type)); }
};

#if 0
const Rgba64OperationsBase::Type Rgba64OperationsBase::clear = QRgba64::fromRgba64(0);

struct Rgba64OperationsC : public Rgba64OperationsBase

typedef Rgba64OperationsC Rgba64Operations;
#endif

#endif // 0

#if QT_CONFIG(raster_fp)


    comp_func_Clear_template<Argb32Operations>(dest, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_Clear_rgb64(QRgba64 *dest, int length, QRgba64, uint const_alpha)
{
    comp_func_Clear_template<Rgba64Operations>(dest, length, const_alpha);

    comp_func_Source_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_Source_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_Source_template<Rgba64Operations>(dest, length, color, const_alpha);

{
}

#if 0
void QT_FASTCALL comp_func_solid_Destination_rgb64(QRgba64 *, int, QRgba64, uint)
{
}

    comp_func_SourceOver_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_SourceOver_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_SourceOver_template<Rgba64Operations>(dest, length, color, const_alpha);

    comp_func_DestinationOver_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_DestinationOver_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_DestinationOver_template<Rgba64Operations>(dest, length, color, const_alpha);

    comp_func_SourceIn_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_SourceIn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_SourceIn_template<Rgba64Operations>(dest, length, color, const_alpha);

    comp_func_DestinationIn_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_DestinationIn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_DestinationIn_template<Rgba64Operations>(dest, length, color, const_alpha);

    comp_func_SourceOut_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_SourceOut_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_SourceOut_template<Rgba64Operations>(dest, length, color, const_alpha);

    comp_func_DestinationOut_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_DestinationOut_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_DestinationOut_template<Rgba64Operations>(dest, length, color, const_alpha);

    comp_func_SourceAtop_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_SourceAtop_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_SourceAtop_template<Rgba64Operations>(dest, length, color, const_alpha);

    comp_func_DestinationAtop_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_DestinationAtop_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_DestinationAtop_template<Rgba64Operations>(dest, length, color, const_alpha);

    comp_func_XOR_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_XOR_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_XOR_template<Rgba64Operations>(dest, length, color, const_alpha);

    {
        *dest = src;
    }
#if 0
    inline void store(QRgba64 *dest, const QRgba64 src) const
    {
        *dest = src;

    {
        store_template<Argb32Operations>(dest, src);
    }
#if 0
    inline void store(QRgba64 *dest, const QRgba64 src) const
    {
        store_template<Rgba64Operations>(dest, src);

    return 255 - qt_div_255((255 - sa) * (255 - da));
}

#if 0
static inline uint mix_alpha_rgb64(uint da, uint sa)
{
    return 65535U - qt_div_65535((65535U - sa) * (65535U - da));

    comp_func_Plus_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_solid_Plus_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_Plus_template<Rgba64Operations>(dest, length, color, const_alpha);

        comp_func_solid_Multiply_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
static inline uint multiply_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    return qt_div_65535(src * dst + src * (65535U - da) + dst * (65535U - sa));

        comp_func_Multiply_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_Multiply_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

        comp_func_solid_Screen_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_solid_Screen_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{

        comp_func_Screen_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_Screen_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

        comp_func_solid_Overlay_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
static inline uint overlay_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    const uint temp = src * (65535U - da) + dst * (65535U - sa);

        comp_func_Overlay_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_Overlay_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

        comp_func_solid_Darken_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
static inline uint darken_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    return qt_div_65535(qMin(src * da, dst * sa) + src * (65535U - da) + dst * (65535U - sa));

        comp_func_Darken_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_Darken_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

}


#if 0
static inline uint lighten_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    return qt_div_65535(qMax(src * da, dst * sa) + src * (65535U - da) + dst * (65535U - sa));

        comp_func_Lighten_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_Lighten_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

        comp_func_solid_ColorDodge_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
static inline uint color_dodge_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
{
    const qint64 sa_da = sa * da;

        comp_func_ColorDodge_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_ColorDodge_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

        comp_func_solid_ColorBurn_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
static inline uint color_burn_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
{
    const qint64 src_da = src * da;

        comp_func_ColorBurn_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_ColorBurn_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

        comp_func_solid_HardLight_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
static inline uint hardlight_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    const uint temp = src * (65535U - da) + dst * (65535U - sa);

        comp_func_HardLight_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_HardLight_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

        comp_func_solid_SoftLight_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
static inline uint soft_light_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
{
    const qint64 src2 = src << 1;

        comp_func_SoftLight_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_SoftLight_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

        comp_func_solid_Difference_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
static inline uint difference_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
{
    return src + dst - qt_div_65535(2 * qMin(src * da, dst * sa));

        comp_func_Difference_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_Difference_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

        comp_func_solid_Exclusion_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void QT_FASTCALL comp_func_solid_Exclusion_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{

        comp_func_Exclusion_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if 0
template <typename T>
static inline void comp_func_Exclusion_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{

};

CompositionFunctionSolid64 qt_functionForModeSolid64_C[] = {
#if 0
        comp_func_solid_SourceOver_rgb64,
        comp_func_solid_DestinationOver_rgb64,
        comp_func_solid_Clear_rgb64,

};

CompositionFunction64 qt_functionForMode64_C[] = {
#if 0
        comp_func_SourceOver_rgb64,
        comp_func_DestinationOver_rgb64,
        comp_func_Clear_rgb64,




    fetch1Pixel<QPixelLayout::BPP32FPx4>,
};

#if 0
static void QT_FASTCALL convertRGBA64ToRGBA64PM(QRgba64 *buffer, int count)
{
    for (int i = 0; i < count; ++i)

    destFetch,          // Format_RGBA32FPx4_Premultiplied
};

#if 0
static QRgba64 *QT_FASTCALL destFetch64(QRgba64 *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
{
    const QPixelLayout *layout = &qPixelLayouts[rasterBuffer->format];

    destStore,          // Format_RGBA32FPx4_Premultiplied
};

#if 0
static void QT_FASTCALL destStore64(QRasterBuffer *rasterBuffer, int x, int y, const QRgba64 *buffer, int length)
{
    auto store = qStoreFromRGBA64PM[rasterBuffer->format];

    return buffer;
}

#if 0
static const QRgba64 *QT_FASTCALL fetchUntransformed64(QRgba64 *buffer, const Operator *,
                                                       const QSpanData *data, int y, int x, int length)
{

    return buffer;
}

#if 0
template<TextureBlendType blendType>  /* either BlendTransformed or BlendTransformedTiled */
static const QRgba64 *QT_FASTCALL fetchTransformed64(QRgba64 *buffer, const Operator *, const QSpanData *data,
                                                     int y, int x, int length)

    return buffer;
}

#if 0
template<TextureBlendType blendType>
static const QRgba64 *QT_FASTCALL fetchTransformedBilinear64_uint32(QRgba64 *buffer, const QSpanData *data,
                                                                    int y, int x, int length)

    return sourceFetchGeneric[blendType];
}

#if 0
static const SourceFetchProc64 sourceFetchGeneric64[NBlendTypes] = {
    fetchUntransformed64,                                     // Untransformed
    fetchUntransformed64,                                     // Tiled

    return data->colorTable32[qt_gradient_clamp(data, ipos)];
}

#if 0
static const QRgba64& qt_gradient_pixel64_fixed(const QGradientData *data, int fixed_pos)
{
    int ipos = (fixed_pos + (FIXPT_SIZE / 2)) >> FIXPT_BITS;

    }
};

#if 0
class GradientBase64
{
public:

    return qt_fetch_linear_gradient_template<GradientBase32, uint>(buffer, op, data, y, x, length);
}

#if 0
static const QRgba64 * QT_FASTCALL qt_fetch_linear_gradient_rgb64(QRgba64 *buffer, const Operator *op, const QSpanData *data,
                                                                 int y, int x, int length)
{


static SourceFetchProc qt_fetch_radial_gradient = qt_fetch_radial_gradient_plain;

#if 0
const QRgba64 * QT_FASTCALL qt_fetch_radial_gradient_rgb64(QRgba64 *buffer, const Operator *op, const QSpanData *data,
                                                        int y, int x, int length)
{

    return qt_fetch_conical_gradient_template<GradientBase32, uint>(buffer, data, y, x, length);
}

#if 0
static const QRgba64 * QT_FASTCALL qt_fetch_conical_gradient_rgb64(QRgba64 *buffer, const Operator *, const QSpanData *data,
                                                                   int y, int x, int length)
{

extern CompositionFunctionSolidFP qt_functionForModeSolidFP_C[];

static const CompositionFunctionSolid *functionForModeSolid = qt_functionForModeSolid_C;
#if 0
static const CompositionFunctionSolid64 *functionForModeSolid64 = qt_functionForModeSolid64_C;
#endif
#if QT_CONFIG(raster_fp)

extern CompositionFunctionFP qt_functionForModeFP_C[];

static const CompositionFunction *functionForMode = qt_functionForMode_C;
#if 0
static const CompositionFunction64 *functionForMode64 = qt_functionForMode64_C;
#endif
#if QT_CONFIG(raster_fp)

        solidSource = !data->gradient.alphaColor;
        getLinearGradientValues(&op.linear, data);
        op.srcFetch = qt_fetch_linear_gradient;
#if 0
        op.srcFetch64 = qt_fetch_linear_gradient_rgb64;
#endif
#if QT_CONFIG(raster_fp)

        solidSource = !data->gradient.alphaColor;
        getRadialGradientValues(&op.radial, data);
        op.srcFetch = qt_fetch_radial_gradient;
#if 0
        op.srcFetch64 = qt_fetch_radial_gradient_rgb64;
#endif
#if QT_CONFIG(raster_fp)

    case QSpanData::ConicalGradient:
        solidSource = !data->gradient.alphaColor;
        op.srcFetch = qt_fetch_conical_gradient;
#if 0
        op.srcFetch64 = qt_fetch_conical_gradient_rgb64;
#endif
#if QT_CONFIG(raster_fp)

    case QSpanData::Texture:
        solidSource = !data->texture.hasAlpha;
        op.srcFetch = getSourceFetch(getBlendType(data), data->texture.format);
#if 0
        op.srcFetch64 = getSourceFetch64(getBlendType(data), data->texture.format);;
#endif
#if QT_CONFIG(raster_fp)

        Q_UNREACHABLE();
        break;
    }
#if !0
    op.srcFetch64 = nullptr;
#endif
#if !QT_CONFIG(raster_fp)

        op.mode = QPainter::CompositionMode_Source;

    op.destFetch = destFetchProc[data->rasterBuffer->format];
#if 0
    op.destFetch64 = destFetchProc64[data->rasterBuffer->format];
#else
    op.destFetch64 = nullptr;

            // But don't clear passthrough destFetch as they are just as fast and save destStore.
            if (op.destFetch != destFetchARGB32P)
                op.destFetch = destFetchUndefined;
#if 0
            if (op.destFetch64 != destFetchRGB64)
                op.destFetch64 = destFetch64Undefined;
#endif

    op.destStore = destStoreProc[data->rasterBuffer->format];
    op.funcSolid = functionForModeSolid[op.mode];
    op.func = functionForMode[op.mode];
#if 0
    op.destStore64 = destStoreProc64[data->rasterBuffer->format];
    op.funcSolid64 = functionForModeSolid64[op.mode];
    op.func64 = functionForMode64[op.mode];


static void blend_color_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
#if 0
    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
    const Operator op = getOperator(data, nullptr, 0);
    if (!op.funcSolid64) {

    }
};

#if 0
class BlendSrcGenericRGB64 : public QBlendBase
{
public:

    handleSpans<BlendSrcGeneric>(count, spans, data, op);
}

#if 0
static void blend_src_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
    QSpanData *data = reinterpret_cast<QSpanData *>(userData);

    QT_THREAD_PARALLEL_FILLS(function);
}

#if 0
static void blend_untransformed_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
    QSpanData *data = reinterpret_cast<QSpanData *>(userData);

    QT_THREAD_PARALLEL_FILLS(function);
}

#if 0
static void blend_tiled_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
    QSpanData *data = reinterpret_cast<QSpanData *>(userData);

    blend_src_generic                   // TransformedBilinearTiled
};

#if 0
static const ProcessSpans processTextureSpansGeneric64[NBlendTypes] = {
    blend_untransformed_generic_rgb64,  // Untransformed
    blend_tiled_generic_rgb64,          // Tiled

    case QImage::Format_RGBA32FPx4:
    case QImage::Format_RGBA32FPx4_Premultiplied:
#endif
#if 0
        proc = processTextureSpansGeneric64[blendType];
        break;
#endif // 0
#if QT_CONFIG(raster_fp)
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:

    while (count--) {
        int y = spans->y;

#if 0
        data->solidColor = qt_gradient_pixel64_fixed(&data->gradient, yinc * y + off);
#else
        data->solidColor = qt_gradient_pixel_fixed(&data->gradient, yinc * y + off);

    case QImage::Format_RGBA32FPx4:
    case QImage::Format_RGBA32FPx4_Premultiplied:
#endif
#if 0
        if (isVerticalGradient)
            return blend_vertical_gradient<blend_color_generic_rgb64>(count, spans, userData);
        return blend_src_generic_rgb64(count, spans, userData);
#endif // 0
#if QT_CONFIG(raster_fp)
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:

    }
}

#if 0

static inline void grayBlendPixel(QRgba64 &dst, int coverage, QRgba64 srcLinear, const QColorTrcLut *colorProfile)
{

    }
}

#if 0
static inline void rgbBlendPixel(QRgba64 &dst, int coverage, QRgba64 slinear, const QColorTrcLut *colorProfile)
{
    // Do a gammacorrected RGB alphablend...

        qStoreFromRGBA64PM[QImage::Format_RGBA8888] = storeRGBA8888FromRGBA64PM_sse4;
        qStoreFromRGBA64PM[QImage::Format_RGBX64] = storeRGBx64FromRGBA64PM_sse4;
        qStoreFromRGBA64PM[QImage::Format_RGBA64] = storeRGBA64FromRGBA64PM_sse4;
#if 0
        destStoreProc64[QImage::Format_ARGB32] = destStore64ARGB32_sse4;
        destStoreProc64[QImage::Format_RGBA8888] = destStore64RGBA8888_sse4;
#endif

        qt_functionForMode_C[QPainter::CompositionMode_Source] = comp_func_Source_avx2;
        qt_functionForMode_C[QPainter::CompositionMode_SourceOver] = comp_func_SourceOver_avx2;
        qt_functionForModeSolid_C[QPainter::CompositionMode_SourceOver] = comp_func_solid_SourceOver_avx2;
#if 0
        extern void QT_FASTCALL comp_func_Source_rgb64_avx2(QRgba64 *destPixels, const QRgba64 *srcPixels, int length, uint const_alpha);
        extern void QT_FASTCALL comp_func_SourceOver_rgb64_avx2(QRgba64 *destPixels, const QRgba64 *srcPixels, int length, uint const_alpha);
        extern void QT_FASTCALL comp_func_solid_SourceOver_rgb64_avx2(QRgba64 *destPixels, int length, QRgba64 color, uint const_alpha);




        BLEND_SOURCE_OVER_ARGB32_WITH_CONST_ALPHA_AVX2(dst, src, length, const_alpha);
}

#if 0
void QT_FASTCALL comp_func_SourceOver_rgb64_avx2(QRgba64 *dst, const QRgba64 *src, int length, uint const_alpha)
{
    Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]

    }
}

#if 0
void QT_FASTCALL comp_func_Source_rgb64_avx2(QRgba64 *dst, const QRgba64 *src, int length, uint const_alpha)
{
    Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]

    }
}

#if 0
void QT_FASTCALL comp_func_solid_SourceOver_rgb64_avx2(QRgba64 *destPixels, int length, QRgba64 color, uint const_alpha)
{
    Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]

Lines 265-271 struct QGradientData Link Here

(-)a/src/gui/painting/qdrawhelper_p.h (-2 / +2 lines)
265	#define GRADIENT_STOPTABLE_SIZE 1024	265	#define GRADIENT_STOPTABLE_SIZE 1024
266	#define GRADIENT_STOPTABLE_SIZE_SHIFT 10	266	#define GRADIENT_STOPTABLE_SIZE_SHIFT 10
267		267
268	#if QT_CONFIG(raster_64bit) \|\| QT_CONFIG(raster_fp)	268	#if 0 \|\| QT_CONFIG(raster_fp)
269	const QRgba64 *colorTable64; //[GRADIENT_STOPTABLE_SIZE];	269	const QRgba64 *colorTable64; //[GRADIENT_STOPTABLE_SIZE];
270	#endif	270	#endif
271	const QRgb *colorTable32; //[GRADIENT_STOPTABLE_SIZE];	271	const QRgb *colorTable32; //[GRADIENT_STOPTABLE_SIZE];
Lines 370-376 static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos) Link Here
370	return data->colorTable32[qt_gradient_clamp(data, ipos)];	370	return data->colorTable32[qt_gradient_clamp(data, ipos)];
371	}	371	}
372		372
373	#if QT_CONFIG(raster_64bit)	373	#if 0
374	static inline const QRgba64& qt_gradient_pixel64(const QGradientData *data, qreal pos)	374	static inline const QRgba64& qt_gradient_pixel64(const QGradientData *data, qreal pos)
375	{	375	{
376	int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));	376	int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));

Lines 473-479 template Link Here

(-)a/src/gui/painting/qdrawhelper_sse4.cpp (-1 / +1 lines)
473	void QT_FASTCALL storeA2RGB30PMFromARGB32PM_sse4<PixelOrderRGB>(uchar dest, const uint src, int index, int count,	473	void QT_FASTCALL storeA2RGB30PMFromARGB32PM_sse4<PixelOrderRGB>(uchar dest, const uint src, int index, int count,
474	const QList<QRgb> , QDitherInfo );	474	const QList<QRgb> , QDitherInfo );
475		475
476	#if QT_CONFIG(raster_64bit)	476	#if 0
477	void QT_FASTCALL destStore64ARGB32_sse4(QRasterBuffer rasterBuffer, int x, int y, const QRgba64 buffer, int length)	477	void QT_FASTCALL destStore64ARGB32_sse4(QRasterBuffer rasterBuffer, int x, int y, const QRgba64 buffer, int length)
478	{	478	{
479	uint dest = (uint)rasterBuffer->scanLine(y) + x;	479	uint dest = (uint)rasterBuffer->scanLine(y) + x;

Lines 541-547 static void qt_qimageScaleAARGBA_down_xy(QImageScaleInfo isi, unsigned int des Link Here

(-)a/src/gui/painting/qimagescale.cpp (-2 / +2 lines)
541	multithread_pixels_function(isi, dh, scaleSection);	541	multithread_pixels_function(isi, dh, scaleSection);
542	}	542	}
543		543
544	#if QT_CONFIG(raster_64bit)	544	#if 0
545	static void qt_qimageScaleRgba64_up_x_down_y(QImageScaleInfo isi, QRgba64 dest,	545	static void qt_qimageScaleRgba64_up_x_down_y(QImageScaleInfo isi, QRgba64 dest,
546	int dw, int dh, int dow, int sow);	546	int dw, int dh, int dow, int sow);
547		547
Lines 1202-1208 QImage qSmoothScaleImage(const QImage &src, int dw, int dh) Link Here
1202	dw, dh, dw, src.bytesPerLine() / 16);	1202	dw, dh, dw, src.bytesPerLine() / 16);
1203	else	1203	else
1204	#endif	1204	#endif
1205	#if QT_CONFIG(raster_64bit)	1205	#if 0
1206	if (src.depth() > 32)	1206	if (src.depth() > 32)
1207	qt_qimageScaleRgba64(scaleinfo, (QRgba64 *)buffer.scanLine(0),	1207	qt_qimageScaleRgba64(scaleinfo, (QRgba64 *)buffer.scanLine(0),
1208	dw, dh, dw, src.bytesPerLine() / 8);	1208	dw, dh, dw, src.bytesPerLine() / 8);





            auto cacheInfo = qt_gradient_cache()->getBuffer(*g, alpha);
            gradient.colorTable32 = cacheInfo->buffer32;
#if 0 || QT_CONFIG(raster_fp)
            gradient.colorTable64 = cacheInfo->buffer64;
#endif
            cachedGradient = std::move(cacheInfo);


            auto cacheInfo = qt_gradient_cache()->getBuffer(*g, alpha);
            gradient.colorTable32 = cacheInfo->buffer32;
#if 0 || QT_CONFIG(raster_fp)
            gradient.colorTable64 = cacheInfo->buffer64;
#endif
            cachedGradient = std::move(cacheInfo);


            auto cacheInfo = qt_gradient_cache()->getBuffer(*g, alpha);
            gradient.colorTable32 = cacheInfo->buffer32;
#if 0 || QT_CONFIG(raster_fp)
            gradient.colorTable64 = cacheInfo->buffer64;
#endif
            cachedGradient = std::move(cacheInfo);




    int sizes[] = { 2, 3, 4, 6, 7, 8, 10, 16, 20, 32, 40, 64, 100, 101, 128, 0 };
    QImage::Format formats[] = { QImage::Format_RGB32,
                                 QImage::Format_ARGB32_Premultiplied,
#if 0
                                 QImage::Format_RGBX64,
                                 QImage::Format_RGBA64_Premultiplied,
#endif

    QTest::addColumn<QImage::Format>("format");

    QTest::newRow("RGB32") << QImage::Format_RGB32;
#if 0
    QTest::newRow("RGBx64") << QImage::Format_RGBX64;
#endif
#if QT_CONFIG(raster_fp)

    QTest::newRow("argb32pm -> argb6666pm (no dither)") << rgb32 << QImage::Format_ARGB6666_Premultiplied << 0 << 64;
    QTest::newRow("argb32pm -> argb6666pm (dithering)") << rgb32 << QImage::Format_ARGB6666_Premultiplied << int(Qt::PreferDither | Qt::OrderedDither) << 129;

#if 0
    QImage rgb30(1024, 16, QImage::Format_RGB30);
    QLinearGradient gradient30(QRectF(rgb30.rect()).topLeft(), QRectF(rgb30.rect()).topRight());
    gradient30.setColorAt(0.0, QColor(0, 0, 0));




    void gradientPixelFormat_data();
    void gradientPixelFormat();

#if 0
    void linearGradientRgb30_data();
    void linearGradientRgb30();
    void radialGradientRgb30_data();

    }
}

#if 0
void tst_QPainter::linearGradientRgb30_data()
{
    QTest::addColumn<QColor>("stop0");

                                     << QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 85) << 85;
    QTest::newRow("ARGB_PM over RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
                                        << QPainter::CompositionMode_SourceOver << qRgba(85, 0, 0, 85) << 85;
#if 0
    QTest::newRow("ARGB@85 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
                                          << QPainter::CompositionMode_Source << qRgba(255, 0, 0, 85) << 85;
    QTest::newRow("ARGB@120 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32

#endif
    QTest::newRow("ARGB_PM@85 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
                                             << QPainter::CompositionMode_Source << qRgba(85, 0, 0, 85) << 85;
#if 0
    QTest::newRow("ARGB_PM@180 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
                                              << QPainter::CompositionMode_Source << qRgba(180, 0, 0, 180) << 170;
#endif

Return to bug 917343

Lines 360-366 void QT_FASTCALL comp_func_SourceOver_avx2(uint destPixels, const uint srcPixe Link Here

(-)a/src/gui/painting/qdrawhelper_avx2.cpp (-3 / +3 lines)
360	BLEND_SOURCE_OVER_ARGB32_WITH_CONST_ALPHA_AVX2(dst, src, length, const_alpha);	360	BLEND_SOURCE_OVER_ARGB32_WITH_CONST_ALPHA_AVX2(dst, src, length, const_alpha);
361	}	361	}
362		362
363	#if QT_CONFIG(raster_64bit)	363	#if 0
364	void QT_FASTCALL comp_func_SourceOver_rgb64_avx2(QRgba64 dst, const QRgba64 src, int length, uint const_alpha)	364	void QT_FASTCALL comp_func_SourceOver_rgb64_avx2(QRgba64 dst, const QRgba64 src, int length, uint const_alpha)
365	{	365	{
366	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]	366	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]
Lines 485-491 void QT_FASTCALL comp_func_Source_avx2(uint dst, const uint src, int length, u Link Here
485	}	485	}
486	}	486	}
487		487
488	#if QT_CONFIG(raster_64bit)	488	#if 0
489	void QT_FASTCALL comp_func_Source_rgb64_avx2(QRgba64 dst, const QRgba64 src, int length, uint const_alpha)	489	void QT_FASTCALL comp_func_Source_rgb64_avx2(QRgba64 dst, const QRgba64 src, int length, uint const_alpha)
490	{	490	{
491	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]	491	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]
Lines 586-592 void QT_FASTCALL comp_func_solid_SourceOver_avx2(uint *destPixels, int length, u Link Here
586	}	586	}
587	}	587	}
588		588
589	#if QT_CONFIG(raster_64bit)	589	#if 0
590	void QT_FASTCALL comp_func_solid_SourceOver_rgb64_avx2(QRgba64 *destPixels, int length, QRgba64 color, uint const_alpha)	590	void QT_FASTCALL comp_func_solid_SourceOver_rgb64_avx2(QRgba64 *destPixels, int length, QRgba64 color, uint const_alpha)
591	{	591	{
592	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]	592	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]

Lines 4499-4505 void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode Link Here

(-)a/src/gui/painting/qpaintengine_raster.cpp (-3 / +3 lines)
4499		4499
4500	auto cacheInfo = qt_gradient_cache()->getBuffer(*g, alpha);	4500	auto cacheInfo = qt_gradient_cache()->getBuffer(*g, alpha);
4501	gradient.colorTable32 = cacheInfo->buffer32;	4501	gradient.colorTable32 = cacheInfo->buffer32;
4502	#if QT_CONFIG(raster_64bit) \|\| QT_CONFIG(raster_fp)	4502	#if 0 \|\| QT_CONFIG(raster_fp)
4503	gradient.colorTable64 = cacheInfo->buffer64;	4503	gradient.colorTable64 = cacheInfo->buffer64;
4504	#endif	4504	#endif
4505	cachedGradient = std::move(cacheInfo);	4505	cachedGradient = std::move(cacheInfo);
Lines 4523-4529 void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode Link Here
4523		4523
4524	auto cacheInfo = qt_gradient_cache()->getBuffer(*g, alpha);	4524	auto cacheInfo = qt_gradient_cache()->getBuffer(*g, alpha);
4525	gradient.colorTable32 = cacheInfo->buffer32;	4525	gradient.colorTable32 = cacheInfo->buffer32;
4526	#if QT_CONFIG(raster_64bit) \|\| QT_CONFIG(raster_fp)	4526	#if 0 \|\| QT_CONFIG(raster_fp)
4527	gradient.colorTable64 = cacheInfo->buffer64;	4527	gradient.colorTable64 = cacheInfo->buffer64;
4528	#endif	4528	#endif
4529	cachedGradient = std::move(cacheInfo);	4529	cachedGradient = std::move(cacheInfo);
Lines 4551-4557 void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode Link Here
4551		4551
4552	auto cacheInfo = qt_gradient_cache()->getBuffer(*g, alpha);	4552	auto cacheInfo = qt_gradient_cache()->getBuffer(*g, alpha);
4553	gradient.colorTable32 = cacheInfo->buffer32;	4553	gradient.colorTable32 = cacheInfo->buffer32;
4554	#if QT_CONFIG(raster_64bit) \|\| QT_CONFIG(raster_fp)	4554	#if 0 \|\| QT_CONFIG(raster_fp)
4555	gradient.colorTable64 = cacheInfo->buffer64;	4555	gradient.colorTable64 = cacheInfo->buffer64;
4556	#endif	4556	#endif
4557	cachedGradient = std::move(cacheInfo);	4557	cachedGradient = std::move(cacheInfo);

Lines 1799-1805 void tst_QImage::smoothScale2_data() Link Here

(-)a/tests/auto/gui/image/qimage/tst_qimage.cpp (-3 / +3 lines)
1799	int sizes[] = { 2, 3, 4, 6, 7, 8, 10, 16, 20, 32, 40, 64, 100, 101, 128, 0 };	1799	int sizes[] = { 2, 3, 4, 6, 7, 8, 10, 16, 20, 32, 40, 64, 100, 101, 128, 0 };
1800	QImage::Format formats[] = { QImage::Format_RGB32,	1800	QImage::Format formats[] = { QImage::Format_RGB32,
1801	QImage::Format_ARGB32_Premultiplied,	1801	QImage::Format_ARGB32_Premultiplied,
1802	#if QT_CONFIG(raster_64bit)	1802	#if 0
1803	QImage::Format_RGBX64,	1803	QImage::Format_RGBX64,
1804	QImage::Format_RGBA64_Premultiplied,	1804	QImage::Format_RGBA64_Premultiplied,
1805	#endif	1805	#endif
Lines 1966-1972 void tst_QImage::smoothScale4_data() Link Here
1966	QTest::addColumn<QImage::Format>("format");	1966	QTest::addColumn<QImage::Format>("format");
1967		1967
1968	QTest::newRow("RGB32") << QImage::Format_RGB32;	1968	QTest::newRow("RGB32") << QImage::Format_RGB32;
1969	#if QT_CONFIG(raster_64bit)	1969	#if 0
1970	QTest::newRow("RGBx64") << QImage::Format_RGBX64;	1970	QTest::newRow("RGBx64") << QImage::Format_RGBX64;
1971	#endif	1971	#endif
1972	#if QT_CONFIG(raster_fp)	1972	#if QT_CONFIG(raster_fp)
Lines 3814-3820 void tst_QImage::ditherGradient_data() Link Here
3814	QTest::newRow("argb32pm -> argb6666pm (no dither)") << rgb32 << QImage::Format_ARGB6666_Premultiplied << 0 << 64;	3814	QTest::newRow("argb32pm -> argb6666pm (no dither)") << rgb32 << QImage::Format_ARGB6666_Premultiplied << 0 << 64;
3815	QTest::newRow("argb32pm -> argb6666pm (dithering)") << rgb32 << QImage::Format_ARGB6666_Premultiplied << int(Qt::PreferDither \| Qt::OrderedDither) << 129;	3815	QTest::newRow("argb32pm -> argb6666pm (dithering)") << rgb32 << QImage::Format_ARGB6666_Premultiplied << int(Qt::PreferDither \| Qt::OrderedDither) << 129;
3816		3816
3817	#if QT_CONFIG(raster_64bit)	3817	#if 0
3818	QImage rgb30(1024, 16, QImage::Format_RGB30);	3818	QImage rgb30(1024, 16, QImage::Format_RGB30);
3819	QLinearGradient gradient30(QRectF(rgb30.rect()).topLeft(), QRectF(rgb30.rect()).topRight());	3819	QLinearGradient gradient30(QRectF(rgb30.rect()).topLeft(), QRectF(rgb30.rect()).topRight());
3820	gradient30.setColorAt(0.0, QColor(0, 0, 0));	3820	gradient30.setColorAt(0.0, QColor(0, 0, 0));

Lines 163-169 private slots: Link Here

(-)a/tests/auto/gui/painting/qpainter/tst_qpainter.cpp (-4 / +4 lines)
163	void gradientPixelFormat_data();	163	void gradientPixelFormat_data();
164	void gradientPixelFormat();	164	void gradientPixelFormat();
165		165
166	#if QT_CONFIG(raster_64bit)	166	#if 0
167	void linearGradientRgb30_data();	167	void linearGradientRgb30_data();
168	void linearGradientRgb30();	168	void linearGradientRgb30();
169	void radialGradientRgb30_data();	169	void radialGradientRgb30_data();
Lines 3966-3972 void tst_QPainter::gradientInterpolation() Link Here
3966	}	3966	}
3967	}	3967	}
3968		3968
3969	#if QT_CONFIG(raster_64bit)	3969	#if 0
3970	void tst_QPainter::linearGradientRgb30_data()	3970	void tst_QPainter::linearGradientRgb30_data()
3971	{	3971	{
3972	QTest::addColumn<QColor>("stop0");	3972	QTest::addColumn<QColor>("stop0");
Lines 5036-5042 void tst_QPainter::blendARGBonRGB_data() Link Here
5036	<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 85) << 85;	5036	<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 85) << 85;
5037	QTest::newRow("ARGB_PM over RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied	5037	QTest::newRow("ARGB_PM over RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
5038	<< QPainter::CompositionMode_SourceOver << qRgba(85, 0, 0, 85) << 85;	5038	<< QPainter::CompositionMode_SourceOver << qRgba(85, 0, 0, 85) << 85;
5039	#if QT_CONFIG(raster_64bit)	5039	#if 0
5040	QTest::newRow("ARGB@85 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32	5040	QTest::newRow("ARGB@85 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
5041	<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 85) << 85;	5041	<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 85) << 85;
5042	QTest::newRow("ARGB@120 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32	5042	QTest::newRow("ARGB@120 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
Lines 5044-5050 void tst_QPainter::blendARGBonRGB_data() Link Here
5044	#endif	5044	#endif
5045	QTest::newRow("ARGB_PM@85 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied	5045	QTest::newRow("ARGB_PM@85 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
5046	<< QPainter::CompositionMode_Source << qRgba(85, 0, 0, 85) << 85;	5046	<< QPainter::CompositionMode_Source << qRgba(85, 0, 0, 85) << 85;
5047	#if QT_CONFIG(raster_64bit)	5047	#if 0
5048	QTest::newRow("ARGB_PM@180 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied	5048	QTest::newRow("ARGB_PM@180 source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
5049	<< QPainter::CompositionMode_Source << qRgba(180, 0, 0, 180) << 170;	5049	<< QPainter::CompositionMode_Source << qRgba(180, 0, 0, 180) << 170;
5050	#endif	5050	#endif