Attachment #888015 for bug #917343




    if (!converter && format > QImage::Format_Indexed8 && d->format > QImage::Format_Indexed8) {
        if (qt_highColorPrecision(d->format, !destLayout->hasAlphaChannel)
                && qt_highColorPrecision(format, !hasAlphaChannel())) {
#if 0
            if (qt_fpColorPrecision(d->format) && qt_fpColorPrecision(format))
                converter = convert_generic_over_rgba32f;
            else

        src.convertTo(QImage::Format_RGBA64_Premultiplied);
        break;
#endif
#if 0
    case QImage::Format_RGBX32FPx4:
    case QImage::Format_RGBA32FPx4_Premultiplied:
        break;

        // any direct ones are probably better even if not inplace.
        if (qt_highColorPrecision(newFormat, !qPixelLayouts[newFormat].hasAlphaChannel)
                && qt_highColorPrecision(format, !qPixelLayouts[format].hasAlphaChannel)) {
#if 0
            if (qt_fpColorPrecision(format) && qt_fpColorPrecision(newFormat))
                return convert_generic_inplace_over_rgba32f(this, newFormat, flags);
#endif

Lines 279-285 void convert_generic_over_rgb64(QImageData dest, const QImageData src, Qt::Ima Link Here

(-)a/src/gui/image/qimage_conversions.cpp (-2 / +2 lines)
279	#endif	279	#endif
280	}	280	}
281		281
282	#if QT_CONFIG(raster_fp)	282	#if 0
283	void convert_generic_over_rgba32f(QImageData dest, const QImageData src, Qt::ImageConversionFlags)	283	void convert_generic_over_rgba32f(QImageData dest, const QImageData src, Qt::ImageConversionFlags)
284	{	284	{
285	Q_ASSERT(dest->format >= QImage::Format_RGBX16FPx4);	285	Q_ASSERT(dest->format >= QImage::Format_RGBX16FPx4);
Lines 556-562 bool convert_generic_inplace_over_rgb64(QImageData *data, QImage::Format dst_for Link Here
556	return true;	556	return true;
557	}	557	}
558		558
559	#if QT_CONFIG(raster_fp)	559	#if 0
560	bool convert_generic_inplace_over_rgba32f(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags)	560	bool convert_generic_inplace_over_rgba32f(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags)
561	{	561	{
562	Q_ASSERT(data->format >= QImage::Format_RGBX16FPx4);	562	Q_ASSERT(data->format >= QImage::Format_RGBX16FPx4);

Lines 124-130 void convert_generic(QImageData dest, const QImageData src, Qt::ImageConversio Link Here

(-)a/src/gui/image/qimage_p.h (-1 / +1 lines)
124	void convert_generic_over_rgb64(QImageData dest, const QImageData src, Qt::ImageConversionFlags);	124	void convert_generic_over_rgb64(QImageData dest, const QImageData src, Qt::ImageConversionFlags);
125	bool convert_generic_inplace(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);	125	bool convert_generic_inplace(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);
126	bool convert_generic_inplace_over_rgb64(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);	126	bool convert_generic_inplace_over_rgb64(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);
127	#if QT_CONFIG(raster_fp)	127	#if 0
128	void convert_generic_over_rgba32f(QImageData dest, const QImageData src, Qt::ImageConversionFlags);	128	void convert_generic_over_rgba32f(QImageData dest, const QImageData src, Qt::ImageConversionFlags);
129	bool convert_generic_inplace_over_rgba32f(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);	129	bool convert_generic_inplace_over_rgba32f(QImageData *data, QImage::Format dst_format, Qt::ImageConversionFlags);
130	#endif	130	#endif





#endif // 0

#if 0

static inline QRgbaFloat32 qRgbaFloat32(float r, float g, float b, float a)
{

typedef RgbaFPOperationsC RgbaFPOperations;
#endif

#endif // 0

/*
  result = 0

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_Clear_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32, uint const_alpha)
{
    comp_func_Clear_template<RgbaFPOperations>(dest, length, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_Source_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_Source_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_Destination_rgbafp(QRgbaFloat32 *, int, QRgbaFloat32, uint)
{
}

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_SourceOver_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_SourceOver_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_DestinationOver_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_DestinationOver_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_SourceIn_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_SourceIn_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_DestinationIn_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_DestinationIn_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_SourceOut_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_SourceOut_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_DestinationOut_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_DestinationOut_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_SourceAtop_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_SourceAtop_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_DestinationAtop_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_DestinationAtop_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_XOR_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_XOR_template<RgbaFPOperations>(dest, length, color, const_alpha);

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

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

}
#endif

#if 0
static inline float mix_alpha_rgbafp(float da, float sa)
{
    return 1.0f - (1.0f - sa) * (1.0f - da);

}
#endif

#if 0
void QT_FASTCALL comp_func_solid_Plus_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_Plus_template<RgbaFPOperations>(dest, length, color, const_alpha);

}
#endif

#if 0
static inline float multiply_op_rgbafp(float dst, float src, float da, float sa)
{
    return src * dst + src * (1.0f - da) + dst * (1.0f - sa);

}
#endif

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

}
#endif

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

}
#endif

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

}
#endif

#if 0
static inline float overlay_op_rgbafp(float dst, float src, float da, float sa)
{
    const float temp = src * (1.0f - da) + dst * (1.0f - sa);

}
#endif

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

}
#endif

#if 0
static inline float darken_op_rgbafp(float dst, float src, float da, float sa)
{
    return qMin(src * da, dst * sa) + src * (1.0f - da) + dst * (1.0f - sa);

}
#endif

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

}
#endif

#if 0
static inline float lighten_op_rgbafp(float dst, float src, float da, float sa)
{
    return qMax(src * da, dst * sa) + src * (1.0f - da) + dst * (1.0f - sa);

}
#endif

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

}
#endif

#if 0
static inline float color_dodge_op_rgbafp(float dst, float src, float da, float sa)
{
    const float sa_da = sa * da;

}
#endif

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

}
#endif

#if 0
static inline float color_burn_op_rgbafp(float dst, float src, float da, float sa)
{
    const float src_da = src * da;

}
#endif

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

}
#endif

#if 0
static inline float hardlight_op_rgbafp(float dst, float src, float da, float sa)
{
    const float temp = src * (1.0f - da) + dst * (1.0f - sa);

}
#endif

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


#endif

#if 0
static inline float soft_light_op_rgbafp(float dst, float src, float da, float sa)
{
    const float src2 = src * 2;

}
#endif

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

}
#endif

#if 0
static inline float difference_op_rgbafp(float dst, float src, float da, float sa)
{
    return src + dst - (2 * qMin(src * da, dst * sa));

}
#endif

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

}
#endif

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

}
#endif

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

};

CompositionFunctionSolidFP qt_functionForModeSolidFP_C[] = {
#if 0
        comp_func_solid_SourceOver_rgbafp,
        comp_func_solid_DestinationOver_rgbafp,
        comp_func_solid_Clear_rgbafp,

};

CompositionFunctionFP qt_functionForModeFP_C[] = {
#if 0
        comp_func_SourceOver_rgbafp,
        comp_func_DestinationOver_rgbafp,
        comp_func_Clear_rgbafp,




};
#endif

#if 0
static void QT_FASTCALL convertRGBA64PMToRGBA32F(QRgbaFloat32 *buffer, const quint64 *src, int count)
{
    const auto *in = reinterpret_cast<const QRgba64 *>(src);

};
#endif

#if 0
static QRgbaFloat32 *QT_FASTCALL destFetchFP(QRgbaFloat32 *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
{
    return const_cast<QRgbaFloat32 *>(qFetchToRGBA32F[rasterBuffer->format](buffer, rasterBuffer->scanLine(y), x, length, nullptr, nullptr));

};
#endif

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

}
#endif

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

}
#endif

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

}
#endif

#if 0
static void interpolate_simple_rgba32f(QRgbaFloat32 *b, const QRgbaFloat32 *buf1, const QRgbaFloat32 *buf2, int len,
                                       int &fx, int fdx,
                                       int &fy, int fdy)

        return fetchTransformedBilinearFP_uint32<blendType>(buffer, data, y, x, length);
    }
}
#endif // 0

// FetchUntransformed can have more specialized methods added depending on SIMD features.
static SourceFetchProc sourceFetchUntransformed[QImage::NImageFormats] = {

}
#endif

#if 0
static const SourceFetchProcFP sourceFetchGenericFP[NBlendTypes] = {
    fetchUntransformedFP,                                     // Untransformed
    fetchUntransformedFP,                                     // Tiled

}
#endif

#if 0
static inline QRgbaFloat32 qt_gradient_pixelFP(const QGradientData *data, qreal pos)
{
    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));

};
#endif

#if 0
class GradientBaseFP
{
public:

    return qt_fetch_linear_gradient_template<GradientBase64, QRgba64>(buffer, op, data, y, x, length);
}
#endif
#if 0
static const QRgbaFloat32 * QT_FASTCALL qt_fetch_linear_gradient_rgbfp(QRgbaFloat32 *buffer, const Operator *op, const QSpanData *data,
                                                                   int y, int x, int length)
{

}
#endif

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

}
#endif

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

#if 0
static const CompositionFunctionSolid64 *functionForModeSolid64 = qt_functionForModeSolid64_C;
#endif
#if 0
static const CompositionFunctionSolidFP *functionForModeSolidFP = qt_functionForModeSolidFP_C;
#endif


#if 0
static const CompositionFunction64 *functionForMode64 = qt_functionForMode64_C;
#endif
#if 0
static const CompositionFunctionFP *functionForModeFP = qt_functionForModeFP_C;
#endif


#if 0
        op.srcFetch64 = qt_fetch_linear_gradient_rgb64;
#endif
#if 0
        op.srcFetchFP = qt_fetch_linear_gradient_rgbfp;
#endif
        break;

#if 0
        op.srcFetch64 = qt_fetch_radial_gradient_rgb64;
#endif
#if 0
        op.srcFetchFP = qt_fetch_radial_gradient_rgbfp;
#endif
        break;

#if 0
        op.srcFetch64 = qt_fetch_conical_gradient_rgb64;
#endif
#if 0
        op.srcFetchFP = qt_fetch_conical_gradient_rgbfp;
#endif
        break;

#if 0
        op.srcFetch64 = getSourceFetch64(getBlendType(data), data->texture.format);;
#endif
#if 0
        op.srcFetchFP = getSourceFetchFP(getBlendType(data), data->texture.format);
#endif
        break;

#if !0
    op.srcFetch64 = nullptr;
#endif
#if !0
    op.srcFetchFP = nullptr;
#endif


#else
    op.destFetch64 = nullptr;
#endif
#if 0
    op.destFetchFP = destFetchProcFP[data->rasterBuffer->format];
#else
    op.destFetchFP = nullptr;

            if (op.destFetch64 != destFetchRGB64)
                op.destFetch64 = destFetch64Undefined;
#endif
#if 0
            if (op.destFetchFP != destFetchRGBFP)
                op.destFetchFP = destFetchFPUndefined;
#endif

    op.funcSolid64 = nullptr;
    op.func64 = nullptr;
#endif
#if 0
    op.destStoreFP = destStoreFP;
    op.funcSolidFP = functionForModeSolidFP[op.mode];
    op.funcFP = functionForModeFP[op.mode];


static void blend_color_generic_fp(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.funcSolidFP || !op.destFetchFP) {

};
#endif

#if 0
class BlendSrcGenericRGBFP : public QBlendBase
{
public:

}
#endif

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

}
#endif

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

}
#endif

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

};
#endif

#if 0
static const ProcessSpans processTextureSpansGenericFP[NBlendTypes] = {
    blend_untransformed_generic_fp,     // Untransformed
    blend_tiled_generic_fp,             // Tiled

    case QImage::Format_RGBA64:
    case QImage::Format_RGBA64_Premultiplied:
    case QImage::Format_Grayscale16:
#if !0
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:

        proc = processTextureSpansGeneric64[blendType];
        break;
#endif // 0
#if 0
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:

    case QImage::Format_RGBX64:
    case QImage::Format_RGBA64:
    case QImage::Format_RGBA64_Premultiplied:
#if !0
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:

            return blend_vertical_gradient<blend_color_generic_rgb64>(count, spans, userData);
        return blend_src_generic_rgb64(count, spans, userData);
#endif // 0
#if 0
    case QImage::Format_RGBX16FPx4:
    case QImage::Format_RGBA16FPx4:
    case QImage::Format_RGBA16FPx4_Premultiplied:

        destStoreProc64[QImage::Format_ARGB32] = destStore64ARGB32_sse4;
        destStoreProc64[QImage::Format_RGBA8888] = destStore64RGBA8888_sse4;
#endif
#if 0
        extern const QRgbaFloat32 *QT_FASTCALL fetchRGBA32FToRGBA32F_sse4(QRgbaFloat32 *buffer, const uchar *src, int index, int count, const QList<QRgb> *, QDitherInfo *);
        extern void QT_FASTCALL storeRGBX32FFromRGBA32F_sse4(uchar *dest, const QRgbaFloat32 *src, int index, int count, const QList<QRgb> *, QDitherInfo *);
        extern void QT_FASTCALL storeRGBA32FFromRGBA32F_sse4(uchar *dest, const QRgbaFloat32 *src, int index, int count, const QList<QRgb> *, QDitherInfo *);
        qFetchToRGBA32F[QImage::Format_RGBA32FPx4] = fetchRGBA32FToRGBA32F_sse4;
        qStoreFromRGBA32F[QImage::Format_RGBX32FPx4] = storeRGBX32FFromRGBA32F_sse4;
        qStoreFromRGBA32F[QImage::Format_RGBA32FPx4] = storeRGBA32FFromRGBA32F_sse4;
#endif // 0
    }
#endif


        qt_functionForMode64_C[QPainter::CompositionMode_SourceOver] = comp_func_SourceOver_rgb64_avx2;
        qt_functionForModeSolid64_C[QPainter::CompositionMode_SourceOver] = comp_func_solid_SourceOver_rgb64_avx2;
#endif
#if 0
        extern void QT_FASTCALL comp_func_Source_rgbafp_avx2(QRgbaFloat32 *destPixels, const QRgbaFloat32 *srcPixels, int length, uint const_alpha);
        extern void QT_FASTCALL comp_func_SourceOver_rgbafp_avx2(QRgbaFloat32 *destPixels, const QRgbaFloat32 *srcPixels, int length, uint const_alpha);
        extern void QT_FASTCALL comp_func_solid_Source_rgbafp_avx2(QRgbaFloat32 *destPixels, int length, QRgbaFloat32 color, uint const_alpha);

        qPixelLayouts[QImage::Format_RGBA16FPx4_Premultiplied].fetchToRGBA64PM = fetchRGBA16FPMToRGBA64PM_avx2;
        qPixelLayouts[QImage::Format_RGBA16FPx4_Premultiplied].storeFromARGB32PM = storeRGB16FFromRGB32_avx2;
        qPixelLayouts[QImage::Format_RGBA16FPx4_Premultiplied].storeFromRGB32 = storeRGB16FFromRGB32_avx2;
#if 0
        extern const QRgbaFloat32 *QT_FASTCALL fetchRGBA16FToRGBA32F_avx2(QRgbaFloat32 *buffer, const uchar *src, int index, int count, const QList<QRgb> *, QDitherInfo *);
        extern void QT_FASTCALL storeRGBX16FFromRGBA32F_avx2(uchar *dest, const QRgbaFloat32 *src, int index, int count, const QList<QRgb> *, QDitherInfo *);
        extern void QT_FASTCALL storeRGBA16FFromRGBA32F_avx2(uchar *dest, const QRgbaFloat32 *src, int index, int count, const QList<QRgb> *, QDitherInfo *);
        qFetchToRGBA32F[QImage::Format_RGBA16FPx4] = fetchRGBA16FToRGBA32F_avx2;
        qStoreFromRGBA32F[QImage::Format_RGBX16FPx4] = storeRGBX16FFromRGBA32F_avx2;
        qStoreFromRGBA32F[QImage::Format_RGBA16FPx4] = storeRGBA16FFromRGBA32F_avx2;
#endif // 0
    }

#endif




}
#endif

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

}
#endif

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

}
#endif

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

    }
}

#if 0
const QRgbaFloat32 *QT_FASTCALL fetchRGBA16FToRGBA32F_avx2(QRgbaFloat32 *buffer, const uchar *src, int index, int count,
                                                       const QList<QRgb> *, QDitherInfo *)
{




#define GRADIENT_STOPTABLE_SIZE 1024
#define GRADIENT_STOPTABLE_SIZE_SHIFT 10

#if 0 || 0
    const QRgba64 *colorTable64; //[GRADIENT_STOPTABLE_SIZE];
#endif
    const QRgb *colorTable32; //[GRADIENT_STOPTABLE_SIZE];

}
#endif // __SSE2__

#if 0
static inline QRgbaFloat32 multiplyAlpha_rgba32f(QRgbaFloat32 c, float a)
{
    return QRgbaFloat32 { c.r * a, c.g * a, c.b * a, c.a * a };

    return xtop;
#endif
}
#endif // 0

static inline uint BYTE_MUL_RGB16(uint x, uint a) {
    a += 1;

Lines 515-521 void QT_FASTCALL storeRGBx64FromRGBA64PM_sse4(uchar dest, const QRgba64 src, i Link Here

(-)a/src/gui/painting/qdrawhelper_sse4.cpp (-1 / +1 lines)
515	convertRGBA64FromRGBA64PM_sse4<true>(d, src, count);	515	convertRGBA64FromRGBA64PM_sse4<true>(d, src, count);
516	}	516	}
517		517
518	#if QT_CONFIG(raster_fp)	518	#if 0
519	const QRgbaFloat32 QT_FASTCALL fetchRGBA32FToRGBA32F_sse4(QRgbaFloat32 buffer, const uchar *src, int index, int count,	519	const QRgbaFloat32 QT_FASTCALL fetchRGBA32FToRGBA32F_sse4(QRgbaFloat32 buffer, const uchar *src, int index, int count,
520	const QList<QRgb> , QDitherInfo )	520	const QList<QRgb> , QDitherInfo )
521	{	521	{

Lines 756-762 static void qt_qimageScaleRgba64_down_xy(QImageScaleInfo isi, QRgba64 dest, Link Here

(-)a/src/gui/painting/qimagescale.cpp (-2 / +2 lines)
756	}	756	}
757	#endif	757	#endif
758		758
759	#if QT_CONFIG(raster_fp)	759	#if 0
760	static void qt_qimageScaleRgbaFP_up_x_down_y(QImageScaleInfo isi, QRgbaFloat32 dest,	760	static void qt_qimageScaleRgbaFP_up_x_down_y(QImageScaleInfo isi, QRgbaFloat32 dest,
761	int dw, int dh, int dow, int sow);	761	int dw, int dh, int dow, int sow);
762		762
Lines 1196-1202 QImage qSmoothScaleImage(const QImage &src, int dw, int dh) Link Here
1196	return QImage();	1196	return QImage();
1197	}	1197	}
1198		1198
1199	#if QT_CONFIG(raster_fp)	1199	#if 0
1200	if (qt_fpColorPrecision(src.format()))	1200	if (qt_fpColorPrecision(src.format()))
1201	qt_qimageScaleRgbaFP(scaleinfo, (QRgbaFloat32 *)buffer.scanLine(0),	1201	qt_qimageScaleRgbaFP(scaleinfo, (QRgbaFloat32 *)buffer.scanLine(0),
1202	dw, dh, dw, src.bytesPerLine() / 16);	1202	dw, dh, dw, src.bytesPerLine() / 16);





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


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


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

Lines 1955-1961 ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[QImage::NImageFormats] = { Link Here

(-)a/src/gui/painting/qpixellayout.cpp (-2 / +2 lines)
1955	storeRGBA32FPMFromRGBA64PM,	1955	storeRGBA32FPMFromRGBA64PM,
1956	};	1956	};
1957		1957
1958	#if QT_CONFIG(raster_fp)	1958	#if 0
1959	static void QT_FASTCALL convertToRgbaF32(QRgbaFloat32 dest, const uint src, int length)	1959	static void QT_FASTCALL convertToRgbaF32(QRgbaFloat32 dest, const uint src, int length)
1960	{	1960	{
1961	for (int i = 0; i < length; ++i)	1961	for (int i = 0; i < length; ++i)
Lines 2316-2321 ConvertAndStorePixelsFuncFP qStoreFromRGBA32F[QImage::NImageFormats] = { Link Here
2316	storeRGBA32FFromRGBA32F,	2316	storeRGBA32FFromRGBA32F,
2317	storeRGBA32FPMFromRGBA32F,	2317	storeRGBA32FPMFromRGBA32F,
2318	};	2318	};
2319	#endif // QT_CONFIG(raster_fp)	2319	#endif // 0
2320		2320
2321	QT_END_NAMESPACE	2321	QT_END_NAMESPACE

Lines 320-326 struct QPixelLayout Link Here

(-)a/src/gui/painting/qpixellayout_p.h (-1 / +1 lines)
320		320
321	extern ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[QImage::NImageFormats];	321	extern ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[QImage::NImageFormats];
322		322
323	#if QT_CONFIG(raster_fp)	323	#if 0
324	extern ConvertToFPFunc qConvertToRGBA32F[QImage::NImageFormats];	324	extern ConvertToFPFunc qConvertToRGBA32F[QImage::NImageFormats];
325	extern FetchAndConvertPixelsFuncFP qFetchToRGBA32F[QImage::NImageFormats];	325	extern FetchAndConvertPixelsFuncFP qFetchToRGBA32F[QImage::NImageFormats];
326	extern ConvertAndStorePixelsFuncFP qStoreFromRGBA32F[QImage::NImageFormats];	326	extern ConvertAndStorePixelsFuncFP qStoreFromRGBA32F[QImage::NImageFormats];

Lines 1803-1809 void tst_QImage::smoothScale2_data() Link Here

(-)a/tests/auto/gui/image/qimage/tst_qimage.cpp (-2 / +2 lines)
1803	QImage::Format_RGBX64,	1803	QImage::Format_RGBX64,
1804	QImage::Format_RGBA64_Premultiplied,	1804	QImage::Format_RGBA64_Premultiplied,
1805	#endif	1805	#endif
1806	#if QT_CONFIG(raster_fp)	1806	#if 0
1807	QImage::Format_RGBX32FPx4,	1807	QImage::Format_RGBX32FPx4,
1808	QImage::Format_RGBA32FPx4_Premultiplied,	1808	QImage::Format_RGBA32FPx4_Premultiplied,
1809	#endif	1809	#endif
Lines 1969-1975 void tst_QImage::smoothScale4_data() Link Here
1969	#if 0	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 0
1973	QTest::newRow("RGBx32FP") << QImage::Format_RGBX32FPx4;	1973	QTest::newRow("RGBx32FP") << QImage::Format_RGBX32FPx4;
1974	#endif	1974	#endif
1975	}	1975	}

Lines 282-288 private slots: Link Here

(-)a/tests/auto/gui/painting/qpainter/tst_qpainter.cpp (-2 / +2 lines)
282		282
283	void drawImageAtPointF();	283	void drawImageAtPointF();
284	void scaledDashes();	284	void scaledDashes();
285	#if QT_CONFIG(raster_fp)	285	#if 0
286	void hdrColors();	286	void hdrColors();
287	#endif	287	#endif
288		288
Lines 5500-5506 void tst_QPainter::scaledDashes() Link Here
5500	QVERIFY(backFound);	5500	QVERIFY(backFound);
5501	}	5501	}
5502		5502
5503	#if QT_CONFIG(raster_fp)	5503	#if 0
5504	void tst_QPainter::hdrColors()	5504	void tst_QPainter::hdrColors()
5505	{	5505	{
5506	QImage img(10, 10, QImage::Format_RGBA32FPx4_Premultiplied);	5506	QImage img(10, 10, QImage::Format_RGBA32FPx4_Premultiplied);

Return to bug 917343

Lines 2189-2195 QImage QImage::convertToFormat_helper(Format format, Qt::ImageConversionFlags fl Link Here

(-)a/src/gui/image/qimage.cpp (-3 / +3 lines)
2189	if (!converter && format > QImage::Format_Indexed8 && d->format > QImage::Format_Indexed8) {	2189	if (!converter && format > QImage::Format_Indexed8 && d->format > QImage::Format_Indexed8) {
2190	if (qt_highColorPrecision(d->format, !destLayout->hasAlphaChannel)	2190	if (qt_highColorPrecision(d->format, !destLayout->hasAlphaChannel)
2191	&& qt_highColorPrecision(format, !hasAlphaChannel())) {	2191	&& qt_highColorPrecision(format, !hasAlphaChannel())) {
2192	#if QT_CONFIG(raster_fp)	2192	#if 0
2193	if (qt_fpColorPrecision(d->format) && qt_fpColorPrecision(format))	2193	if (qt_fpColorPrecision(d->format) && qt_fpColorPrecision(format))
2194	converter = convert_generic_over_rgba32f;	2194	converter = convert_generic_over_rgba32f;
2195	else	2195	else
Lines 4663-4669 QImage QImage::smoothScaled(int w, int h) const Link Here
4663	src.convertTo(QImage::Format_RGBA64_Premultiplied);	4663	src.convertTo(QImage::Format_RGBA64_Premultiplied);
4664	break;	4664	break;
4665	#endif	4665	#endif
4666	#if QT_CONFIG(raster_fp)	4666	#if 0
4667	case QImage::Format_RGBX32FPx4:	4667	case QImage::Format_RGBX32FPx4:
4668	case QImage::Format_RGBA32FPx4_Premultiplied:	4668	case QImage::Format_RGBA32FPx4_Premultiplied:
4669	break;	4669	break;
Lines 5214-5220 bool QImageData::convertInPlace(QImage::Format newFormat, Qt::ImageConversionFla Link Here
5214	// any direct ones are probably better even if not inplace.	5214	// any direct ones are probably better even if not inplace.
5215	if (qt_highColorPrecision(newFormat, !qPixelLayouts[newFormat].hasAlphaChannel)	5215	if (qt_highColorPrecision(newFormat, !qPixelLayouts[newFormat].hasAlphaChannel)
5216	&& qt_highColorPrecision(format, !qPixelLayouts[format].hasAlphaChannel)) {	5216	&& qt_highColorPrecision(format, !qPixelLayouts[format].hasAlphaChannel)) {
5217	#if QT_CONFIG(raster_fp)	5217	#if 0
5218	if (qt_fpColorPrecision(format) && qt_fpColorPrecision(newFormat))	5218	if (qt_fpColorPrecision(format) && qt_fpColorPrecision(newFormat))
5219	return convert_generic_inplace_over_rgba32f(this, newFormat, flags);	5219	return convert_generic_inplace_over_rgba32f(this, newFormat, flags);
5220	#endif	5220	#endif

Lines 420-426 void QT_FASTCALL comp_func_SourceOver_rgb64_avx2(QRgba64 dst, const QRgba64 sr Link Here

(-)a/src/gui/painting/qdrawhelper_avx2.cpp (-4 / +4 lines)
420	}	420	}
421	#endif	421	#endif
422		422
423	#if QT_CONFIG(raster_fp)	423	#if 0
424	void QT_FASTCALL comp_func_SourceOver_rgbafp_avx2(QRgbaFloat32 dst, const QRgbaFloat32 src, int length, uint const_alpha)	424	void QT_FASTCALL comp_func_SourceOver_rgbafp_avx2(QRgbaFloat32 dst, const QRgbaFloat32 src, int length, uint const_alpha)
425	{	425	{
426	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]	426	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]
Lines 520-526 void QT_FASTCALL comp_func_Source_rgb64_avx2(QRgba64 dst, const QRgba64 src, i Link Here
520	}	520	}
521	#endif	521	#endif
522		522
523	#if QT_CONFIG(raster_fp)	523	#if 0
524	void QT_FASTCALL comp_func_Source_rgbafp_avx2(QRgbaFloat32 dst, const QRgbaFloat32 src, int length, uint const_alpha)	524	void QT_FASTCALL comp_func_Source_rgbafp_avx2(QRgbaFloat32 dst, const QRgbaFloat32 src, int length, uint const_alpha)
525	{	525	{
526	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]	526	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]
Lines 619-625 void QT_FASTCALL comp_func_solid_SourceOver_rgb64_avx2(QRgba64 *destPixels, int Link Here
619	}	619	}
620	#endif	620	#endif
621		621
622	#if QT_CONFIG(raster_fp)	622	#if 0
623	void QT_FASTCALL comp_func_solid_Source_rgbafp_avx2(QRgbaFloat32 *dst, int length, QRgbaFloat32 color, uint const_alpha)	623	void QT_FASTCALL comp_func_solid_Source_rgbafp_avx2(QRgbaFloat32 *dst, int length, QRgbaFloat32 color, uint const_alpha)
624	{	624	{
625	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]	625	Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]
Lines 1539-1545 void QT_FASTCALL storeRGBA16FFromARGB32PM_avx2(uchar dest, const uint src, int Link Here
1539	}	1539	}
1540	}	1540	}
1541		1541
1542	#if QT_CONFIG(raster_fp)	1542	#if 0
1543	const QRgbaFloat32 QT_FASTCALL fetchRGBA16FToRGBA32F_avx2(QRgbaFloat32 buffer, const uchar *src, int index, int count,	1543	const QRgbaFloat32 QT_FASTCALL fetchRGBA16FToRGBA32F_avx2(QRgbaFloat32 buffer, const uchar *src, int index, int count,
1544	const QList<QRgb> , QDitherInfo )	1544	const QList<QRgb> , QDitherInfo )
1545	{	1545	{

Lines 265-271 struct QGradientData Link Here

(-)a/src/gui/painting/qdrawhelper_p.h (-3 / +3 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 0 \|\| QT_CONFIG(raster_fp)	268	#if 0 \|\| 0
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 811-817 static inline QRgba64 interpolate_4_pixels_rgb64(const QRgba64 t[], const QRgba6 Link Here
811	}	811	}
812	#endif // __SSE2__	812	#endif // __SSE2__
813		813
814	#if QT_CONFIG(raster_fp)	814	#if 0
815	static inline QRgbaFloat32 multiplyAlpha_rgba32f(QRgbaFloat32 c, float a)	815	static inline QRgbaFloat32 multiplyAlpha_rgba32f(QRgbaFloat32 c, float a)
816	{	816	{
817	return QRgbaFloat32 { c.r * a, c.g * a, c.b * a, c.a * a };	817	return QRgbaFloat32 { c.r * a, c.g * a, c.b * a, c.a * a };
Lines 860-866 static inline QRgbaFloat32 interpolate_4_pixels_rgba32f(const QRgbaFloat32 t[], Link Here
860	return xtop;	860	return xtop;
861	#endif	861	#endif
862	}	862	}
863	#endif // QT_CONFIG(raster_fp)	863	#endif // 0
864		864
865	static inline uint BYTE_MUL_RGB16(uint x, uint a) {	865	static inline uint BYTE_MUL_RGB16(uint x, uint a) {
866	a += 1;	866	a += 1;

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 0 \|\| QT_CONFIG(raster_fp)	4502	#if 0 \|\| 0
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 0 \|\| QT_CONFIG(raster_fp)	4526	#if 0 \|\| 0
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 0 \|\| QT_CONFIG(raster_fp)	4554	#if 0 \|\| 0
4555	gradient.colorTable64 = cacheInfo->buffer64;	4555	gradient.colorTable64 = cacheInfo->buffer64;
4556	#endif	4556	#endif
4557	cachedGradient = std::move(cacheInfo);	4557	cachedGradient = std::move(cacheInfo);