From 2c036aab4670a93490d42de3492983feb389231d Mon Sep 17 00:00:00 2001 From: Tor Andersson Date: Wed, 4 Aug 2010 13:43:58 +0000 Subject: Rearrange low level painting functions and add new functions for constant alpha painting. --- draw/blendmodes.c | 14 ++- draw/imagedraw.c | 364 +++++++++++++++++++----------------------------------- draw/meshdraw.c | 2 +- draw/pathscan.c | 4 +- draw/porterduff.c | 328 ++++++++++++++++++++++++++++++------------------ 5 files changed, 351 insertions(+), 361 deletions(-) (limited to 'draw') diff --git a/draw/blendmodes.c b/draw/blendmodes.c index 0c8c7eec..184e1a28 100644 --- a/draw/blendmodes.c +++ b/draw/blendmodes.c @@ -326,12 +326,24 @@ fz_blendnonseparable(byte * restrict bp, byte * restrict sp, int w, fz_blendmode } void -fz_blendpixmapswithmode(fz_pixmap *dst, fz_pixmap *src, fz_blendmode blendmode) +fz_blendpixmap(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_blendmode blendmode) { unsigned char *sp, *dp; fz_bbox bbox; int x, y, w, h, n; + /* TODO: fix this hack! */ + if (alpha < 255) + { + sp = src->samples; + n = src->w * src->h * src->n; + while (n--) + { + *sp = fz_mul255(*sp, alpha); + sp++; + } + } + bbox = fz_boundpixmap(dst); bbox = fz_intersectbbox(bbox, fz_boundpixmap(src)); diff --git a/draw/imagedraw.c b/draw/imagedraw.c index a626deb7..b9bb2702 100644 --- a/draw/imagedraw.c +++ b/draw/imagedraw.c @@ -1,301 +1,194 @@ #include "fitz.h" -#define noNEAREST +#define LINEAR typedef unsigned char byte; -/* Sample image and clamp to edge */ - -static inline byte -getmask(byte *s, int w, int h, int u, int v) +static inline float roundup(float x) { - if (u < 0) u = 0; - if (v < 0) v = 0; - if (u >= w) u = w - 1; - if (v >= h) v = h - 1; - return s[w * v + u]; + return (x < 0) ? floorf(x) : ceilf(x); } -static inline byte * -getga(byte *s, int w, int h, int u, int v) +#ifdef LINEAR + +static inline int lerp(int a, int b, int t) { - if (u < 0) u = 0; - if (v < 0) v = 0; - if (u >= w) u = w - 1; - if (v >= h) v = h - 1; - return s + ((w * v + u) << 1); + return a + (((b - a) * t) >> 16); } -static inline byte * -getrgba(byte *s, int w, int h, int u, int v) +static inline int bilerp(int a, int b, int c, int d, int u, int v) { - if (u < 0) u = 0; - if (v < 0) v = 0; - if (u >= w) u = w - 1; - if (v >= h) v = h - 1; - return s + ((w * v + u) << 2); + return lerp(lerp(a, b, u), lerp(c, d, u), v); } -static inline int -getcolor(byte *s, int w, int h, int n, int u, int v, int k) +static inline byte *samplenearest(byte *s, int w, int h, int n, int u, int v) { if (u < 0) u = 0; if (v < 0) v = 0; if (u >= w) u = w - 1; if (v >= h) v = h - 1; - return s[w * v * n + u + k]; -} - -/* Bi-linear interpolation of sample */ - -static inline int -lerp(int a, int b, int t) -{ - return a + (((b - a) * t) >> 16); -} - -static inline void -lerpga(byte *dst, byte *a, byte *b, int t) -{ - dst[0] = lerp(a[0], b[0], t); - dst[1] = lerp(a[1], b[1], t); -} - -static inline void -lerprgba(byte *dst, byte *a, byte *b, int t) -{ - dst[0] = lerp(a[0], b[0], t); - dst[1] = lerp(a[1], b[1], t); - dst[2] = lerp(a[2], b[2], t); - dst[3] = lerp(a[3], b[3], t); -} - -static inline int -samplemask(byte *s, int w, int h, int u, int v) -{ -#ifdef NEAREST - return getmask(s, w, h, u >> 16, v >> 16); -#else - int ui = u >> 16; - int vi = v >> 16; - int ud = u & 0xFFFF; - int vd = v & 0xFFFF; - int a = getmask(s, w, h, ui, vi); - int b = getmask(s, w, h, ui+1, vi); - int c = getmask(s, w, h, ui, vi+1); - int d = getmask(s, w, h, ui+1, vi+1); - int ab = lerp(a, b, ud); - int cd = lerp(c, d, ud); - return lerp(ab, cd, vd); -#endif + return s + (v * w + u) * n; } -static inline void -samplega(byte *s, int w, int h, int u, int v, int *gout, int *aout) -{ -#ifdef NEAREST - byte *ga = getga(s, w, h, u >> 16, v >> 16); - *gout = ga[0]; - *aout = ga[1]; -#else - byte ab[2]; - byte cd[2]; - byte abcd[2]; - int ui = u >> 16; - int vi = v >> 16; - int ud = u & 0xFFFF; - int vd = v & 0xFFFF; - byte *a = getga(s, w, h, ui, vi); - byte *b = getga(s, w, h, ui+1, vi); - byte *c = getga(s, w, h, ui, vi+1); - byte *d = getga(s, w, h, ui+1, vi+1); - lerpga(ab, a, b, ud); - lerpga(cd, c, d, ud); - lerpga(abcd, ab, cd, vd); - *gout = abcd[0]; - *aout = abcd[1]; #endif -} -static inline void -samplergba(byte *s, int w, int h, int u, int v, int *rout, int *gout, int *bout, int *aout) -{ -#ifdef NEAREST - byte *rgba = getrgba(s, w, h, u >> 16, v >> 16); - *rout = rgba[0]; - *gout = rgba[1]; - *bout = rgba[2]; - *aout = rgba[3]; -#else - byte ab[4]; - byte cd[4]; - byte abcd[4]; - int ui = u >> 16; - int vi = v >> 16; - int ud = u & 0xFFFF; - int vd = v & 0xFFFF; - byte *a = getrgba(s, w, h, ui, vi); - byte *b = getrgba(s, w, h, ui+1, vi); - byte *c = getrgba(s, w, h, ui, vi+1); - byte *d = getrgba(s, w, h, ui+1, vi+1); - lerprgba(ab, a, b, ud); - lerprgba(cd, c, d, ud); - lerprgba(abcd, ab, cd, vd); - *rout = abcd[0]; - *gout = abcd[1]; - *bout = abcd[2]; - *aout = abcd[3]; -#endif -} +/* Blend premultiplied source image in constant alpha over destination */ static inline void -samplecolor(byte *s, int w, int h, int n, int u, int v, byte *out) +fz_paintaffinealphaN(byte *dp, byte *sp, int sw, int sh, int u, int v, int fa, int fb, int w, int n, int alpha) { -#ifdef NEAREST - int k; - for (k = 0; k < n; k++) - out[k] = getcolor(s, w, h, n, u >> 16, v >> 16, k); -#else - int ui = u >> 16; - int vi = v >> 16; - int ud = u & 0xFFFF; - int vd = v & 0xFFFF; int k; - for (k = 0; k < n; k++) - { - int a = getcolor(s, w, h, n, ui, vi, k); - int b = getcolor(s, w, h, n, ui+1, vi, k); - int c = getcolor(s, w, h, n, ui, vi+1, k); - int d = getcolor(s, w, h, n, ui+1, vi+1, k); - int ab = lerp(a, b, ud); - int cd = lerp(c, d, ud); - out[k] = lerp(ab, cd, vd); - } -#endif -} - -/* Blend source image scanline over destination */ -#define INSIDEU u >= 0 && u <= (sw << 16) -#define INSIDEV v >= 0 && v <= (sh << 16) -#define INSIDE INSIDEU && INSIDEV - -static inline void -fz_blendscan1(unsigned char *dp, unsigned char *sp, int sw, int sh, - int u, int v, int fa, int fb, int w) -{ while (w--) { - if (INSIDE) + int ui = u >> 16; + int vi = v >> 16; + if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) { - int a = samplemask(sp, sw, sh, u, v); - dp[0] = a + fz_mul255(dp[0], 255 - a); +#ifdef LINEAR + int uf = u & 0xffff; + int vf = v & 0xffff; + byte *a = samplenearest(sp, sw, sh, n, ui, vi); + byte *b = samplenearest(sp, sw, sh, n, ui+1, vi); + byte *c = samplenearest(sp, sw, sh, n, ui, vi+1); + byte *d = samplenearest(sp, sw, sh, n, ui+1, vi+1); + int x = bilerp(a[n-1], b[n-1], c[n-1], d[n-1], uf, vf); + int t = 255 - fz_mul255(x, alpha); + for (k = 0; k < n; k++) + { + x = bilerp(a[k], b[k], c[k], d[k], uf, vf); + dp[k] = x + fz_mul255(dp[k], t); + } +#else + byte *sample = sp + ((vi * sw + ui) * n); + int t = 255 - fz_mul255(sample[n-1], alpha); + for (k = 0; k < n; k++) + dp[k] = sample[k] + fz_mul255(dp[k], t); +#endif } - dp ++; + dp += n; u += fa; v += fb; } } +/* Blend premultiplied source image over destination */ + static inline void -fz_blendscan2(unsigned char *dp, unsigned char *sp, int sw, int sh, - int u, int v, int fa, int fb, int w) +fz_paintaffineN(byte *dp, byte *sp, int sw, int sh, int u, int v, int fa, int fb, int w, int n) { + int k; + while (w--) { - if (INSIDE) + int ui = u >> 16; + int vi = v >> 16; + if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) { - int g, a, t; - samplega(sp, sw, sh, u, v, &g, &a); - t = 255 - a; - dp[0] = g + fz_mul255(dp[0], t); - dp[1] = a + fz_mul255(dp[1], t); +#ifdef LINEAR + int uf = u & 0xffff; + int vf = v & 0xffff; + byte *a = samplenearest(sp, sw, sh, n, ui, vi); + byte *b = samplenearest(sp, sw, sh, n, ui+1, vi); + byte *c = samplenearest(sp, sw, sh, n, ui, vi+1); + byte *d = samplenearest(sp, sw, sh, n, ui+1, vi+1); + int t = 255 - bilerp(a[n-1], b[n-1], c[n-1], d[n-1], uf, vf); + for (k = 0; k < n; k++) + { + int x = bilerp(a[k], b[k], c[k], d[k], uf, vf); + dp[k] = x + fz_mul255(dp[k], t); + } +#else + byte *sample = sp + ((vi * sw + ui) * n); + int t = 255 - sample[n-1]; + for (k = 0; k < n; k++) + dp[k] = sample[k] + fz_mul255(dp[k], t); +#endif } - dp += 2; + dp += n; u += fa; v += fb; } } +/* Blend non-premultiplied color in source image mask over destination */ + static inline void -fz_blendscan4(unsigned char *dp, unsigned char *sp, int sw, int sh, - int u, int v, int fa, int fb, int w) +fz_paintaffinecolorN(byte *dp, byte *sp, int sw, int sh, int u, int v, int fa, int fb, int w, int n, byte *color) { + int sa = color[n-1]; + int k; + while (w--) { - if (INSIDE) + int ui = u >> 16; + int vi = v >> 16; + if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) { - int r, g, b, a, t; - samplergba(sp, sw, sh, u, v, &r, &g, &b, &a); - t = 255 - a; - dp[0] = r + fz_mul255(dp[0], t); - dp[1] = g + fz_mul255(dp[1], t); - dp[2] = b + fz_mul255(dp[2], t); - dp[3] = a + fz_mul255(dp[3], t); +#ifdef LINEAR + int uf = u & 0xffff; + int vf = v & 0xffff; + byte *a = samplenearest(sp, sw, sh, 1, ui, vi); + byte *b = samplenearest(sp, sw, sh, 1, ui+1, vi); + byte *c = samplenearest(sp, sw, sh, 1, ui, vi+1); + byte *d = samplenearest(sp, sw, sh, 1, ui+1, vi+1); + int ma = bilerp(a[0], b[0], c[0], d[0], uf, vf); +#else + int ma = sp[vi * sw + ui]; +#endif + int masa = FZ_COMBINE(FZ_EXPAND(ma), sa); + for (k = 0; k < n - 1; k++) + dp[k] = FZ_BLEND(color[k], dp[k], masa); + dp[k] = FZ_BLEND(255, dp[k], masa); } - dp += 4; + dp += n; u += fa; v += fb; } } -static inline void -fz_blendscan(unsigned char *dp, unsigned char *sp, int sw, int sh, - int u, int v, int fa, int fb, int w, int n) +void +fz_paintaffine(byte *dp, byte *sp, int sw, int sh, int u, int v, int fa, int fb, int w, int n, int alpha) { - while (w--) + if (alpha == 255) { - if (INSIDE) + switch (n) { - unsigned char color[FZ_MAXCOLORS+1]; - int k, t; - samplecolor(sp, sw, sh, n, u, v, color); - t = 255 - color[n-1]; - for (k = 0; k < n; k++) - dp[k] = color[k] + fz_mul255(dp[k], t); + case 1: fz_paintaffineN(dp, sp, sw, sh, u, v, fa, fb, w, 1); break; + case 2: fz_paintaffineN(dp, sp, sw, sh, u, v, fa, fb, w, 2); break; + case 4: fz_paintaffineN(dp, sp, sw, sh, u, v, fa, fb, w, 4); break; + default: fz_paintaffineN(dp, sp, sw, sh, u, v, fa, fb, w, n); break; } - dp += n; - u += fa; - v += fb; } -} - -/* Blend non-premultiplied color in image mask over destination */ - -static inline void -fz_blendscanwithcolor(unsigned char *dp, unsigned char *sp, int sw, int sh, - int u, int v, int fa, int fb, int w, int n, unsigned char *color) -{ - int sa = color[n-1]; - while (w--) + else if (alpha > 0) { - if (INSIDE) + switch (n) { - int ma = samplemask(sp, sw, sh, u, v); - int masa = fz_mul255(sa, ma); - int t = 255 - masa; - int k; - for (k = 0; k < n; k++) - dp[k] = fz_mul255(color[k], ma) + fz_mul255(dp[k], t); + case 1: fz_paintaffinealphaN(dp, sp, sw, sh, u, v, fa, fb, w, 1, alpha); break; + case 2: fz_paintaffinealphaN(dp, sp, sw, sh, u, v, fa, fb, w, 2, alpha); break; + case 4: fz_paintaffinealphaN(dp, sp, sw, sh, u, v, fa, fb, w, 4, alpha); break; + default: fz_paintaffinealphaN(dp, sp, sw, sh, u, v, fa, fb, w, n, alpha); break; } - dp += n; - u += fa; - v += fb; } } -/* Draw an image with an affine transform on destination */ - -static inline float roundup(float x) +void +fz_paintaffinecolor(byte *dp, byte *sp, int sw, int sh, int u, int v, int fa, int fb, int w, int n, byte *color) { - return (x < 0) ? floorf(x) : ceilf(x); + switch (n) + { + case 2: fz_paintaffinecolorN(dp, sp, sw, sh, u, v, fa, fb, w, 2, color); break; + case 4: fz_paintaffinecolorN(dp, sp, sw, sh, u, v, fa, fb, w, 4, color); break; + default: fz_paintaffinecolorN(dp, sp, sw, sh, u, v, fa, fb, w, n, color); break; + } } +/* Draw an image with an affine transform on destination */ + static void -fz_blendimageimp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, - unsigned char *color) +fz_paintimageimp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, byte *color, int alpha) { - unsigned char *dp, *sp; + byte *dp, *sp; int u, v, fa, fb, fc, fd; int x, y, w, h; int sw, sh, n; @@ -339,22 +232,14 @@ fz_blendimageimp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, sw = img->w; sh = img->h; + /* TODO: if (fb == 0 && fa == 1) call fz_paintspan */ + while (h--) { if (color) - { - fz_blendscanwithcolor(dp, sp, sw, sh, u, v, fa, fb, w, n, color); - } + fz_paintaffinecolor(dp, sp, sw, sh, u, v, fa, fb, w, n, color); else - { - switch (n) - { - case 1: fz_blendscan1(dp, sp, sw, sh, u, v, fa, fb, w); break; - case 2: fz_blendscan2(dp, sp, sw, sh, u, v, fa, fb, w); break; - case 4: fz_blendscan4(dp, sp, sw, sh, u, v, fa, fb, w); break; - default: fz_blendscan(dp, sp, sw, sh, u, v, fa, fb, w, n); break; - } - } + fz_paintaffine(dp, sp, sw, sh, u, v, fa, fb, w, n, alpha); dp += dst->w * n; u += fc; v += fd; @@ -362,16 +247,15 @@ fz_blendimageimp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, } void -fz_blendimagewithcolor(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, - unsigned char *color) +fz_paintimagecolor(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, byte *color) { assert(img->n == 1); - fz_blendimageimp(dst, scissor, img, ctm, color); + fz_paintimageimp(dst, scissor, img, ctm, color, 255); } void -fz_blendimage(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm) +fz_paintimage(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *img, fz_matrix ctm, int alpha) { assert(dst->n == img->n); - fz_blendimageimp(dst, scissor, img, ctm, nil); + fz_paintimageimp(dst, scissor, img, ctm, nil, alpha); } diff --git a/draw/meshdraw.c b/draw/meshdraw.c index 4fbdab70..61b678ab 100644 --- a/draw/meshdraw.c +++ b/draw/meshdraw.c @@ -378,7 +378,7 @@ fz_rendershade(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) *d++ = clut[v][k]; *d++ = *s++; } - fz_blendpixmaps(dest, conv); + fz_paintpixmap(dest, conv, 255); fz_droppixmap(conv); fz_droppixmap(temp); } diff --git a/draw/pathscan.c b/draw/pathscan.c index dc6c6ff8..459dd306 100644 --- a/draw/pathscan.c +++ b/draw/pathscan.c @@ -476,9 +476,9 @@ blit(fz_pixmap *dest, int x, int y, unsigned char *mp, int w, unsigned char *col dp = dest->samples + ( (y - dest->y) * dest->w + (x - dest->x) ) * dest->n; if (color) - fz_blendwithcolormask(dp, color, mp, dest->n, w); + fz_paintspancolor(dp, mp, dest->n, w, color); else - fz_blendmasks(dp, mp, w); + fz_paintspan(dp, mp, 1, w, 255); } fz_error diff --git a/draw/porterduff.c b/draw/porterduff.c index e5070a5d..59a4f4d4 100644 --- a/draw/porterduff.c +++ b/draw/porterduff.c @@ -72,131 +72,172 @@ and stick to using the premultiplied form. typedef unsigned char byte; -/* Blend source alpha over destination alpha */ +/* Blend a non-premultiplied color in mask over destination */ -void -fz_blendmasks(byte * restrict dp, byte * restrict sp, int w) +static inline void +fz_paintspancolor2(byte * restrict dp, byte * restrict mp, int w, byte *color) { + int sa = FZ_EXPAND(color[1]); + int g = color[0]; while (w--) { - dp[0] = sp[0] + fz_mul255(dp[0], 255 - sp[0]); - sp++; - dp++; + int ma = *mp++; + int masa = FZ_COMBINE(FZ_EXPAND(ma), sa); + dp[0] = FZ_BLEND(g, dp[0], masa); + dp[1] = FZ_BLEND(255, dp[1], masa); + dp += 2; } } -/* Blend a non-premultiplied color in mask over destination */ +static inline void +fz_paintspancolor4(byte * restrict dp, byte * restrict mp, int w, byte *color) +{ + int sa = FZ_EXPAND(color[3]); + int r = color[0]; + int g = color[1]; + int b = color[2]; + while (w--) + { + int ma = *mp++; + int masa = FZ_COMBINE(FZ_EXPAND(ma), sa); + dp[0] = FZ_BLEND(r, dp[0], masa); + dp[1] = FZ_BLEND(g, dp[1], masa); + dp[2] = FZ_BLEND(b, dp[2], masa); + dp[3] = FZ_BLEND(255, dp[3], masa); + dp += 4; + } +} -void -fz_blendwithcolormask(byte * restrict dp, byte * restrict sp, byte * restrict mp, int n, int w) +static inline void +fz_paintspancolorN(byte * restrict dp, byte * restrict mp, int n, int w, byte *color) { - int sa, r, g, b, k; + int sa = FZ_EXPAND(color[n-1]); + int k; + while (w--) + { + int ma = *mp++; + int masa = FZ_COMBINE(FZ_EXPAND(ma), sa); + for (k = 0; k < n - 1; k++) + dp[k] = FZ_BLEND(color[k], dp[k], masa); + dp[k] = FZ_BLEND(255, dp[k], masa); + dp += n; + } +} +void +fz_paintspancolor(byte * restrict dp, byte * restrict mp, int n, int w, byte *color) +{ switch (n) { - case 2: - sa = FZ_EXPAND(sp[1]); - g = sp[0]; - while (w--) - { - int ma = *mp++; - int masa = FZ_COMBINE(FZ_EXPAND(ma), sa); - dp[0] = FZ_BLEND(g, dp[0], masa); - dp[1] = FZ_BLEND(255, dp[1], masa); - dp += 2; - } - break; - case 4: - sa = FZ_EXPAND(sp[3]); - r = sp[0]; - g = sp[1]; - b = sp[2]; - while (w--) - { - int ma = *mp++; - int masa = FZ_COMBINE(FZ_EXPAND(ma), sa); - dp[0] = FZ_BLEND(r, dp[0], masa); - dp[1] = FZ_BLEND(g, dp[1], masa); - dp[2] = FZ_BLEND(b, dp[2], masa); - dp[3] = FZ_BLEND(255, dp[3], masa); - dp += 4; - } - break; - default: - sa = FZ_EXPAND(sp[n-1]); - while (w--) - { - int ma = *mp++; - int masa = FZ_COMBINE(FZ_EXPAND(ma), sa); - for (k = 0; k < n - 1; k++) - dp[k] = FZ_BLEND(sp[k], dp[k], masa); - dp[k] = FZ_BLEND(255, dp[k], masa); - dp += n; - } + case 2: fz_paintspancolor2(dp, mp, w, color); break; + case 4: fz_paintspancolor4(dp, mp, w, color); break; + default: fz_paintspancolorN(dp, mp, n, w, color); break; } } /* Blend source in mask over destination */ -void -fz_blendwithmask(byte * restrict dp, byte * restrict sp, byte * restrict mp, int n, int w) +static inline void +fz_paintspanmask2(byte * restrict dp, byte * restrict sp, byte * restrict mp, int w) +{ + while (w--) + { + int ma = *mp++; + int masa = fz_mul255(sp[1], ma); + int t = 255 - masa; + dp[0] = fz_mul255(sp[0], ma) + fz_mul255(dp[0], t); + dp[1] = fz_mul255(sp[1], ma) + fz_mul255(dp[1], t); + sp += 2; + dp += 2; + } +} + +static inline void +fz_paintspanmask4(byte * restrict dp, byte * restrict sp, byte * restrict mp, int w) +{ + while (w--) + { + int ma = *mp++; + int masa = fz_mul255(sp[3], ma); + int t = 255 - masa; + dp[0] = fz_mul255(sp[0], ma) + fz_mul255(dp[0], t); + dp[1] = fz_mul255(sp[1], ma) + fz_mul255(dp[1], t); + dp[2] = fz_mul255(sp[2], ma) + fz_mul255(dp[2], t); + dp[3] = fz_mul255(sp[3], ma) + fz_mul255(dp[3], t); + sp += 4; + dp += 4; + } +} + +static inline void +fz_paintspanmaskN(byte * restrict dp, byte * restrict sp, byte * restrict mp, int n, int w) { int k; + while (w--) + { + int ma = *mp++; + int masa = fz_mul255(sp[n-1], ma); + int t = 255 - masa; + for (k = 0; k < n; k++) + dp[k] = fz_mul255(sp[k], ma) + fz_mul255(dp[k], t); + sp += n; + dp += n; + } +} +void +fz_paintspanmask(byte * restrict dp, byte * restrict sp, byte * restrict mp, int n, int w) +{ switch (n) { - case 2: - while (w--) - { - int ma = *mp++; - int masa = fz_mul255(sp[1], ma); - int t = 255 - masa; - dp[0] = fz_mul255(sp[0], ma) + fz_mul255(dp[0], t); - sp += 2; - dp += 2; - } - break; - case 4: - while (w--) - { - int ma = *mp++; - int masa = fz_mul255(sp[3], ma); - int t = 255 - masa; - dp[0] = fz_mul255(sp[0], ma) + fz_mul255(dp[0], t); - dp[1] = fz_mul255(sp[1], ma) + fz_mul255(dp[1], t); - dp[2] = fz_mul255(sp[2], ma) + fz_mul255(dp[2], t); - dp[3] = fz_mul255(sp[3], ma) + fz_mul255(dp[3], t); - sp += 4; - dp += 4; - } - break; - default: - while (w--) - { - int ma = *mp++; - int masa = fz_mul255(sp[n-1], ma); - int t = 255 - masa; - for (k = 0; k < n; k++) - dp[k] = fz_mul255(sp[k], ma) + fz_mul255(dp[k], t); - sp += n; - dp += n; - } + case 2: fz_paintspanmask2(dp, sp, mp, w); break; + case 4: fz_paintspanmask4(dp, sp, mp, w); break; + default: fz_paintspanmaskN(dp, sp, mp, n, w); break; } } -/* Blend source in (constant) alpha over destination */ +/* Blend source in constant alpha over destination */ -void -fz_blendwithalpha(byte * restrict dp, byte * restrict sp, int ma, int n, int w) +static inline void +fz_paintspan2alpha(byte * restrict dp, byte * restrict sp, int w, int alpha) { - int k; + while (w--) + { + int masa = fz_mul255(sp[1], alpha); + int t = 255 - masa; + dp[0] = fz_mul255(sp[0], masa) + fz_mul255(dp[0], t); + dp[1] = fz_mul255(sp[1], masa) + fz_mul255(dp[1], t); + sp += 2; + dp += 2; + } +} +static inline void +fz_paintspan4alpha(byte * restrict dp, byte * restrict sp, int w, int alpha) +{ while (w--) { - int masa = fz_mul255(sp[n-1], ma); + int masa = fz_mul255(sp[3], alpha); + int t = 255 - masa; + dp[0] = fz_mul255(sp[0], masa) + fz_mul255(dp[0], t); + dp[1] = fz_mul255(sp[1], masa) + fz_mul255(dp[1], t); + dp[2] = fz_mul255(sp[2], masa) + fz_mul255(dp[2], t); + dp[3] = fz_mul255(sp[3], masa) + fz_mul255(dp[3], t); + sp += 4; + dp += 4; + } +} + +static inline void +fz_paintspanNalpha(byte * restrict dp, byte * restrict sp, int n, int w, int alpha) +{ + int k; + while (w--) + { + int masa = fz_mul255(sp[n-1], alpha); int t = 255 - masa; for (k = 0; k < n; k++) - dp[k] = fz_mul255(sp[k], ma) + fz_mul255(dp[k], t); + dp[k] = fz_mul255(sp[k], masa) + fz_mul255(dp[k], t); sp += n; dp += n; } @@ -204,11 +245,50 @@ fz_blendwithalpha(byte * restrict dp, byte * restrict sp, int ma, int n, int w) /* Blend source over destination */ -void -fz_blendnormal(byte * restrict dp, byte * restrict sp, int n, int w) +static inline void +fz_paintspan1(byte * restrict dp, byte * restrict sp, int w) { - int k; + while (w--) + { + int t = 255 - sp[0]; + dp[0] = sp[0] + fz_mul255(dp[0], t); + sp ++; + dp ++; + } +} +static inline void +fz_paintspan2(byte * restrict dp, byte * restrict sp, int w) +{ + while (w--) + { + int t = 255 - sp[1]; + dp[0] = sp[0] + fz_mul255(dp[0], t); + dp[1] = sp[1] + fz_mul255(dp[1], t); + sp += 2; + dp += 2; + } +} + +static inline void +fz_paintspan4(byte * restrict dp, byte * restrict sp, int w) +{ + while (w--) + { + int t = 255 - sp[3]; + dp[0] = sp[0] + fz_mul255(dp[0], t); + dp[1] = sp[1] + fz_mul255(dp[1], t); + dp[2] = sp[2] + fz_mul255(dp[2], t); + dp[3] = sp[3] + fz_mul255(dp[3], t); + sp += 4; + dp += 4; + } +} + +static inline void +fz_paintspanN(byte * restrict dp, byte * restrict sp, int n, int w) +{ + int k; while (w--) { int t = 255 - sp[n-1]; @@ -219,23 +299,45 @@ fz_blendnormal(byte * restrict dp, byte * restrict sp, int n, int w) } } +void +fz_paintspan(byte * restrict dp, byte * restrict sp, int n, int w, int alpha) +{ + if (alpha == 255) + { + switch (n) + { + case 1: fz_paintspan1(dp, sp, w); break; + case 2: fz_paintspan2(dp, sp, w); break; + case 4: fz_paintspan4(dp, sp, w); break; + default: fz_paintspanN(dp, sp, n, w); break; + } + } + else if (alpha > 0) + { + switch (n) + { + case 2: fz_paintspan2alpha(dp, sp, w, alpha); break; + case 4: fz_paintspan4alpha(dp, sp, w, alpha); break; + default: fz_paintspanNalpha(dp, sp, n, w, alpha); break; + } + } +} + /* * Pixmap blending functions */ void -fz_blendpixmapswithmask(fz_pixmap *dst, fz_pixmap *src, fz_pixmap *msk) +fz_paintpixmap(fz_pixmap *dst, fz_pixmap *src, int alpha) { - unsigned char *sp, *dp, *mp; + unsigned char *sp, *dp; fz_bbox bbox; int x, y, w, h, n; assert(dst->n == src->n); - assert(msk->n == 1); bbox = fz_boundpixmap(dst); bbox = fz_intersectbbox(bbox, fz_boundpixmap(src)); - bbox = fz_intersectbbox(bbox, fz_boundpixmap(msk)); x = bbox.x0; y = bbox.y0; @@ -244,53 +346,45 @@ fz_blendpixmapswithmask(fz_pixmap *dst, fz_pixmap *src, fz_pixmap *msk) n = src->n; sp = src->samples + ((y - src->y) * src->w + (x - src->x)) * src->n; - mp = msk->samples + ((y - msk->y) * msk->w + (x - msk->x)) * msk->n; dp = dst->samples + ((y - dst->y) * dst->w + (x - dst->x)) * dst->n; while (h--) { - fz_blendwithmask(dp, sp, mp, n, w); + fz_paintspan(dp, sp, n, w, alpha); sp += src->w * n; dp += dst->w * n; - mp += msk->w; } } void -fz_blendpixmapswithalpha(fz_pixmap *dst, fz_pixmap *src, float alpha) +fz_paintpixmapmask(fz_pixmap *dst, fz_pixmap *src, fz_pixmap *msk) { - unsigned char *sp, *dp; + unsigned char *sp, *dp, *mp; fz_bbox bbox; - int x, y, w, h, n, a; + int x, y, w, h, n; assert(dst->n == src->n); + assert(msk->n == 1); bbox = fz_boundpixmap(dst); bbox = fz_intersectbbox(bbox, fz_boundpixmap(src)); + bbox = fz_intersectbbox(bbox, fz_boundpixmap(msk)); x = bbox.x0; y = bbox.y0; w = bbox.x1 - bbox.x0; h = bbox.y1 - bbox.y0; - a = alpha * 255; n = src->n; sp = src->samples + ((y - src->y) * src->w + (x - src->x)) * src->n; + mp = msk->samples + ((y - msk->y) * msk->w + (x - msk->x)) * msk->n; dp = dst->samples + ((y - dst->y) * dst->w + (x - dst->x)) * dst->n; while (h--) { - if (a == 255) - fz_blendnormal(dp, sp, n, w); - else - fz_blendwithalpha(dp, sp, a, n, w); + fz_paintspanmask(dp, sp, mp, n, w); sp += src->w * n; dp += dst->w * n; + mp += msk->w; } } - -void -fz_blendpixmaps(fz_pixmap *dst, fz_pixmap *src) -{ - fz_blendpixmapswithalpha(dst, src, 1); -} -- cgit v1.2.3