Merge "Merge remote-tracking branch 'origin/stable' into dev" into refs/staging/dev

2 files changed, 169 insertions, 6 deletions

diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index 7a5c5dc660..b5ccafdf9a 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -1709,6 +1709,163 @@ static const uint * QT_FASTCALL fetchTransformedBilinearARGB32PM(uint *buffer, c
                 }
             } else {
                 //we are zooming less than 8x, use 4bit precision
+
+                if (blendType != BlendTransformedBilinearTiled) {
+#define BILINEAR_ROTATE_BOUNDS_PROLOG \
+                    while (b < end) { \
+                        int x1 = (fx >> 16); \
+                        int x2; \
+                        int y1 = (fy >> 16); \
+                        int y2; \
+                        fetchTransformedBilinear_pixelBounds<blendType>(image_width, image_x1, image_x2, x1, x2); \
+                        fetchTransformedBilinear_pixelBounds<blendType>(image_height, image_y1, image_y2, y1, y2); \
+                        if (x1 != x2 && y1 != y2) \
+                            break; \
+                        const uint *s1 = (const uint *)data->texture.scanLine(y1); \
+                        const uint *s2 = (const uint *)data->texture.scanLine(y2); \
+                        uint tl = s1[x1]; \
+                        uint tr = s1[x2]; \
+                        uint bl = s2[x1]; \
+                        uint br = s2[x2]; \
+                        int distx = (fx & 0x0000ffff) >> 12; \
+                        int disty = (fy & 0x0000ffff) >> 12; \
+                        *b = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty); \
+                        fx += fdx; \
+                        fy += fdy; \
+                        ++b; \
+                    } \
+                    uint *boundedEnd = end - 3; \
+                    boundedEnd -= 3;
+
+#if defined(__SSE2__)
+                    BILINEAR_ROTATE_BOUNDS_PROLOG
+
+                    const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+                    const __m128i v_256 = _mm_set1_epi16(256);
+                    __m128i v_fdx = _mm_set1_epi32(fdx*4);
+                    __m128i v_fdy = _mm_set1_epi32(fdy*4);
+
+                    const uchar *textureData = data->texture.imageData;
+                    const int bytesPerLine = data->texture.bytesPerLine;
+
+                    union Vect_buffer { __m128i vect; qint32 i[4]; };
+                    Vect_buffer v_fx, v_fy;
+
+                    for (int i = 0; i < 4; i++) {
+                        v_fx.i[i] = fx;
+                        v_fy.i[i] = fy;
+                        fx += fdx;
+                        fy += fdy;
+                    }
+
+                    while (b < boundedEnd) {
+                        if (fdx > 0 && (v_fx.i[3] >> 16) >= image_x2)
+                            break;
+                        if (fdx < 0 && (v_fx.i[3] >> 16) < image_x1)
+                            break;
+                        if (fdy > 0 && (v_fy.i[3] >> 16) >= image_y2)
+                            break;
+                        if (fdy < 0 && (v_fy.i[3] >> 16) < image_y1)
+                            break;
+
+                        Vect_buffer tl, tr, bl, br;
+                        Vect_buffer v_fx_shifted, v_fy_shifted;
+                        v_fx_shifted.vect = _mm_srli_epi32(v_fx.vect, 16);
+                        v_fy_shifted.vect = _mm_srli_epi32(v_fy.vect, 16);
+
+                        for (int i = 0; i < 4; i++) {
+                            const int x1 = v_fx_shifted.i[i];
+                            const int y1 = v_fy_shifted.i[i];
+                            const uchar *sl = textureData + bytesPerLine * y1;
+                            const uint *s1 = (const uint *)sl;
+                            const uint *s2 = (const uint *)(sl + bytesPerLine);
+                            tl.i[i] = s1[x1];
+                            tr.i[i] = s1[x1+1];
+                            bl.i[i] = s2[x1];
+                            br.i[i] = s2[x1+1];
+                        }
+                        __m128i v_distx = _mm_srli_epi16(v_fx.vect, 12);
+                        __m128i v_disty = _mm_srli_epi16(v_fy.vect, 12);
+                        v_distx = _mm_shufflehi_epi16(v_distx, _MM_SHUFFLE(2,2,0,0));
+                        v_distx = _mm_shufflelo_epi16(v_distx, _MM_SHUFFLE(2,2,0,0));
+                        v_disty = _mm_shufflehi_epi16(v_disty, _MM_SHUFFLE(2,2,0,0));
+                        v_disty = _mm_shufflelo_epi16(v_disty, _MM_SHUFFLE(2,2,0,0));
+
+                        interpolate_4_pixels_16_sse2(tl.vect, tr.vect, bl.vect, br.vect, v_distx, v_disty, colorMask, v_256, b);
+                        b+=4;
+                        v_fx.vect = _mm_add_epi32(v_fx.vect, v_fdx);
+                        v_fy.vect = _mm_add_epi32(v_fy.vect, v_fdy);
+                    }
+                    fx = v_fx.i[0];
+                    fy = v_fy.i[0];
+#elif defined(__ARM_NEON__)
+                    BILINEAR_ROTATE_BOUNDS_PROLOG
+
+                    const int16x8_t colorMask = vdupq_n_s16(0x00ff);
+                    const int16x8_t invColorMask = vmvnq_s16(colorMask);
+                    const int16x8_t v_256 = vdupq_n_s16(256);
+                    int32x4_t v_fdx = vdupq_n_s32(fdx*4);
+                    int32x4_t v_fdy = vdupq_n_s32(fdy*4);
+
+                    const uchar *textureData = data->texture.imageData;
+                    const int bytesPerLine = data->texture.bytesPerLine;
+
+                    union Vect_buffer { int32x4_t vect; quint32 i[4]; };
+                    Vect_buffer v_fx, v_fy;
+
+                    for (int i = 0; i < 4; i++) {
+                        v_fx.i[i] = fx;
+                        v_fy.i[i] = fy;
+                        fx += fdx;
+                        fy += fdy;
+                    }
+
+                    const int32x4_t v_ffff_mask = vdupq_n_s32(0x0000ffff);
+
+                    while (b < boundedEnd) {
+                        if (fdx > 0 && (v_fx.i[3] >> 16) >= image_x2)
+                            break;
+                        if (fdx < 0 && (v_fx.i[3] >> 16) < image_x1)
+                            break;
+                        if (fdy > 0 && (v_fy.i[3] >> 16) >= image_y2)
+                            break;
+                        if (fdy < 0 && (v_fy.i[3] >> 16) < image_y1)
+                            break;
+
+                        Vect_buffer tl, tr, bl, br;
+
+                        Vect_buffer v_fx_shifted, v_fy_shifted;
+                        v_fx_shifted.vect = vshrq_n_s32(v_fx.vect, 16);
+                        v_fy_shifted.vect = vshrq_n_s32(v_fy.vect, 16);
+
+                        for (int i = 0; i < 4; i++) {
+                            const int x1 = v_fx_shifted.i[i];
+                            const int y1 = v_fy_shifted.i[i];
+                            const uchar *sl = textureData + bytesPerLine * y1;
+                            const uint *s1 = (const uint *)sl;
+                            const uint *s2 = (const uint *)(sl + bytesPerLine);
+                            tl.i[i] = s1[x1];
+                            tr.i[i] = s1[x1+1];
+                            bl.i[i] = s2[x1];
+                            br.i[i] = s2[x1+1];
+                        }
+
+                        int32x4_t v_distx = vshrq_n_s32(vandq_s32(v_fx.vect, v_ffff_mask), 12);
+                        int32x4_t v_disty = vshrq_n_s32(vandq_s32(v_fy.vect, v_ffff_mask), 12);
+                        v_distx = vorrq_s32(v_distx, vshlq_n_s32(v_distx, 16));
+                        v_disty = vorrq_s32(v_disty, vshlq_n_s32(v_disty, 16));
+                        int16x8_t v_disty_ = vshlq_n_s16(v_disty, 4);
+
+                        interpolate_4_pixels_16_neon(vreinterpretq_s16_s32(tl.vect), vreinterpretq_s16_s32(tr.vect), vreinterpretq_s16_s32(bl.vect), vreinterpretq_s16_s32(br.vect), vreinterpretq_s16_s32(v_distx), v_disty, v_disty_, colorMask, invColorMask, v_256, b);
+                        b+=4;
+                        v_fx.vect = vaddq_s32(v_fx.vect, v_fdx);
+                        v_fy.vect = vaddq_s32(v_fy.vect, v_fdy);
+                    }
+                    fx = v_fx.i[0];
+                    fy = v_fy.i[0];
+#endif
+                }
+
                 while (b < end) {
                     int x1 = (fx >> 16);
                     int x2;
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index a3b1f07c69..7c691c9670 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -147,8 +147,9 @@ static inline uint line_emulation(uint emulation)
 }
 
 #ifndef QT_NO_DEBUG
-static bool qt_painter_thread_test(int devType, const char *what)
+static bool qt_painter_thread_test(int devType, int engineType, const char *what)
 {
+    const QPlatformIntegration *platformIntegration = QGuiApplicationPrivate::platformIntegration();
     switch (devType) {
     case QInternal::Image:
     case QInternal::Printer:
@@ -157,8 +158,13 @@ static bool qt_painter_thread_test(int devType, const char *what)
         break;
     default:
         if (QThread::currentThread() != qApp->thread()
-                && (devType!=QInternal::Pixmap || !QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedPixmaps))
-                && (devType!=QInternal::OpenGL || !QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedOpenGL))) {
+                // pixmaps cannot be targets unless threaded pixmaps are supported
+                && (devType != QInternal::Pixmap || !platformIntegration->hasCapability(QPlatformIntegration::ThreadedPixmaps))
+                // framebuffer objects and such cannot be targets unless threaded GL is supported
+                && (devType != QInternal::OpenGL || !platformIntegration->hasCapability(QPlatformIntegration::ThreadedOpenGL))
+                // widgets cannot be targets except for QGLWidget
+                && (devType != QInternal::Widget || !platformIntegration->hasCapability(QPlatformIntegration::ThreadedOpenGL)
+                    || (engineType != QPaintEngine::OpenGL && engineType != QPaintEngine::OpenGL2))) {
             qWarning("QPainter: It is not safe to use %s outside the GUI thread", what);
             return false;
         }
@@ -5054,7 +5060,7 @@ void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
         return;
 
 #ifndef QT_NO_DEBUG
-    qt_painter_thread_test(d->device->devType(), "drawPixmap()");
+    qt_painter_thread_test(d->device->devType(), d->engine->type(), "drawPixmap()");
 #endif
 
     if (d->extended) {
@@ -5125,7 +5131,7 @@ void QPainter::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
     if (!d->engine || pm.isNull())
         return;
 #ifndef QT_NO_DEBUG
-    qt_painter_thread_test(d->device->devType(), "drawPixmap()");
+    qt_painter_thread_test(d->device->devType(), d->engine->type(), "drawPixmap()");
 #endif
 
     qreal x = r.x();
@@ -6612,7 +6618,7 @@ void QPainter::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPo
         return;
 
 #ifndef QT_NO_DEBUG
-    qt_painter_thread_test(d->device->devType(), "drawTiledPixmap()");
+    qt_painter_thread_test(d->device->devType(), d->engine->type(), "drawTiledPixmap()");
 #endif
 
     qreal sw = pixmap.width();