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)