gtk+: add 2.10.14, the latest stable release

1 files changed, 569 insertions, 0 deletions

diff --git a/packages/gtk+/gtk+-2.10.14/plana-pixops.patch b/packages/gtk+/gtk+-2.10.14/plana-pixops.patch
new file mode 100644
index 0000000000..21fe4879c5
--- /dev/null
+++ b/packages/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)