diff options
| -rw-r--r-- | gdk-pixbuf/ChangeLog | 14 | ||||
| -rw-r--r-- | gdk-pixbuf/pixops/README | 61 | ||||
| -rw-r--r-- | gdk-pixbuf/pixops/pixops.c | 66 | ||||
| -rw-r--r-- | gdk-pixbuf/pixops/scale_line_22_33_mmx.S | 26 |
4 files changed, 143 insertions, 24 deletions
diff --git a/gdk-pixbuf/ChangeLog b/gdk-pixbuf/ChangeLog index 9a8e370a3..390efd9fd 100644 --- a/gdk-pixbuf/ChangeLog +++ b/gdk-pixbuf/ChangeLog @@ -1,3 +1,17 @@ +Thu Jan 3 19:31:58 2002 Owen Taylor <otaylor@redhat.com> + + * pixops/pixops.c (scale_line_22_33): Fix and uncomment + non-MMX version. + + * pixops/pixops.c (pixops_composite_nearest): Remove a + division. + + * pixops/pixops.c (pixops_composite): Add some docs + about the parameters. + + * pixops/README: Add notes about the correct algorithms + for alpha compositing and how to implement them quickly. + 2001-12-29 Tor Lillqvist <tml@iki.fi> * Makefile.am (EXTRA_DIST): Add makefile.msc. diff --git a/gdk-pixbuf/pixops/README b/gdk-pixbuf/pixops/README index 957a0b3cb..c79e0e2fd 100644 --- a/gdk-pixbuf/pixops/README +++ b/gdk-pixbuf/pixops/README @@ -33,6 +33,61 @@ for a number of the most common special cases: compositing from RGBA to RGBx compositing against a color from RGBA and storing in a RGBx buffer +Alpha compositing 8 bit RGBAa onto RGB is defined in terms of +rounding the exact result (real values in [0,1]): + + cc = ca * aa + (1 - aa) * Cb + + Cc = ROUND [255. * (Ca/255. * Aa/255. + (1 - Aa/255.) * Cb/255.)] + +We can comp + +ROUND(i / 255.) can be computed exactly for i in [0,255*255] as: + + t = i + 0x80; result = (t + (t >> 8)) >> 8; [ call this as To8(i) ] + +So, + + t = Ca * Aa + (255 - Aa) * Cb + 0x80; + Cc = (t + (t >> 8)) >> 8; + +Alpha compositing 8 bit RaGaBaAa onto RbGbBbAa is a little harder, for +non-premultiplied alpha. The premultiplied result is simple: + + ac = aa + (1 - aa) * ab + cc = ca + (1 - aa) * cb + +Which can be computed in integers terms as: + + Cc = Ca + To8 ((255 - Aa) * Cb) + Ac = Aa + To8 ((255 - Aa) * Ab) + +For non-premultiplied alpha, we need divide the color components by +the alpha: + + +- (ca * aa + (1 - aa) * ab * cb)) / ac; aa != 0 + cc = | + +- cb; aa == 0 + +To calculate this as in integer, we note the alternate form: + + cc = cb + aa * (ca - cb) / ac + +[ 'cc = ca + (ac - aa) * (cb - ca) / ac' can also be useful numerically, + but isn't important here ] + +We can express this as integers as: + + Ac_tmp = Aa * 255 + (255 - Aa) * Ab; + + +- Cb + (255 * Aa * (Ca - Cb) + Ac_tmp / 2) / Ac_tmp ; Ca > Cb + Cc = | + +- Cb - (255 * Aa * (Cb - Ca) + Ac_tmp / 2) / Ac_tmp ; ca <= Cb + +Or, playing bit tricks to avoid the conditional + + Cc = Cb + (255 * Aa * (Ca - Cb) + (((Ca - Cb) >> 8) ^ (Ac_tmp / 2)) ) / Ac_tmp + TODO ==== @@ -57,13 +112,13 @@ TODO the _nearest() variants do it right, most of the other code is wrong to some degree or another. - For instance, in composite line, we have: + For instance, in composite_line_22_4a4(), we have: dest[0] = ((0xff0000 - a) * dest[0] + r) >> 24; - if a is 0, then we have: + if a is 0 (implies r == 0), then we have: - (0xff0000 * dest[0] + r) >> 24 + (0xff0000 * dest[0]) >> 24 which gives results which are 1 to low: diff --git a/gdk-pixbuf/pixops/pixops.c b/gdk-pixbuf/pixops/pixops.c index c9606107f..ef5afd747 100644 --- a/gdk-pixbuf/pixops/pixops.c +++ b/gdk-pixbuf/pixops/pixops.c @@ -202,10 +202,14 @@ pixops_composite_nearest (guchar *dest_buf, else { unsigned int a1 = 0xff - a0; - - dest[0] = (a0 * p[0] + a1 * dest[0]) / 0xff; - dest[1] = (a0 * p[1] + a1 * dest[1]) / 0xff; - dest[2] = (a0 * p[2] + a1 * dest[2]) / 0xff; + unsigned int tmp; + + tmp = a0 * p[0] + a1 * dest[0] + 0x80; + dest[0] = (tmp + (tmp >> 8)) >> 8; + tmp = a0 * p[1] + a1 * dest[1] + 0x80; + dest[1] = (tmp + (tmp >> 8)) >> 8; + tmp = a0 * p[2] + a1 * dest[2] + 0x80; + dest[2] = (tmp + (tmp >> 8)) >> 8; } break; } @@ -388,7 +392,7 @@ composite_line (int *weights, int n_x, int n_y, int *pixel_weights; pixel_weights = weights + ((x >> (SCALE_SHIFT - SUBSAMPLE_BITS)) & SUBSAMPLE_MASK) * n_x * n_y; - + for (i=0; i<n_y; i++) { guchar *q = src[i] + x_scaled * src_channels; @@ -837,10 +841,9 @@ scale_line_22_33_mmx_stub (int *weights, int n_x, int n_y, } #endif /* USE_MMX */ -#ifdef SCALE_LINE_22_33_USED /* This dead code would need changes if we wanted to use it */ static guchar * scale_line_22_33 (int *weights, int n_x, int n_y, - guchar *dest, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha, guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, int check_size, guint32 color1, guint32 color2) @@ -860,8 +863,8 @@ scale_line_22_33 (int *weights, int n_x, int n_y, q0 = src0 + x_scaled * 3; q1 = src1 + x_scaled * 3; - pixel_weights = (int *)((char *)weights + ((x >> (SCALE_SHIFT - SUBSAMPLE_BITS - 4)) & (SUBSAMPLE_MASK << 4))); - + pixel_weights = weights + ((x >> (SCALE_SHIFT - SUBSAMPLE_BITS)) & SUBSAMPLE_MASK) * 4; + w1 = pixel_weights[0]; w2 = pixel_weights[1]; w3 = pixel_weights[2]; @@ -883,9 +886,9 @@ scale_line_22_33 (int *weights, int n_x, int n_y, g += w4 * q1[5]; b += w4 * q1[6]; - dest[0] = r >> 16; - dest[1] = g >> 16; - dest[2] = b >> 16; + dest[0] = (r + 0x8000) >> 16; + dest[1] = (g + 0x8000) >> 16; + dest[2] = (b + 0x8000) >> 16; dest += 3; @@ -894,7 +897,6 @@ scale_line_22_33 (int *weights, int n_x, int n_y, return dest; } -#endif /* SCALE_LINE_22_33_USED */ static void process_pixel (int *weights, int n_x, int n_y, @@ -1227,7 +1229,7 @@ bilinear_make_fast_weights (PixopsFilter *filter, double x_scale, double y_scale for (i = 0; i < n_y; i++) for (j = 0; j < n_x; j++) - *(pixel_weights + n_x * i + j) = 65536 * x_weights[j] * x_scale * y_weights[i] * y_scale * overall_alpha; + *(pixel_weights + n_x * i + j) = 65536 * x_weights[j] * x_scale * y_weights[i] * y_scale * overall_alpha + 0.5; } g_free (x_weights); @@ -1412,6 +1414,30 @@ pixops_composite_color (guchar *dest_buf, g_free (filter.weights); } +/** + * pixops_composite: + * @dest_buf: pointer to location to store result + * @render_x0: x0 of region of scaled source to store into @dest_buf + * @render_y0: y0 of region of scaled source to store into @dest_buf + * @render_x1: x1 of region of scaled source to store into @dest_buf + * @render_y1: x1 of region of scaled source to store into @dest_buf + * @dest_rowstride: rowstride of @dest_buf + * @dest_channels: number of channels in @dest_buf + * @dest_has_alpha: whether @dest_buf has alpha + * @src_buf: pointer to source pixels + * @src_width: width of source (used for clipping) + * @src_height: height of source (used for clipping) + * @src_rowstride: rowstride of source + * @src_channels: number of channels in @src_buf + * @src_has_alpha: whether @src_buf has alpha + * @scale_x: amount to scale source by in X direction + * @scale_y: amount to scale source by in Y direction + * @interp_type: type of enumeration + * @overall_alpha: overall alpha factor to multiply source by + * + * Scale source buffer by scale_x / scale_y, then composite a given rectangle + * of the result into the destination buffer. + **/ void pixops_composite (guchar *dest_buf, int render_x0, @@ -1550,12 +1576,16 @@ pixops_scale (guchar *dest_buf, break; } + if (filter.n_x == 2 && filter.n_y == 2 && dest_channels == 3 && src_channels == 3) + { #ifdef USE_MMX - if (filter.n_x == 2 && filter.n_y == 2 && - found_mmx && dest_channels == 3 && src_channels == 3) - line_func = scale_line_22_33_mmx_stub; + if (found_mmx) + line_func = scale_line_22_33_mmx_stub; + else +#endif + line_func = scale_line_22_33; + } else -#endif line_func = scale_line; pixops_process (dest_buf, render_x0, render_y0, render_x1, render_y1, diff --git a/gdk-pixbuf/pixops/scale_line_22_33_mmx.S b/gdk-pixbuf/pixops/scale_line_22_33_mmx.S index 40dec48d3..8259a9db3 100644 --- a/gdk-pixbuf/pixops/scale_line_22_33_mmx.S +++ b/gdk-pixbuf/pixops/scale_line_22_33_mmx.S @@ -55,6 +55,12 @@ _pixops_scale_line_22_33_mmx: cmpl %esi,28(%ebp) je .out +/* For the body of this loop, %mm01, %mm1, %mm2, %mm3 hold the 4 adjoining + * points we are interpolating between, as: + * + * 000000BB00GG00RR + */ + /* Load initial values into %mm1, %mm3 */ leal (%edx,%edx,2),%edx # Multiply by 3 @@ -82,11 +88,16 @@ _pixops_scale_line_22_33_mmx: jmp .newx .p2align 4,,7 .loop: -/* int x_index = (x & 0xf000) >> 12 */ +/* short *pixel_weights = weights + ((x >> (SCALE_SHIFT - SUBSAMPLE_BITS)) & SUBSAMPLE_MASK) * n_x * n_y + * 16 4 0xf 2 2 + */ movl %ebx,%eax andl $0xf000,%eax shrl $7,%eax +/* At this point, %edi holds weights. Load the 4 weights into %mm4,%mm5,%mm6,%mm7, multiply and + * accumulate. + */ movq (%edi,%eax),%mm4 pmullw %mm0,%mm4 movq 8(%edi,%eax),%mm5 @@ -99,7 +110,17 @@ _pixops_scale_line_22_33_mmx: paddw %mm6, %mm7 paddw %mm5, %mm7 +/* %mm7 holds the accumulated sum. Compute (C + 0x80) / 256 + */ + pxor %mm4, %mm4 + movl $8421504, %eax # 0x00808080 + movd %eax, %mm6 + punpcklbw %mm4, %mm6 + paddw %mm6, %mm7 psrlw $8, %mm7 + +/* Pack into %eax and store result + */ packuswb %mm7, %mm7 movd %mm7, %eax @@ -113,7 +134,7 @@ _pixops_scale_line_22_33_mmx: /* x += x_step; */ addl 24(%ebp),%ebx -/* x_scale = x >> 16; */ +/* x_scaled = x >> 16; */ movl %ebx,%edx sarl $16,%edx @@ -131,7 +152,6 @@ _pixops_scale_line_22_33_mmx: leal (%edx,%edx,2),%edx # Multiply by 3 movl 16(%ebp),%edi - pxor %mm4, %mm4 movzbl 2(%edi,%edx),%ecx shll $16,%ecx movzwl (%edi,%edx),%eax |