aboutsummaryrefslogtreecommitdiffstats
path: root/recipes/obsolete/gtk+/gtk+-2.10.14/plana-pixops.patch
diff options
context:
space:
mode:
authorFrans Meulenbroeks <fransmeulenbroeks@gmail.com>2010-10-10 13:22:48 +0200
committerFrans Meulenbroeks <fransmeulenbroeks@gmail.com>2010-10-10 13:22:48 +0200
commit783f3cdb23b699566962eb396ae32b81ff9e4ef1 (patch)
tree755a12ff1fcd68d89c6fd28837b2466703c50ff2 /recipes/obsolete/gtk+/gtk+-2.10.14/plana-pixops.patch
parent04736443306582cd0d2ce2fd081bf9dfa1c27adc (diff)
downloadopenembedded-783f3cdb23b699566962eb396ae32b81ff9e4ef1.tar.gz
openembedded-783f3cdb23b699566962eb396ae32b81ff9e4ef1.tar.bz2
openembedded-783f3cdb23b699566962eb396ae32b81ff9e4ef1.zip
gtk+ : moved unused files to obsolete dir
Signed-off-by: Frans Meulenbroeks <fransmeulenbroeks@gmail.com>
Diffstat (limited to 'recipes/obsolete/gtk+/gtk+-2.10.14/plana-pixops.patch')
-rw-r--r--recipes/obsolete/gtk+/gtk+-2.10.14/plana-pixops.patch569
1 files changed, 569 insertions, 0 deletions
diff --git a/recipes/obsolete/gtk+/gtk+-2.10.14/plana-pixops.patch b/recipes/obsolete/gtk+/gtk+-2.10.14/plana-pixops.patch
new file mode 100644
index 0000000000..21fe4879c5
--- /dev/null
+++ b/recipes/obsolete/gtk+/gtk+-2.10.14/plana-pixops.patch
@@ -0,0 +1,569 @@
+diff -urN gtk+-2.10.9.orig/config.h.in gtk+-2.10.9-integer-pixops/config.h.in
+--- gtk+-2.10.9.orig/config.h.in 2007-01-22 09:01:23.000000000 -0700
++++ gtk+-2.10.9-integer-pixops/config.h.in 2007-02-10 12:15:39.000000000 -0700
+@@ -259,3 +259,7 @@
+
+ /* Define to `int' if <sys/types.h> doesn't define. */
+ #undef uid_t
++
++/* Define to use integer math rather than floating point where possible. */
++#undef ENABLE_INTEGER_PIXOPS
++
+diff -urN gtk+-2.10.9.orig/configure.in gtk+-2.10.9-integer-pixops/configure.in
+--- gtk+-2.10.9.orig/configure.in 2007-01-22 08:59:41.000000000 -0700
++++ gtk+-2.10.9-integer-pixops/configure.in 2007-02-10 12:15:39.000000000 -0700
+@@ -203,6 +203,15 @@
+ [AC_HELP_STRING([--disable-rebuilds],
+ [disable all source autogeneration rules])],,
+ [enable_rebuilds=yes])
++AC_ARG_ENABLE(integer-pixops,
++ [AC_HELP_STRING([--enable-integer-pixops],
++ [use integer math where possible])],,
++ [enable_integer_pixops=no])
++
++if test "x$enable_integer_pixops" = "xyes"; then
++ AC_DEFINE(ENABLE_INTEGER_PIXOPS)
++fi
++
+ AC_ARG_ENABLE(visibility,
+ [AC_HELP_STRING([--disable-visibility],
+ [don't use ELF visibility attributes])],,
+diff -urN gtk+-2.10.9.orig/gdk-pixbuf/pixops/pixops.c gtk+-2.10.9-integer-pixops/gdk-pixbuf/pixops/pixops.c
+--- gtk+-2.10.9.orig/gdk-pixbuf/pixops/pixops.c 2007-01-22 08:50:43.000000000 -0700
++++ gtk+-2.10.9-integer-pixops/gdk-pixbuf/pixops/pixops.c 2007-02-12 01:00:23.000000000 -0700
+@@ -28,21 +28,42 @@
+ #define SUBSAMPLE_MASK ((1 << SUBSAMPLE_BITS)-1)
+ #define SCALE_SHIFT 16
+
++/* TODO: Add a FLOOR() and CEIL() macro to handle normalized values) */
++/* TODO: Get rid of standard C numeric types (ie. int). Replace with glib types */
++#ifdef ENABLE_INTEGER_PIXOPS
++/* The bigger the value of FRAC is, the better the accuracy. Be wary of
++ overflows, though */
++#define FRAC 0x10000ULL
++#define NORMALIZE(d) (d * FRAC)
++#define UNNORMALIZE(t,i) ((t)(i) / FRAC)
++#define FLOOR(i) (int)((i) / FRAC)
++#define CEIL(i) (((i) - 1) / FRAC + 1)
++#define DOUBLE_TYPE gint32
++#define BIG_DOUBLE_TYPE gint64
++#else
++#define NORMALIZE(d) (d)
++#define UNNORMALIZE(t,i) (t)(i)
++#define FLOOR(i) floor(i)
++#define CEIL(i) ceil(i)
++#define DOUBLE_TYPE double
++#define BIG_DOUBLE_TYPE double
++#endif
++
+ typedef struct _PixopsFilter PixopsFilter;
+ typedef struct _PixopsFilterDimension PixopsFilterDimension;
+
+ struct _PixopsFilterDimension
+ {
+ int n;
+- double offset;
+- double *weights;
++ BIG_DOUBLE_TYPE offset;
++ DOUBLE_TYPE *weights;
+ };
+
+ struct _PixopsFilter
+ {
+ PixopsFilterDimension x;
+ PixopsFilterDimension y;
+- double overall_alpha;
++ gint32 overall_alpha; /* Normalized: alpha * 255; Not sure why original devs chose 255 */
+ };
+
+ typedef guchar *(*PixopsLineFunc) (int *weights, int n_x, int n_y,
+@@ -86,13 +107,13 @@
+ int src_rowstride,
+ int src_channels,
+ gboolean src_has_alpha,
+- double scale_x,
+- double scale_y)
++ DOUBLE_TYPE scale_x,
++ DOUBLE_TYPE scale_y)
+ {
+ int i;
+ int x;
+- int x_step = (1 << SCALE_SHIFT) / scale_x;
+- int y_step = (1 << SCALE_SHIFT) / scale_y;
++ int x_step = NORMALIZE((1 << SCALE_SHIFT)) / scale_x;
++ int y_step = NORMALIZE((1 << SCALE_SHIFT)) / scale_y;
+ int xmax, xstart, xstop, x_pos, y_pos;
+ const guchar *p;
+
+@@ -175,14 +196,14 @@
+ int src_rowstride,
+ int src_channels,
+ gboolean src_has_alpha,
+- double scale_x,
+- double scale_y,
++ DOUBLE_TYPE scale_x,
++ DOUBLE_TYPE scale_y,
+ int overall_alpha)
+ {
+ int i;
+ int x;
+- int x_step = (1 << SCALE_SHIFT) / scale_x;
+- int y_step = (1 << SCALE_SHIFT) / scale_y;
++ int x_step = NORMALIZE((1 << SCALE_SHIFT)) / scale_x;
++ int y_step = NORMALIZE((1 << SCALE_SHIFT)) / scale_y;
+ int xmax, xstart, xstop, x_pos, y_pos;
+ const guchar *p;
+ unsigned int a0;
+@@ -260,8 +281,8 @@
+ int src_rowstride,
+ int src_channels,
+ gboolean src_has_alpha,
+- double scale_x,
+- double scale_y,
++ DOUBLE_TYPE scale_x,
++ DOUBLE_TYPE scale_y,
+ int overall_alpha,
+ int check_x,
+ int check_y,
+@@ -271,8 +292,8 @@
+ {
+ int i, j;
+ int x;
+- int x_step = (1 << SCALE_SHIFT) / scale_x;
+- int y_step = (1 << SCALE_SHIFT) / scale_y;
++ int x_step = NORMALIZE((1 << SCALE_SHIFT)) / scale_x;
++ int y_step = NORMALIZE((1 << SCALE_SHIFT)) / scale_y;
+ int r1, g1, b1, r2, g2, b2;
+ int check_shift = get_check_shift (check_size);
+ int xmax, xstart, xstop, x_pos, y_pos;
+@@ -977,9 +998,9 @@
+ int n_x,
+ int n_y,
+ int total,
+- double overall_alpha)
++ gint32 overall_alpha)
+ {
+- int correction = (int)(0.5 + 65536 * overall_alpha) - total;
++ int correction = (int)(0.5 + 65536 / 255 * overall_alpha) - total;
+ int remaining, c, d, i;
+
+ if (correction != 0)
+@@ -1009,7 +1030,7 @@
+ for (i_offset=0; i_offset < SUBSAMPLE; i_offset++)
+ for (j_offset=0; j_offset < SUBSAMPLE; j_offset++)
+ {
+- double weight;
++ DOUBLE_TYPE weight;
+ int *pixel_weights = weights + ((i_offset*SUBSAMPLE) + j_offset) * n_x * n_y;
+ int total = 0;
+ int i, j;
+@@ -1017,13 +1038,15 @@
+ for (i=0; i < n_y; i++)
+ for (j=0; j < n_x; j++)
+ {
+- weight = filter->x.weights[(j_offset * n_x) + j] *
++ weight = UNNORMALIZE(DOUBLE_TYPE, filter->x.weights[(j_offset * n_x) + j] *
+ filter->y.weights[(i_offset * n_y) + i] *
+- filter->overall_alpha * 65536 + 0.5;
++ filter->overall_alpha * 65536 / 255) + NORMALIZE(0.5);
++ /* Wonder how I should treat the "+ 0.5" for scientific
++ rouding off */
+
+- total += (int)weight;
++ total += UNNORMALIZE(int, weight);
+
+- *(pixel_weights + n_x * i + j) = weight;
++ *(pixel_weights + n_x * i + j) = UNNORMALIZE(int, weight);
+ }
+
+ correct_total (pixel_weights, n_x, n_y, total, filter->overall_alpha);
+@@ -1047,8 +1070,8 @@
+ int src_rowstride,
+ int src_channels,
+ gboolean src_has_alpha,
+- double scale_x,
+- double scale_y,
++ DOUBLE_TYPE scale_x,
++ DOUBLE_TYPE scale_y,
+ int check_x,
+ int check_y,
+ int check_size,
+@@ -1064,12 +1087,13 @@
+ guchar **line_bufs = g_new (guchar *, filter->y.n);
+ int *filter_weights = make_filter_table (filter);
+
+- int x_step = (1 << SCALE_SHIFT) / scale_x; /* X step in source (fixed point) */
+- int y_step = (1 << SCALE_SHIFT) / scale_y; /* Y step in source (fixed point) */
++ int x_step = NORMALIZE((1 << SCALE_SHIFT)) / scale_x; /* X step in source (fixed point) */
++ int y_step = NORMALIZE((1 << SCALE_SHIFT)) / scale_y; /* Y step in source (fixed point) */
+
+ int check_shift = check_size ? get_check_shift (check_size) : 0;
+
+- int scaled_x_offset = floor (filter->x.offset * (1 << SCALE_SHIFT));
++ /* Possible overflow when scale-shifting which is why offset is BIG_DOUBLE_TYPE */
++ int scaled_x_offset = FLOOR(filter->x.offset * (1 << SCALE_SHIFT));
+
+ /* Compute the index where we run off the end of the source buffer. The furthest
+ * source pixel we access at index i is:
+@@ -1087,7 +1111,7 @@
+ int run_end_index = MYDIV (run_end_x + x_step - 1, x_step) - render_x0;
+ run_end_index = MIN (run_end_index, render_x1 - render_x0);
+
+- y = render_y0 * y_step + floor (filter->y.offset * (1 << SCALE_SHIFT));
++ y = render_y0 * y_step + FLOOR(filter->y.offset * (1 << SCALE_SHIFT));
+ for (i = 0; i < (render_y1 - render_y0); i++)
+ {
+ int dest_x;
+@@ -1180,37 +1204,37 @@
+ */
+ static void
+ tile_make_weights (PixopsFilterDimension *dim,
+- double scale)
++ DOUBLE_TYPE scale)
+ {
+- int n = ceil (1 / scale + 1);
+- double *pixel_weights = g_new (double, SUBSAMPLE * n);
++ int n = CEIL(NORMALIZE(NORMALIZE(1)) / scale + NORMALIZE(1)); /* Another possible overflow */
++ DOUBLE_TYPE *pixel_weights = g_new (DOUBLE_TYPE, SUBSAMPLE * n);
+ int offset;
+ int i;
+-
++
+ dim->n = n;
+- dim->offset = 0;
++ dim->offset = NORMALIZE(0);
+ dim->weights = pixel_weights;
+
+ for (offset = 0; offset < SUBSAMPLE; offset++)
+ {
+- double x = (double)offset / SUBSAMPLE;
+- double a = x + 1 / scale;
++ DOUBLE_TYPE x = (DOUBLE_TYPE)NORMALIZE(offset) / SUBSAMPLE;
++ DOUBLE_TYPE a = x + NORMALIZE(NORMALIZE(1)) / scale;
+
+ for (i = 0; i < n; i++)
+ {
+- if (i < x)
++ if (NORMALIZE(i) < x)
+ {
+- if (i + 1 > x)
+- *(pixel_weights++) = (MIN (i + 1, a) - x) * scale;
++ if (NORMALIZE(i + 1) > x)
++ *(pixel_weights++) = UNNORMALIZE(DOUBLE_TYPE, (MIN(NORMALIZE(i + 1), a) - x) * scale);
+ else
+- *(pixel_weights++) = 0;
++ *(pixel_weights++) = NORMALIZE(0);
+ }
+ else
+ {
+- if (a > i)
+- *(pixel_weights++) = (MIN (i + 1, a) - i) * scale;
++ if (a > NORMALIZE(i))
++ *(pixel_weights++) = UNNORMALIZE(DOUBLE_TYPE, (MIN(NORMALIZE(i + 1), a) - i) * scale);
+ else
+- *(pixel_weights++) = 0;
++ *(pixel_weights++) = NORMALIZE(0);
+ }
+ }
+ }
+@@ -1222,41 +1246,44 @@
+ */
+ static void
+ bilinear_magnify_make_weights (PixopsFilterDimension *dim,
+- double scale)
++ DOUBLE_TYPE scale)
+ {
+- double *pixel_weights;
++ DOUBLE_TYPE *pixel_weights;
+ int n;
+ int offset;
+ int i;
+
+- if (scale > 1.0) /* Linear */
++ if (scale > NORMALIZE(1.0)) /* Linear */
+ {
+ n = 2;
+- dim->offset = 0.5 * (1 / scale - 1);
++ dim->offset = NORMALIZE(NORMALIZE(0.5) / (scale - NORMALIZE(1)));
+ }
+ else /* Tile */
+ {
+- n = ceil (1.0 + 1.0 / scale);
+- dim->offset = 0.0;
++ n = CEIL(NORMALIZE(1.0) + NORMALIZE(NORMALIZE(1.0)) / scale);
++ dim->offset = NORMALIZE(0.0);
+ }
+-
++
+ dim->n = n;
+- dim->weights = g_new (double, SUBSAMPLE * n);
++ dim->weights = g_new (DOUBLE_TYPE, SUBSAMPLE * n);
+
+ pixel_weights = dim->weights;
+
+ for (offset=0; offset < SUBSAMPLE; offset++)
+ {
+- double x = (double)offset / SUBSAMPLE;
++ DOUBLE_TYPE x = (DOUBLE_TYPE)NORMALIZE(offset) / SUBSAMPLE;
+
+- if (scale > 1.0) /* Linear */
++ if (scale > NORMALIZE(1.0)) /* Linear */
+ {
+ for (i = 0; i < n; i++)
+- *(pixel_weights++) = (((i == 0) ? (1 - x) : x) / scale) * scale;
++ /* In the original, what is the point of dividing by scale then multiplying by scale? */
++ /* *(pixel_weights++) = (((i == 0) ? (1 - x) : x) / scale) * scale;*/
++ /* *(pixel_weights++) = i == 0 ? NORMALIZE(1) - x : x; */
++ *(pixel_weights++) = (((i == 0) ? NORMALIZE(1) - x : x) / scale) * scale;
+ }
+ else /* Tile */
+ {
+- double a = x + 1 / scale;
++ DOUBLE_TYPE a = x + NORMALIZE(NORMALIZE(1)) / scale;
+
+ /* x
+ * ---------|--.-|----|--.-|------- SRC
+@@ -1264,19 +1291,19 @@
+ */
+ for (i = 0; i < n; i++)
+ {
+- if (i < x)
++ if (NORMALIZE(i) < x)
+ {
+- if (i + 1 > x)
+- *(pixel_weights++) = (MIN (i + 1, a) - x) * scale;
++ if (NORMALIZE(i + 1) > x)
++ *(pixel_weights++) = UNNORMALIZE(DOUBLE_TYPE, (MIN(NORMALIZE(i + 1), a) - x) * scale);
+ else
+- *(pixel_weights++) = 0;
++ *(pixel_weights++) = NORMALIZE(0);
+ }
+ else
+ {
+- if (a > i)
+- *(pixel_weights++) = (MIN (i + 1, a) - i) * scale;
++ if (a > NORMALIZE(i))
++ *(pixel_weights++) = UNNORMALIZE(DOUBLE_TYPE, (MIN(NORMALIZE(i + 1), a) - i) * scale);
+ else
+- *(pixel_weights++) = 0;
++ *(pixel_weights++) = NORMALIZE(0);
+ }
+ }
+ }
+@@ -1291,14 +1318,14 @@
+ * We combine two of these to compute the convolution of
+ * a box filter with a triangular spike.
+ */
+-static double
+-linear_box_half (double b0, double b1)
++static DOUBLE_TYPE
++linear_box_half (DOUBLE_TYPE b0, DOUBLE_TYPE b1)
+ {
+- double a0, a1;
+- double x0, x1;
++ DOUBLE_TYPE a0, a1;
++ DOUBLE_TYPE x0, x1;
+
+- a0 = 0.;
+- a1 = 1.;
++ a0 = NORMALIZE(0.);
++ a1 = NORMALIZE(1.);
+
+ if (a0 < b0)
+ {
+@@ -1308,7 +1335,7 @@
+ x1 = MIN (a1, b1);
+ }
+ else
+- return 0;
++ return NORMALIZE(0);
+ }
+ else
+ {
+@@ -1318,10 +1345,10 @@
+ x1 = MIN (a1, b1);
+ }
+ else
+- return 0;
++ return NORMALIZE(0);
+ }
+
+- return 0.5 * (x1*x1 - x0*x0);
++ return UNNORMALIZE(DOUBLE_TYPE, NORMALIZE(0.5) * UNNORMALIZE(DOUBLE_TYPE, (x1*x1 - x0*x0)));
+ }
+
+ /* Compute weights for reconstructing with bilinear
+@@ -1329,28 +1356,28 @@
+ */
+ static void
+ bilinear_box_make_weights (PixopsFilterDimension *dim,
+- double scale)
++ DOUBLE_TYPE scale)
+ {
+- int n = ceil (1/scale + 3.0);
+- double *pixel_weights = g_new (double, SUBSAMPLE * n);
+- double w;
++ int n = CEIL(NORMALIZE(NORMALIZE(1))/scale + NORMALIZE(3.0));
++ DOUBLE_TYPE *pixel_weights = g_new (DOUBLE_TYPE, SUBSAMPLE * n);
++ DOUBLE_TYPE w;
+ int offset, i;
+
+- dim->offset = -1.0;
++ dim->offset = NORMALIZE(-1.0);
+ dim->n = n;
+ dim->weights = pixel_weights;
+
+ for (offset = 0; offset < SUBSAMPLE; offset++)
+ {
+- double x = (double)offset / SUBSAMPLE;
+- double a = x + 1 / scale;
++ DOUBLE_TYPE x = (DOUBLE_TYPE)NORMALIZE(offset) / SUBSAMPLE;
++ DOUBLE_TYPE a = x + NORMALIZE(NORMALIZE(1)) / scale;
+
+ for (i = 0; i < n; i++)
+ {
+- w = linear_box_half (0.5 + i - a, 0.5 + i - x);
+- w += linear_box_half (1.5 + x - i, 1.5 + a - i);
++ w = linear_box_half (NORMALIZE(0.5) + NORMALIZE(i) - a, NORMALIZE(0.5) + NORMALIZE(i) - x);
++ w += linear_box_half (NORMALIZE(1.5) - NORMALIZE(i) + x, NORMALIZE(1.5) - NORMALIZE(i) + a);
+
+- *(pixel_weights++) = w * scale;
++ *(pixel_weights++) = UNNORMALIZE(DOUBLE_TYPE, w * scale);
+ }
+ }
+ }
+@@ -1358,8 +1385,8 @@
+ static void
+ make_weights (PixopsFilter *filter,
+ PixopsInterpType interp_type,
+- double scale_x,
+- double scale_y)
++ DOUBLE_TYPE scale_x,
++ DOUBLE_TYPE scale_y)
+ {
+ switch (interp_type)
+ {
+@@ -1399,8 +1426,8 @@
+ int src_rowstride,
+ int src_channels,
+ gboolean src_has_alpha,
+- double scale_x,
+- double scale_y,
++ double scale_x_d,
++ double scale_y_d,
+ PixopsInterpType interp_type,
+ int overall_alpha,
+ int check_x,
+@@ -1409,6 +1436,8 @@
+ guint32 color1,
+ guint32 color2)
+ {
++ DOUBLE_TYPE scale_x = NORMALIZE(scale_x_d);
++ DOUBLE_TYPE scale_y = NORMALIZE(scale_y_d);
+ PixopsFilter filter;
+ PixopsLineFunc line_func;
+
+@@ -1419,7 +1448,7 @@
+ g_return_if_fail (!(dest_channels == 3 && dest_has_alpha));
+ g_return_if_fail (!(src_channels == 3 && src_has_alpha));
+
+- if (scale_x == 0 || scale_y == 0)
++ if (scale_x == NORMALIZE(0) || scale_y == NORMALIZE(0))
+ return;
+
+ if (!src_has_alpha && overall_alpha == 255)
+@@ -1427,7 +1456,7 @@
+ _pixops_scale (dest_buf, render_x0, render_y0, render_x1, render_y1,
+ dest_rowstride, dest_channels, dest_has_alpha,
+ src_buf, src_width, src_height, src_rowstride, src_channels,
+- src_has_alpha, scale_x, scale_y, interp_type);
++ src_has_alpha, UNNORMALIZE(double, scale_x), UNNORMALIZE(double, scale_y), interp_type);
+ return;
+ }
+
+@@ -1441,7 +1470,8 @@
+ return;
+ }
+
+- filter.overall_alpha = overall_alpha / 255.;
++ /* filter.overall_alpha = overall_alpha / 255.; /* Why is it 255 instead of 256? */
++ filter.overall_alpha = overall_alpha;
+ make_weights (&filter, interp_type, scale_x, scale_y);
+
+ #ifdef USE_MMX
+@@ -1501,11 +1531,13 @@
+ int src_rowstride,
+ int src_channels,
+ gboolean src_has_alpha,
+- double scale_x,
+- double scale_y,
++ double scale_x_d,
++ double scale_y_d,
+ PixopsInterpType interp_type,
+ int overall_alpha)
+ {
++ DOUBLE_TYPE scale_x = NORMALIZE(scale_x_d);
++ DOUBLE_TYPE scale_y = NORMALIZE(scale_y_d);
+ PixopsFilter filter;
+ PixopsLineFunc line_func;
+
+@@ -1516,7 +1548,7 @@
+ g_return_if_fail (!(dest_channels == 3 && dest_has_alpha));
+ g_return_if_fail (!(src_channels == 3 && src_has_alpha));
+
+- if (scale_x == 0 || scale_y == 0)
++ if (scale_x == NORMALIZE(0) || scale_y == NORMALIZE(0))
+ return;
+
+ if (!src_has_alpha && overall_alpha == 255)
+@@ -1524,7 +1556,7 @@
+ _pixops_scale (dest_buf, render_x0, render_y0, render_x1, render_y1,
+ dest_rowstride, dest_channels, dest_has_alpha,
+ src_buf, src_width, src_height, src_rowstride, src_channels,
+- src_has_alpha, scale_x, scale_y, interp_type);
++ src_has_alpha, UNNORMALIZE(double, scale_x), UNNORMALIZE(double, scale_y), interp_type);
+ return;
+ }
+
+@@ -1537,7 +1569,7 @@
+ return;
+ }
+
+- filter.overall_alpha = overall_alpha / 255.;
++ filter.overall_alpha = overall_alpha;
+ make_weights (&filter, interp_type, scale_x, scale_y);
+
+ if (filter.x.n == 2 && filter.y.n == 2 &&
+@@ -1578,10 +1610,12 @@
+ int src_rowstride,
+ int src_channels,
+ gboolean src_has_alpha,
+- double scale_x,
+- double scale_y,
++ double scale_x_d,
++ double scale_y_d,
+ PixopsInterpType interp_type)
+ {
++ DOUBLE_TYPE scale_x = NORMALIZE(scale_x_d);
++ DOUBLE_TYPE scale_y = NORMALIZE(scale_y_d);
+ PixopsFilter filter;
+ PixopsLineFunc line_func;
+
+@@ -1593,7 +1627,7 @@
+ g_return_if_fail (!(src_channels == 3 && src_has_alpha));
+ g_return_if_fail (!(src_has_alpha && !dest_has_alpha));
+
+- if (scale_x == 0 || scale_y == 0)
++ if (scale_x == NORMALIZE(0) || scale_y == NORMALIZE(0))
+ return;
+
+ if (interp_type == PIXOPS_INTERP_NEAREST)
+@@ -1605,7 +1639,7 @@
+ return;
+ }
+
+- filter.overall_alpha = 1.0;
++ filter.overall_alpha = 255;
+ make_weights (&filter, interp_type, scale_x, scale_y);
+
+ if (filter.x.n == 2 && filter.y.n == 2 && dest_channels == 3 && src_channels == 3)