Attempt at fixing compilation on Symbian.

The Symbian compiler seems to have a problem with forward declarations
of template functions.

Reviewed-by: Bjørn Erik Nilsen

1 files changed, 83 insertions, 88 deletions

diff --git a/src/gui/image/qpixmapfilter.cpp b/src/gui/image/qpixmapfilter.cpp
index 9c7c28e..caa0752 100644
--- a/src/gui/image/qpixmapfilter.cpp
+++ b/src/gui/image/qpixmapfilter.cpp
@@ -601,94 +601,6 @@ QRectF QPixmapBlurFilter::boundingRectFor(const QRectF &rect) const
     return rect.adjusted(-delta, -delta, delta, delta);
 }
 
-// Blur the image according to the blur radius
-// Based on exponential blur algorithm by Jani Huhtanen
-
-template <int aprec, int zprec, bool alphaOnly>
-static inline void blurrow( QImage & im, int line, int alpha);
-
-/*
-*  expblur(QImage &img, int radius)
-*
-*  In-place blur of image 'img' with kernel
-*  of approximate radius 'radius'.
-*
-*  Blurs with two sided exponential impulse
-*  response.
-*
-*  aprec = precision of alpha parameter
-*  in fixed-point format 0.aprec
-*
-*  zprec = precision of state parameters
-*  zR,zG,zB and zA in fp format 8.zprec
-*/
-template <int aprec, int zprec, bool alphaOnly>
-void expblur(QImage &img, qreal radius, bool improvedQuality = false, int transposed = 0)
-{
-    // halve the radius if we're using two passes
-    if (improvedQuality)
-        radius *= qreal(0.5);
-
-    Q_ASSERT(img.format() == QImage::Format_ARGB32_Premultiplied
-             || img.format() == QImage::Format_RGB32);
-
-    // choose the alpha such that pixels at radius distance from a fully
-    // saturated pixel will have an alpha component of no greater than
-    // the cutOffIntensity
-    const qreal cutOffIntensity = 2;
-    int alpha = radius <= qreal(1e-5)
-        ? ((1 << aprec)-1)
-        : qRound((1<<aprec)*(1 - qPow(cutOffIntensity * (1 / qreal(255)), 1 / radius)));
-
-    int img_height = img.height();
-    for (int row = 0; row < img_height; ++row) {
-        for (int i = 0; i <= improvedQuality; ++i)
-            blurrow<aprec, zprec, alphaOnly>(img, row, alpha);
-    }
-
-    QImage temp(img.height(), img.width(), img.format());
-    if (transposed >= 0) {
-        if (img.depth() == 8) {
-            qt_memrotate270(reinterpret_cast<const quint8*>(img.bits()),
-                            img.width(), img.height(), img.bytesPerLine(),
-                            reinterpret_cast<quint8*>(temp.bits()),
-                            temp.bytesPerLine());
-        } else {
-            qt_memrotate270(reinterpret_cast<const quint32*>(img.bits()),
-                            img.width(), img.height(), img.bytesPerLine(),
-                            reinterpret_cast<quint32*>(temp.bits()),
-                            temp.bytesPerLine());
-        }
-    } else {
-        if (img.depth() == 8) {
-            qt_memrotate90(reinterpret_cast<const quint8*>(img.bits()),
-                           img.width(), img.height(), img.bytesPerLine(),
-                           reinterpret_cast<quint8*>(temp.bits()),
-                           temp.bytesPerLine());
-        } else {
-            qt_memrotate90(reinterpret_cast<const quint32*>(img.bits()),
-                           img.width(), img.height(), img.bytesPerLine(),
-                           reinterpret_cast<quint32*>(temp.bits()),
-                           temp.bytesPerLine());
-        }
-    }
-
-    img_height = temp.height();
-    for (int row = 0; row < img_height; ++row) {
-        for (int i = 0; i <= improvedQuality; ++i)
-            blurrow<aprec, zprec, alphaOnly>(temp, row, alpha);
-    }
-
-    if (transposed == 0) {
-        qt_memrotate90(reinterpret_cast<const quint32*>(temp.bits()),
-                       temp.width(), temp.height(), temp.bytesPerLine(),
-                       reinterpret_cast<quint32*>(img.bits()),
-                       img.bytesPerLine());
-    } else {
-        img = temp;
-    }
-}
-
 template <int shift>
 static inline int static_shift(int value)
 {
@@ -773,6 +685,89 @@ static inline void blurrow(QImage & im, int line, int alpha)
     }
 }
 
+/*
+*  expblur(QImage &img, int radius)
+*
+*  Based on exponential blur algorithm by Jani Huhtanen
+*
+*  In-place blur of image 'img' with kernel
+*  of approximate radius 'radius'.
+*
+*  Blurs with two sided exponential impulse
+*  response.
+*
+*  aprec = precision of alpha parameter
+*  in fixed-point format 0.aprec
+*
+*  zprec = precision of state parameters
+*  zR,zG,zB and zA in fp format 8.zprec
+*/
+template <int aprec, int zprec, bool alphaOnly>
+void expblur(QImage &img, qreal radius, bool improvedQuality = false, int transposed = 0)
+{
+    // halve the radius if we're using two passes
+    if (improvedQuality)
+        radius *= qreal(0.5);
+
+    Q_ASSERT(img.format() == QImage::Format_ARGB32_Premultiplied
+             || img.format() == QImage::Format_RGB32);
+
+    // choose the alpha such that pixels at radius distance from a fully
+    // saturated pixel will have an alpha component of no greater than
+    // the cutOffIntensity
+    const qreal cutOffIntensity = 2;
+    int alpha = radius <= qreal(1e-5)
+        ? ((1 << aprec)-1)
+        : qRound((1<<aprec)*(1 - qPow(cutOffIntensity * (1 / qreal(255)), 1 / radius)));
+
+    int img_height = img.height();
+    for (int row = 0; row < img_height; ++row) {
+        for (int i = 0; i <= improvedQuality; ++i)
+            blurrow<aprec, zprec, alphaOnly>(img, row, alpha);
+    }
+
+    QImage temp(img.height(), img.width(), img.format());
+    if (transposed >= 0) {
+        if (img.depth() == 8) {
+            qt_memrotate270(reinterpret_cast<const quint8*>(img.bits()),
+                            img.width(), img.height(), img.bytesPerLine(),
+                            reinterpret_cast<quint8*>(temp.bits()),
+                            temp.bytesPerLine());
+        } else {
+            qt_memrotate270(reinterpret_cast<const quint32*>(img.bits()),
+                            img.width(), img.height(), img.bytesPerLine(),
+                            reinterpret_cast<quint32*>(temp.bits()),
+                            temp.bytesPerLine());
+        }
+    } else {
+        if (img.depth() == 8) {
+            qt_memrotate90(reinterpret_cast<const quint8*>(img.bits()),
+                           img.width(), img.height(), img.bytesPerLine(),
+                           reinterpret_cast<quint8*>(temp.bits()),
+                           temp.bytesPerLine());
+        } else {
+            qt_memrotate90(reinterpret_cast<const quint32*>(img.bits()),
+                           img.width(), img.height(), img.bytesPerLine(),
+                           reinterpret_cast<quint32*>(temp.bits()),
+                           temp.bytesPerLine());
+        }
+    }
+
+    img_height = temp.height();
+    for (int row = 0; row < img_height; ++row) {
+        for (int i = 0; i <= improvedQuality; ++i)
+            blurrow<aprec, zprec, alphaOnly>(temp, row, alpha);
+    }
+
+    if (transposed == 0) {
+        qt_memrotate90(reinterpret_cast<const quint32*>(temp.bits()),
+                       temp.width(), temp.height(), temp.bytesPerLine(),
+                       reinterpret_cast<quint32*>(img.bits()),
+                       img.bytesPerLine());
+    } else {
+        img = temp;
+    }
+}
 #define AVG(a,b)  ( ((((a)^(b)) & 0xfefefefeUL) >> 1) + ((a)&(b)) )
 #define AVG16(a,b)  ( ((((a)^(b)) & 0xf7deUL) >> 1) + ((a)&(b)) )