From 02299d992b5ea844a24eb4634f5dc5990cb7d7e1 Mon Sep 17 00:00:00 2001 From: Robin Watts Date: Fri, 27 May 2016 17:11:53 +0100 Subject: Rejig draw-affine.c for improved profiling. Profilers can't identify which of the switch arms we are in for the inlined function calls, so rejig the code so that each of these is a separate function. In theory this code should be faster too, as the function 'lookup' is only done one rather than once per line, but I don't expect this to make a huge difference. --- source/fitz/draw-affine.c | 2655 ++++++++++++++++++++++++++++++++++++--------- 1 file changed, 2117 insertions(+), 538 deletions(-) (limited to 'source/fitz/draw-affine.c') diff --git a/source/fitz/draw-affine.c b/source/fitz/draw-affine.c index 24ecbbe8..d58d449a 100644 --- a/source/fitz/draw-affine.c +++ b/source/fitz/draw-affine.c @@ -3,6 +3,8 @@ typedef unsigned char byte; +typedef void (paintfn_t)(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp); + static inline int lerp(int a, int b, int t) { return a + (((b - a) * t) >> 16); @@ -104,201 +106,205 @@ fz_paint_affine_alpha_g2rgb_lerp(byte * restrict dp, int da, const byte * restri } static inline void -fz_paint_affine_alpha_N_near(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, byte * restrict hp) +fz_paint_affine_alpha_N_near_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, byte * restrict hp) { int k; - - if (fa == 0) + int ui = u >> 16; + TRACK_FN(); + if (ui < 0 || ui >= sw) + return; + sp += ui * (n1+sa); + while (w--) { - int ui = u >> 16; - if (ui < 0 || ui >= sw) - return; - sp += ui * (n1+sa); - while (w--) + int vi = v >> 16; + if (vi >= 0 && vi < sh) { - int vi = v >> 16; - if (vi >= 0 && vi < sh) + const byte *sample = sp + (vi * ss); + int a = (sa ? fz_mul255(sample[n1], alpha) : alpha); + if (a != 0) { - const byte *sample = sp + (vi * ss); - int a = (sa ? fz_mul255(sample[n1], alpha) : alpha); - if (a != 0) - { - int t = 255 - a; - for (k = 0; k < n1; k++) - dp[k] = fz_mul255(sample[k], alpha) + fz_mul255(dp[k], t); - if (da) - dp[n1] = a + fz_mul255(dp[n1], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); - } + int t = 255 - a; + for (k = 0; k < n1; k++) + dp[k] = fz_mul255(sample[k], alpha) + fz_mul255(dp[k], t); + if (da) + dp[n1] = a + fz_mul255(dp[n1], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } - dp += n1+da; - if (hp) - hp++; - v += fb; } + dp += n1+da; + if (hp) + hp++; + v += fb; } - else if (fb == 0) +} + +static inline void +fz_paint_affine_alpha_N_near_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, byte * restrict hp) +{ + int k; + int vi = v >> 16; + if (vi < 0 || vi >= sh) + return; + sp += vi * ss; + while (w--) { - int vi = v >> 16; - if (vi < 0 || vi >= sh) - return; - sp += vi * ss; - while (w--) + int ui = u >> 16; + if (ui >= 0 && ui < sw) { - int ui = u >> 16; - if (ui >= 0 && ui < sw) + const byte *sample = sp + (ui * (n1+sa)); + int a = (sa ? fz_mul255(sample[n1], alpha) : alpha); + if (a != 0) { - const byte *sample = sp + (ui * (n1+sa)); - int a = (sa ? fz_mul255(sample[n1], alpha) : alpha); - if (a != 0) - { - int t = 255 - a; - for (k = 0; k < n1; k++) - dp[k] = fz_mul255(sample[k], alpha) + fz_mul255(dp[k], t); - if (da) - dp[n1] = a + fz_mul255(dp[n1], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); - } + int t = 255 - a; + for (k = 0; k < n1; k++) + dp[k] = fz_mul255(sample[k], alpha) + fz_mul255(dp[k], t); + if (da) + dp[n1] = a + fz_mul255(dp[n1], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } - dp += n1+da; - if (hp) - hp++; - u += fa; } + dp += n1+da; + if (hp) + hp++; + u += fa; } - else +} + +static inline void +fz_paint_affine_alpha_N_near(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, byte * restrict hp) +{ + int k; + + while (w--) { - while (w--) + int ui = u >> 16; + int vi = v >> 16; + if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) { - int ui = u >> 16; - int vi = v >> 16; - if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) + const byte *sample = sp + (vi * ss) + (ui * (n1+sa)); + int a = (sa ? fz_mul255(sample[n1], alpha) : alpha); + if (a != 0) { - const byte *sample = sp + (vi * ss) + (ui * (n1+sa)); - int a = (sa ? fz_mul255(sample[n1], alpha) : alpha); - if (a != 0) - { - int t = 255 - a; - for (k = 0; k < n1; k++) - dp[k] = fz_mul255(sample[k], alpha) + fz_mul255(dp[k], t); - if (da) - dp[n1] = a + fz_mul255(dp[n1], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); - } + int t = 255 - a; + for (k = 0; k < n1; k++) + dp[k] = fz_mul255(sample[k], alpha) + fz_mul255(dp[k], t); + if (da) + dp[n1] = a + fz_mul255(dp[n1], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } - dp += n1+da; - if (hp) - hp++; - u += fa; - v += fb; } + dp += n1+da; + if (hp) + hp++; + u += fa; + v += fb; } } static inline void -fz_paint_affine_alpha_g2rgb_near(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int alpha, byte * restrict hp) +fz_paint_affine_alpha_g2rgb_near_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int alpha, byte * restrict hp) { - if (fa == 0) + int ui = u >> 16; + if (ui < 0 || ui >= sw) + return; + sp += ui * (1+sa); + while (w--) { - int ui = u >> 16; - if (ui < 0 || ui >= sw) - return; - sp += ui * (1+sa); - while (w--) + int vi = v >> 16; + if (vi >= 0 && vi < sh) { - int vi = v >> 16; - if (vi >= 0 && vi < sh) + const byte *sample = sp + (vi * ss); + int x = fz_mul255(sample[0], alpha); + int a = (sa ? fz_mul255(sample[1], alpha) : alpha); + if (a != 0) { - const byte *sample = sp + (vi * ss); - int x = fz_mul255(sample[0], alpha); - int a = (sa ? fz_mul255(sample[1], alpha) : alpha); - if (a != 0) - { - int t = 255 - a; - dp[0] = x + fz_mul255(dp[0], t); - dp[1] = x + fz_mul255(dp[1], t); - dp[2] = x + fz_mul255(dp[2], t); - if (da) - dp[3] = a + fz_mul255(dp[3], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); - } + int t = 255 - a; + dp[0] = x + fz_mul255(dp[0], t); + dp[1] = x + fz_mul255(dp[1], t); + dp[2] = x + fz_mul255(dp[2], t); + if (da) + dp[3] = a + fz_mul255(dp[3], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } - dp += 3 + da; - if (hp) - hp++; - v += fb; } + dp += 3 + da; + if (hp) + hp++; + v += fb; } - else if (fb == 0) +} + +static inline void +fz_paint_affine_alpha_g2rgb_near_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int alpha, byte * restrict hp) +{ + int vi = v >> 16; + if (vi < 0 || vi >= sh) + return; + sp += vi * ss; + while (w--) { - int vi = v >> 16; - if (vi < 0 || vi >= sh) - return; - sp += vi * ss; - while (w--) + int ui = u >> 16; + if (ui >= 0 && ui < sw) { - int ui = u >> 16; - if (ui >= 0 && ui < sw) + const byte *sample = sp + (ui * (1+sa)); + int x = fz_mul255(sample[0], alpha); + int a = (sa ? fz_mul255(sample[1], alpha) : alpha); + if (a != 0) { - const byte *sample = sp + (ui * (1+sa)); - int x = fz_mul255(sample[0], alpha); - int a = (sa ? fz_mul255(sample[1], alpha) : alpha); - if (a != 0) - { - int t = 255 - a; - dp[0] = x + fz_mul255(dp[0], t); - dp[1] = x + fz_mul255(dp[1], t); - dp[2] = x + fz_mul255(dp[2], t); - if (da) - dp[3] = a + fz_mul255(dp[3], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); - } + int t = 255 - a; + dp[0] = x + fz_mul255(dp[0], t); + dp[1] = x + fz_mul255(dp[1], t); + dp[2] = x + fz_mul255(dp[2], t); + if (da) + dp[3] = a + fz_mul255(dp[3], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } - dp += 3 + da; - if (hp) - hp++; - u += fa; } + dp += 3 + da; + if (hp) + hp++; + u += fa; } - else +} + +static inline void +fz_paint_affine_alpha_g2rgb_near(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int alpha, byte * restrict hp) +{ + while (w--) { - while (w--) + int ui = u >> 16; + int vi = v >> 16; + if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) { - int ui = u >> 16; - int vi = v >> 16; - if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) + const byte *sample = sp + (vi * ss) + (ui * (1+sa)); + int x = fz_mul255(sample[0], alpha); + int a = (sa ? fz_mul255(sample[1], alpha): alpha); + if (a != 0) { - const byte *sample = sp + (vi * ss) + (ui * (1+sa)); - int x = fz_mul255(sample[0], alpha); - int a = (sa ? fz_mul255(sample[1], alpha): alpha); - if (a != 0) - { - int t = 255 - a; - dp[0] = x + fz_mul255(dp[0], t); - dp[1] = x + fz_mul255(dp[1], t); - dp[2] = x + fz_mul255(dp[2], t); - if (da) - dp[3] = a + fz_mul255(dp[3], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); - } + int t = 255 - a; + dp[0] = x + fz_mul255(dp[0], t); + dp[1] = x + fz_mul255(dp[1], t); + dp[2] = x + fz_mul255(dp[2], t); + if (da) + dp[3] = a + fz_mul255(dp[3], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } - dp += 3 + da; - if (hp) - hp++; - u += fa; - v += fb; } + dp += 3 + da; + if (hp) + hp++; + u += fa; + v += fb; } } /* Blend premultiplied source image over destination */ - static inline void fz_paint_affine_N_lerp(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, byte * restrict hp) { @@ -377,295 +383,298 @@ fz_paint_affine_solid_g2rgb_lerp(byte * restrict dp, int da, const byte * restri } static inline void -fz_paint_affine_N_near(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, byte * restrict hp) +fz_paint_affine_N_near_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, byte * restrict hp) { int k; - - if (fa == 0) + int ui = u >> 16; + if (ui < 0 || ui >= sw) + return; + sp += ui*(n1+sa); + while (w--) { - int ui = u >> 16; - if (ui < 0 || ui >= sw) - return; - sp += ui*(n1+sa); - while (w--) + int vi = v >> 16; + if (vi >= 0 && vi < sh) { - int vi = v >> 16; - if (vi >= 0 && vi < sh) + const byte *sample = sp + (vi * ss); + int a = (sa ? sample[n1] : 255); + /* If a is 0, then sample[k] = 0 for all k, as premultiplied */ + if (a != 0) { - const byte *sample = sp + (vi * ss); - int a = (sa ? sample[n1] : 255); - /* If a is 0, then sample[k] = 0 for all k, as premultiplied */ - if (a != 0) + int t = 255 - a; + if (t == 0) { - int t = 255 - a; - if (t == 0) + if (n1+da == 4 && n1+sa == 4) { - if (n1+da == 4 && n1+sa == 4) - { - *(int32_t *)dp = *(int32_t *)sample; - } - else - { - for (k = 0; k < n1; k++) - dp[k] = sample[k]; - if (da) - dp[n1] = a; - } - if (hp) - hp[0] = a; + *(int32_t *)dp = *(int32_t *)sample; } else { for (k = 0; k < n1; k++) - dp[k] = sample[k] + fz_mul255(dp[k], t); + dp[k] = sample[k]; if (da) - dp[n1] = a + fz_mul255(dp[n1], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); + dp[n1] = a; } + if (hp) + hp[0] = a; } - } - dp += n1+da; - if (hp) - hp++; - v += fb; - } - } - else if (fb == 0) - { - int vi = v >> 16; - if (vi < 0 || vi >= sh) - return; - sp += vi * ss; - while (w--) - { - int ui = u >> 16; - if (ui >= 0 && ui < sw) - { - const byte *sample = sp + (ui * (n1+sa)); - int a = sa ? sample[n1] : 255; - /* If a is 0, then sample[k] = 0 for all k, as premultiplied */ - if (a != 0) + else { - int t = 255 - a; - if (t == 0) - { - if (n1+da == 4 && n1+sa == 4) - { - *(int32_t *)dp = *(int32_t *)sample; - } - else - { - for (k = 0; k < n1; k++) - dp[k] = sample[k]; - if (da) - dp[n1] = a; - } - if (hp) - hp[0] = a; - } - else - { - for (k = 0; k < n1; k++) - dp[k] = sample[k] + fz_mul255(dp[k], t); - if(da) - dp[n1] = a + fz_mul255(dp[n1], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); - } + for (k = 0; k < n1; k++) + dp[k] = sample[k] + fz_mul255(dp[k], t); + if (da) + dp[n1] = a + fz_mul255(dp[n1], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } } - dp += n1+da; - if (hp) - hp++; - u += fa; } + dp += n1+da; + if (hp) + hp++; + v += fb; } - else +} + +static inline void +fz_paint_affine_N_near_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, byte * restrict hp) +{ + int k; + int vi = v >> 16; + if (vi < 0 || vi >= sh) + return; + sp += vi * ss; + while (w--) { - while (w--) + int ui = u >> 16; + if (ui >= 0 && ui < sw) { - int ui = u >> 16; - int vi = v >> 16; - if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) + const byte *sample = sp + (ui * (n1+sa)); + int a = sa ? sample[n1] : 255; + /* If a is 0, then sample[k] = 0 for all k, as premultiplied */ + if (a != 0) { - const byte *sample = sp + (vi * ss) + (ui * (n1+sa)); - int a = sa ? sample[n1] : 255; - /* If a is 0, then sample[k] = 0 for all k, as premultiplied */ - if (a != 0) + int t = 255 - a; + if (t == 0) { - int t = 255 - a; - if (t == 0) + if (n1+da == 4 && n1+sa == 4) { - if (n1+da == 4 && n1+sa == 4) - { - *(int32_t *)dp = *(int32_t *)sample; - } - else - { - for (k = 0; k < n1; k++) - dp[k] = sample[k]; - if (da) - dp[n1] = a; - } - if (hp) - hp[0] = a; + *(int32_t *)dp = *(int32_t *)sample; } else { for (k = 0; k < n1; k++) - dp[k] = sample[k] + fz_mul255(dp[k], t); + dp[k] = sample[k]; if (da) - dp[n1] = a + fz_mul255(dp[n1], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); + dp[n1] = a; } + if (hp) + hp[0] = a; + } + else + { + for (k = 0; k < n1; k++) + dp[k] = sample[k] + fz_mul255(dp[k], t); + if(da) + dp[n1] = a + fz_mul255(dp[n1], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } } - dp += n1+da; - if (hp) - hp++; - u += fa; - v += fb; } + dp += n1+da; + if (hp) + hp++; + u += fa; } } static inline void -fz_paint_affine_solid_g2rgb_near(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, byte * restrict hp) +fz_paint_affine_N_near(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, byte * restrict hp) { - if (fa == 0) + int k; + while (w--) { int ui = u >> 16; - if (ui < 0 || ui >= sw) - return; - sp += ui * (1+sa); - while (w--) + int vi = v >> 16; + if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) { - int vi = v >> 16; - if (vi >= 0 && vi < sh) + const byte *sample = sp + (vi * ss) + (ui * (n1+sa)); + int a = sa ? sample[n1] : 255; + /* If a is 0, then sample[k] = 0 for all k, as premultiplied */ + if (a != 0) { - const byte *sample = sp + (vi * ss); - int a = (sa ? sample[1] : 255); - if (a != 0) + int t = 255 - a; + if (t == 0) { - int x = sample[0]; - int t = 255 - a; - if (t == 0) + if (n1+da == 4 && n1+sa == 4) { - dp[0] = x; - dp[1] = x; - dp[2] = x; - if (da) - dp[3] = a; - if (hp) - hp[0] = a; + *(int32_t *)dp = *(int32_t *)sample; } else { - dp[0] = x + fz_mul255(dp[0], t); - dp[1] = x + fz_mul255(dp[1], t); - dp[2] = x + fz_mul255(dp[2], t); + for (k = 0; k < n1; k++) + dp[k] = sample[k]; if (da) - dp[3] = a + fz_mul255(dp[3], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); + dp[n1] = a; } + if (hp) + hp[0] = a; } - } - dp += 3 + da; - if (hp) - hp++; - v += fb; - } - } - else if (fb == 0) - { - int vi = v >> 16; - if (vi < 0 || vi >= sh) - return; - sp += vi * ss; - while (w--) - { - int ui = u >> 16; - if (ui >= 0 && ui < sw) - { - const byte *sample = sp + (ui * (1+sa)); - int a = (sa ? sample[1] : 255); - if (a != 0) + else { - int x = sample[0]; - int t = 255 - a; - if (t == 0) - { - dp[0] = x; - dp[1] = x; - dp[2] = x; - if (da) - dp[3] = a; - if (hp) - hp[0] = a; - } - else - { - dp[0] = x + fz_mul255(dp[0], t); - dp[1] = x + fz_mul255(dp[1], t); - dp[2] = x + fz_mul255(dp[2], t); - if (da) - dp[3] = a + fz_mul255(dp[3], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); - } + for (k = 0; k < n1; k++) + dp[k] = sample[k] + fz_mul255(dp[k], t); + if (da) + dp[n1] = a + fz_mul255(dp[n1], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } } - dp += 3 + da; - if (hp) - hp++; - u += fa; } + dp += n1+da; + if (hp) + hp++; + u += fa; + v += fb; } - else +} + +static inline void +fz_paint_affine_solid_g2rgb_near_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, byte * restrict hp) +{ + int ui = u >> 16; + if (ui < 0 || ui >= sw) + return; + sp += ui * (1+sa); + while (w--) { - while (w--) + int vi = v >> 16; + if (vi >= 0 && vi < sh) { - int ui = u >> 16; - int vi = v >> 16; - if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) + const byte *sample = sp + (vi * ss); + int a = (sa ? sample[1] : 255); + if (a != 0) { - const byte *sample = sp + (vi * ss) + (ui * (1+sa)); - int a = sa ? sample[1] : 255; - if (a != 0) + int x = sample[0]; + int t = 255 - a; + if (t == 0) { - int x = sample[0]; - int t = 255 - a; - if (t == 0) - { - dp[0] = x; - dp[1] = x; - dp[2] = x; - if (da) - dp[3] = a; - if (hp) - hp[0] = a; - } - else - { - dp[0] = x + fz_mul255(dp[0], t); - dp[1] = x + fz_mul255(dp[1], t); - dp[2] = x + fz_mul255(dp[2], t); - if (da) - dp[3] = a + fz_mul255(dp[3], t); - if (hp) - hp[0] = a + fz_mul255(hp[0], t); - } + dp[0] = x; + dp[1] = x; + dp[2] = x; + if (da) + dp[3] = a; + if (hp) + hp[0] = a; + } + else + { + dp[0] = x + fz_mul255(dp[0], t); + dp[1] = x + fz_mul255(dp[1], t); + dp[2] = x + fz_mul255(dp[2], t); + if (da) + dp[3] = a + fz_mul255(dp[3], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); + } + } + } + dp += 3 + da; + if (hp) + hp++; + v += fb; + } +} + +static inline void +fz_paint_affine_solid_g2rgb_near_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, byte * restrict hp) +{ + int vi = v >> 16; + if (vi < 0 || vi >= sh) + return; + sp += vi * ss; + while (w--) + { + int ui = u >> 16; + if (ui >= 0 && ui < sw) + { + const byte *sample = sp + (ui * (1+sa)); + int a = (sa ? sample[1] : 255); + if (a != 0) + { + int x = sample[0]; + int t = 255 - a; + if (t == 0) + { + dp[0] = x; + dp[1] = x; + dp[2] = x; + if (da) + dp[3] = a; + if (hp) + hp[0] = a; + } + else + { + dp[0] = x + fz_mul255(dp[0], t); + dp[1] = x + fz_mul255(dp[1], t); + dp[2] = x + fz_mul255(dp[2], t); + if (da) + dp[3] = a + fz_mul255(dp[3], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); + } + } + } + dp += 3 + da; + if (hp) + hp++; + u += fa; + } +} + +static inline void +fz_paint_affine_solid_g2rgb_near(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, byte * restrict hp) +{ + while (w--) + { + int ui = u >> 16; + int vi = v >> 16; + if (ui >= 0 && ui < sw && vi >= 0 && vi < sh) + { + const byte *sample = sp + (vi * ss) + (ui * (1+sa)); + int a = sa ? sample[1] : 255; + if (a != 0) + { + int x = sample[0]; + int t = 255 - a; + if (t == 0) + { + dp[0] = x; + dp[1] = x; + dp[2] = x; + if (da) + dp[3] = a; + if (hp) + hp[0] = a; + } + else + { + dp[0] = x + fz_mul255(dp[0], t); + dp[1] = x + fz_mul255(dp[1], t); + dp[2] = x + fz_mul255(dp[2], t); + if (da) + dp[3] = a + fz_mul255(dp[3], t); + if (hp) + hp[0] = a + fz_mul255(hp[0], t); } } - dp += 3 + da; - if (hp) - hp++; - u += fa; - v += fb; } + dp += 3 + da; + if (hp) + hp++; + u += fa; + v += fb; } } @@ -741,8 +750,240 @@ fz_paint_affine_color_N_near(byte * restrict dp, int da, const byte * restrict s } } +/* LERP DA + SA Solid */ +static void +fz_paint_affine_lerp_da_sa_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_lerp_da_sa_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_lerp_da_sa_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_lerp_da_sa_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); +} + +/* LERP DA + SA Alpha */ +static void +fz_paint_affine_lerp_da_sa_alpha_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_lerp_da_sa_alpha_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_lerp_da_sa_alpha_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_lerp_da_sa_alpha_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); +} + +/* LERP DA Solid */ +static void +fz_paint_affine_lerp_da_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_lerp_da_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_lerp_da_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_lerp_da_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); +} + +/* LERP DA Alpha */ +static void +fz_paint_affine_lerp_da_alpha_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_lerp_da_alpha_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_lerp_da_alpha_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_lerp_da_alpha_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); +} + +/* LERP SA Solid */ +static void +fz_paint_affine_lerp_sa_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_lerp_sa_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_lerp_sa_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_lerp_sa_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); +} + +/* LERP SA Alpha */ +static void +fz_paint_affine_lerp_sa_alpha_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_lerp_sa_alpha_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_lerp_sa_alpha_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_lerp_sa_alpha_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); +} + +/* LERP Solid */ +static void +fz_paint_affine_lerp_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_lerp_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_lerp_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_lerp_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); +} + +/* LERP Alpha */ +static void +fz_paint_affine_lerp_alpha_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_lerp_alpha_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_lerp_alpha_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); +} + static void -fz_paint_affine_lerp(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color/*unused*/, byte * restrict hp) +fz_paint_affine_lerp_alpha_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); +} + +static paintfn_t * +fz_paint_affine_lerp(int da, int sa, int fa, int fb, int n, int alpha) { if (da) { @@ -752,20 +993,20 @@ fz_paint_affine_lerp(byte * restrict dp, int da, const byte * restrict sp, int s { switch (n) { - case 1: TRACK_LABEL("alds11"); fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); break; - case 3: TRACK_LABEL("alds13"); fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); break; - case 4: TRACK_LABEL("alds14"); fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); break; - default: TRACK_LABEL("alds1n"); fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); break; + case 1: return fz_paint_affine_lerp_da_sa_1; + case 3: return fz_paint_affine_lerp_da_sa_3; + case 4: return fz_paint_affine_lerp_da_sa_4; + default: return fz_paint_affine_lerp_da_sa_N; } } else if (alpha > 0) { switch (n) { - case 1: TRACK_LABEL("aldsa1"); fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); break; - case 3: TRACK_LABEL("aldsa3"); fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); break; - case 4: TRACK_LABEL("aldsa4"); fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); break; - default: TRACK_LABEL("aldsan"); fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); break; + case 1: return fz_paint_affine_lerp_da_sa_alpha_1; + case 3: return fz_paint_affine_lerp_da_sa_alpha_3; + case 4: return fz_paint_affine_lerp_da_sa_alpha_4; + default: return fz_paint_affine_lerp_da_sa_alpha_N; } } } @@ -775,20 +1016,20 @@ fz_paint_affine_lerp(byte * restrict dp, int da, const byte * restrict sp, int s { switch (n) { - case 1: TRACK_LABEL("ald11"); fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); break; - case 3: TRACK_LABEL("ald13"); fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); break; - case 4: TRACK_LABEL("ald14"); fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); break; - default: TRACK_LABEL("ald1n"); fz_paint_affine_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); break; + case 1: return fz_paint_affine_lerp_da_1; + case 3: return fz_paint_affine_lerp_da_3; + case 4: return fz_paint_affine_lerp_da_4; + default: return fz_paint_affine_lerp_da_N; } } else if (alpha > 0) { switch (n) { - case 1: TRACK_LABEL("alda1"); fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); break; - case 3: TRACK_LABEL("alda3"); fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); break; - case 4: TRACK_LABEL("alda4"); fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); break; - default: TRACK_LABEL("aldan"); fz_paint_affine_alpha_N_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); break; + case 1: return fz_paint_affine_lerp_da_alpha_1; + case 3: return fz_paint_affine_lerp_da_alpha_3; + case 4: return fz_paint_affine_lerp_da_alpha_4; + default: return fz_paint_affine_lerp_da_alpha_N; } } } @@ -801,20 +1042,20 @@ fz_paint_affine_lerp(byte * restrict dp, int da, const byte * restrict sp, int s { switch (n) { - case 1: TRACK_LABEL("als11"); fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); break; - case 3: TRACK_LABEL("als13"); fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); break; - case 4: TRACK_LABEL("als14"); fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); break; - default: TRACK_LABEL("als1n"); fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); break; + case 1: return fz_paint_affine_lerp_sa_1; + case 3: return fz_paint_affine_lerp_sa_3; + case 4: return fz_paint_affine_lerp_sa_4; + default: return fz_paint_affine_lerp_sa_N; } } else if (alpha > 0) { switch (n) { - case 1: TRACK_LABEL("alsa1"); fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); break; - case 3: TRACK_LABEL("alsa3"); fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); break; - case 4: TRACK_LABEL("alsa4"); fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); break; - default: TRACK_LABEL("alsan"); fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); break; + case 1: return fz_paint_affine_lerp_sa_alpha_1; + case 3: return fz_paint_affine_lerp_sa_alpha_3; + case 4: return fz_paint_affine_lerp_sa_alpha_4; + default: return fz_paint_affine_lerp_sa_alpha_N; } } } @@ -824,56 +1065,101 @@ fz_paint_affine_lerp(byte * restrict dp, int da, const byte * restrict sp, int s { switch (n) { - case 1: TRACK_LABEL("al11"); fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); break; - case 3: TRACK_LABEL("al13"); fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); break; - case 4: TRACK_LABEL("al14"); fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); break; - default: TRACK_LABEL("al1n"); fz_paint_affine_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); break; + case 1: return fz_paint_affine_lerp_1; + case 3: return fz_paint_affine_lerp_3; + case 4: return fz_paint_affine_lerp_4; + default: return fz_paint_affine_lerp_N; } } else if (alpha > 0) { switch (n) { - case 1: TRACK_LABEL("al11"); fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); break; - case 3: TRACK_LABEL("al13"); fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); break; - case 4: TRACK_LABEL("al14"); fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); break; - default: TRACK_LABEL("al1n"); fz_paint_affine_alpha_N_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); break; + case 1: return fz_paint_affine_lerp_alpha_1; + case 3: return fz_paint_affine_lerp_alpha_3; + case 4: return fz_paint_affine_lerp_alpha_4; + default: return fz_paint_affine_lerp_alpha_N; } } } } + return NULL; +} + +static void +fz_paint_affine_lerp_da_sa_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_lerp_da_sa_g2rgb_alpha(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_lerp_da_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); } static void -fz_paint_affine_g2rgb_lerp(byte *dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color/*unused*/, byte * restrict hp) +fz_paint_affine_lerp_da_g2rgb_alpha(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_lerp_sa_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_lerp_sa_g2rgb_alpha(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_lerp_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_lerp_g2rgb_alpha(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); +} + +static paintfn_t * +fz_paint_affine_g2rgb_lerp(int da, int sa, int fa, int fb, int n, int alpha) { if (da) { if (sa) { if (alpha == 255) - { - TRACK_LABEL("aglds1"); - fz_paint_affine_solid_g2rgb_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); - } + return fz_paint_affine_lerp_da_sa_g2rgb; else if (alpha > 0) - { - TRACK_LABEL("agldsa"); - fz_paint_affine_alpha_g2rgb_lerp(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); - } + return fz_paint_affine_lerp_da_sa_g2rgb_alpha; } else { if (alpha == 255) - { - TRACK_LABEL("agld1"); - fz_paint_affine_solid_g2rgb_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); - } + return fz_paint_affine_lerp_da_g2rgb; else if (alpha > 0) - { - TRACK_LABEL("aglda"); - fz_paint_affine_alpha_g2rgb_lerp(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); - } + return fz_paint_affine_lerp_da_g2rgb_alpha; } } else @@ -881,34 +1167,803 @@ fz_paint_affine_g2rgb_lerp(byte *dp, int da, const byte * restrict sp, int sw, i if (sa) { if (alpha == 255) - { - TRACK_LABEL("agls1"); - fz_paint_affine_solid_g2rgb_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); - } + return fz_paint_affine_lerp_sa_g2rgb; else if (alpha > 0) - { - TRACK_LABEL("aglsa"); - fz_paint_affine_alpha_g2rgb_lerp(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); - } + return fz_paint_affine_lerp_sa_g2rgb_alpha; } else { if (alpha == 255) - { - TRACK_LABEL("agl1"); - fz_paint_affine_solid_g2rgb_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); - } + return fz_paint_affine_lerp_g2rgb; else if (alpha > 0) - { - TRACK_LABEL("agla"); - fz_paint_affine_alpha_g2rgb_lerp(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); - } + return fz_paint_affine_lerp_g2rgb_alpha; } } + return NULL; +} + +/* Near DA+SA Solid fa==0 */ +static void +fz_paint_affine_near_da_sa_0_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 0, hp); +} + +static void +fz_paint_affine_near_da_sa_1_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_da_sa_3_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_da_sa_4_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_da_sa_N_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); +} + +/* Near DA+SA Alpha */ +static void +fz_paint_affine_near_da_sa_alpha_0_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 0, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_1_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_3_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_4_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_N_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near DA Solid */ +static void +fz_paint_affine_near_da_0_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 0, hp); +} + +static void +fz_paint_affine_near_da_1_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_da_3_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_da_4_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_da_N_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); +} + +/* Near DA Alpha */ +static void +fz_paint_affine_near_da_alpha_0_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 0, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_1_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_3_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_4_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_N_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near SA Solid */ +static void +fz_paint_affine_near_sa_1_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_sa_3_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_sa_4_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_sa_N_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); +} + +/* Near SA Alpha */ +static void +fz_paint_affine_near_sa_alpha_1_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_sa_alpha_3_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_sa_alpha_4_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_sa_alpha_N_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near Solid */ +static void +fz_paint_affine_near_1_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_3_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_4_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_N_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); +} + +/* Near Alpha */ +static void +fz_paint_affine_near_alpha_1_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_alpha_3_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_alpha_4_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_alpha_N_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near DA+SA Solid */ +static void +fz_paint_affine_near_da_sa_0_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 0, hp); +} + +static void +fz_paint_affine_near_da_sa_1_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_da_sa_3_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_da_sa_4_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_da_sa_N_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); +} + +/* Near DA+SA Alpha */ +static void +fz_paint_affine_near_da_sa_alpha_0_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 0, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_1_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_3_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_4_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_N_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near DA Solid */ +static void +fz_paint_affine_near_da_0_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 0, hp); +} + +static void +fz_paint_affine_near_da_1_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_da_3_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_da_4_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_da_N_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); +} + +/* Near DA Alpha */ +static void +fz_paint_affine_near_da_alpha_0_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 0, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_1_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_3_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_4_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); } static void -fz_paint_affine_near(byte *dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color/*unused */, byte * restrict hp) +fz_paint_affine_near_da_alpha_N_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near SA Solid */ +static void +fz_paint_affine_near_sa_1_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_sa_3_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_sa_4_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_sa_N_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); +} + +/* Near SA Alpha */ +static void +fz_paint_affine_near_sa_alpha_1_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_sa_alpha_3_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_sa_alpha_4_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_sa_alpha_N_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near Solid */ +static void +fz_paint_affine_near_1_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_3_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_4_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_N_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); +} + +/* Near Alpha */ +static void +fz_paint_affine_near_alpha_1_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_alpha_3_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_alpha_4_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_alpha_N_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near DA+SA Solid */ +static void +fz_paint_affine_near_da_sa_0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 0, hp); +} + +static void +fz_paint_affine_near_da_sa_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_da_sa_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_da_sa_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_da_sa_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); +} + +/* Near DA+SA Alpha */ +static void +fz_paint_affine_near_da_sa_alpha_0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 0, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near DA Solid */ +static void +fz_paint_affine_near_da_0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 0, hp); +} + +static void +fz_paint_affine_near_da_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_da_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_da_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_da_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); +} + +/* Near DA Alpha */ +static void +fz_paint_affine_near_da_alpha_0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 0, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_da_alpha_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near SA Solid */ +static void +fz_paint_affine_near_sa_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_sa_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_sa_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_sa_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); +} + +/* Near SA Alpha */ +static void +fz_paint_affine_near_sa_alpha_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_sa_alpha_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_sa_alpha_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_sa_alpha_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); +} + +/* Near Solid */ +static void +fz_paint_affine_near_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); +} + +static void +fz_paint_affine_near_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); +} + +static void +fz_paint_affine_near_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); +} + +static void +fz_paint_affine_near_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); +} + +/* Near Alpha */ +static void +fz_paint_affine_near_alpha_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); +} + +static void +fz_paint_affine_near_alpha_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); +} + +static void +fz_paint_affine_near_alpha_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); +} + +static void +fz_paint_affine_near_alpha_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); +} + +static paintfn_t * +fz_paint_affine_near(int da, int sa, int fa, int fb, int n, int alpha) { if (da) { @@ -916,24 +1971,74 @@ fz_paint_affine_near(byte *dp, int da, const byte * restrict sp, int sw, int sh, { if (alpha == 255) { - switch (n) + if (fa == 0) + { + switch (n) + { + case 0: return fz_paint_affine_near_da_sa_0_fa0; + case 1: return fz_paint_affine_near_da_sa_1_fa0; + case 3: return fz_paint_affine_near_da_sa_3_fa0; + case 4: return fz_paint_affine_near_da_sa_4_fa0; + default: return fz_paint_affine_near_da_sa_N_fa0; + } + } + else if (fb == 0) { - case 0: TRACK_LABEL("ads10"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 0, hp); break; - case 1: TRACK_LABEL("ads11"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); break; - case 3: TRACK_LABEL("ads13"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); break; - case 4: TRACK_LABEL("ads14"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); break; - default: TRACK_LABEL("ads1n"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); break; + switch (n) + { + case 0: return fz_paint_affine_near_da_sa_0_fb0; + case 1: return fz_paint_affine_near_da_sa_1_fb0; + case 3: return fz_paint_affine_near_da_sa_3_fb0; + case 4: return fz_paint_affine_near_da_sa_4_fb0; + default: return fz_paint_affine_near_da_sa_N_fb0; + } + } + else + { + switch (n) + { + case 0: return fz_paint_affine_near_da_sa_0; + case 1: return fz_paint_affine_near_da_sa_1; + case 3: return fz_paint_affine_near_da_sa_3; + case 4: return fz_paint_affine_near_da_sa_4; + default: return fz_paint_affine_near_da_sa_N; + } } } else if (alpha > 0) { - switch (n) + if (fa == 0) + { + switch (n) + { + case 0: return fz_paint_affine_near_da_sa_alpha_0_fa0; + case 1: return fz_paint_affine_near_da_sa_alpha_1_fa0; + case 3: return fz_paint_affine_near_da_sa_alpha_3_fa0; + case 4: return fz_paint_affine_near_da_sa_alpha_4_fa0; + default: return fz_paint_affine_near_da_sa_alpha_N_fa0; + } + } + else if (fb == 0) + { + switch (n) + { + case 0: return fz_paint_affine_near_da_sa_alpha_0_fb0; + case 1: return fz_paint_affine_near_da_sa_alpha_1_fb0; + case 3: return fz_paint_affine_near_da_sa_alpha_3_fb0; + case 4: return fz_paint_affine_near_da_sa_alpha_4_fb0; + default: return fz_paint_affine_near_da_sa_alpha_N_fb0; + } + } + else { - case 0: TRACK_LABEL("adsa0"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 0, alpha, hp); break; - case 1: TRACK_LABEL("adsa1"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); break; - case 3: TRACK_LABEL("adsa3"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); break; - case 4: TRACK_LABEL("adsa4"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); break; - default: TRACK_LABEL("adsan"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); break; + switch (n) + { + case 0: return fz_paint_affine_near_da_sa_alpha_0; + case 1: return fz_paint_affine_near_da_sa_alpha_1; + case 3: return fz_paint_affine_near_da_sa_alpha_3; + case 4: return fz_paint_affine_near_da_sa_alpha_4; + default: return fz_paint_affine_near_da_sa_alpha_N; + } } } } @@ -941,24 +2046,74 @@ fz_paint_affine_near(byte *dp, int da, const byte * restrict sp, int sw, int sh, { if (alpha == 255) { - switch (n) + if (fa == 0) + { + switch (n) + { + case 0: return fz_paint_affine_near_da_0_fa0; + case 1: return fz_paint_affine_near_da_1_fa0; + case 3: return fz_paint_affine_near_da_3_fa0; + case 4: return fz_paint_affine_near_da_4_fa0; + default: return fz_paint_affine_near_da_N_fa0; + } + } + else if (fb == 0) { - case 0: TRACK_LABEL("ad10"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 0, hp); break; - case 1: TRACK_LABEL("ad11"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); break; - case 3: TRACK_LABEL("ad13"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); break; - case 4: TRACK_LABEL("ad14"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); break; - default: TRACK_LABEL("ad1n"); fz_paint_affine_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); break; + switch (n) + { + case 0: return fz_paint_affine_near_da_0_fb0; + case 1: return fz_paint_affine_near_da_1_fb0; + case 3: return fz_paint_affine_near_da_3_fb0; + case 4: return fz_paint_affine_near_da_4_fb0; + default: return fz_paint_affine_near_da_N_fb0; + } + } + else + { + switch (n) + { + case 0: return fz_paint_affine_near_da_0; + case 1: return fz_paint_affine_near_da_1; + case 3: return fz_paint_affine_near_da_3; + case 4: return fz_paint_affine_near_da_4; + default: return fz_paint_affine_near_da_N; + } } } else if (alpha > 0) { - switch (n) + if (fa == 0) + { + switch (n) + { + case 0: return fz_paint_affine_near_da_alpha_0_fa0; + case 1: return fz_paint_affine_near_da_alpha_1_fa0; + case 3: return fz_paint_affine_near_da_alpha_3_fa0; + case 4: return fz_paint_affine_near_da_alpha_4_fa0; + default: return fz_paint_affine_near_da_alpha_N_fa0; + } + } + else if (fb == 0) + { + switch (n) + { + case 0: return fz_paint_affine_near_da_alpha_0_fb0; + case 1: return fz_paint_affine_near_da_alpha_1_fb0; + case 3: return fz_paint_affine_near_da_alpha_3_fb0; + case 4: return fz_paint_affine_near_da_alpha_4_fb0; + default: return fz_paint_affine_near_da_alpha_N_fb0; + } + } + else { - case 0: TRACK_LABEL("ada0"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 0, alpha, hp); break; - case 1: TRACK_LABEL("ada1"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); break; - case 3: TRACK_LABEL("ada3"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); break; - case 4: TRACK_LABEL("ada4"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); break; - default: TRACK_LABEL("adan"); fz_paint_affine_alpha_N_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); break; + switch (n) + { + case 0: return fz_paint_affine_near_da_alpha_0; + case 1: return fz_paint_affine_near_da_alpha_1; + case 3: return fz_paint_affine_near_da_alpha_3; + case 4: return fz_paint_affine_near_da_alpha_4; + default: return fz_paint_affine_near_da_alpha_N; + } } } } @@ -969,22 +2124,68 @@ fz_paint_affine_near(byte *dp, int da, const byte * restrict sp, int sw, int sh, { if (alpha == 255) { - switch (n) + if (fa == 0) + { + switch (n) + { + case 1: return fz_paint_affine_near_sa_1_fa0; + case 3: return fz_paint_affine_near_sa_3_fa0; + case 4: return fz_paint_affine_near_sa_4_fa0; + default: return fz_paint_affine_near_sa_N_fa0; + } + } + else if (fb == 0) + { + switch (n) + { + case 1: return fz_paint_affine_near_sa_1_fb0; + case 3: return fz_paint_affine_near_sa_3_fb0; + case 4: return fz_paint_affine_near_sa_4_fb0; + default: return fz_paint_affine_near_sa_N_fb0; + } + } + else { - case 1: TRACK_LABEL("as11"); fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, hp); break; - case 3: TRACK_LABEL("as13"); fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, hp); break; - case 4: TRACK_LABEL("as14"); fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, hp); break; - default: TRACK_LABEL("as1n"); fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, hp); break; + switch (n) + { + case 1: return fz_paint_affine_near_sa_1; + case 3: return fz_paint_affine_near_sa_3; + case 4: return fz_paint_affine_near_sa_4; + default: return fz_paint_affine_near_sa_N; + } } } else if (alpha > 0) { - switch (n) + if (fa == 0) + { + switch (n) + { + case 1: return fz_paint_affine_near_sa_alpha_1_fa0; + case 3: return fz_paint_affine_near_sa_alpha_3_fa0; + case 4: return fz_paint_affine_near_sa_alpha_4_fa0; + default: return fz_paint_affine_near_sa_alpha_N_fa0; + } + } + else if (fb == 0) + { + switch (n) + { + case 1: return fz_paint_affine_near_sa_alpha_1_fb0; + case 3: return fz_paint_affine_near_sa_alpha_3_fb0; + case 4: return fz_paint_affine_near_sa_alpha_4_fb0; + default: return fz_paint_affine_near_sa_alpha_N_fb0; + } + } + else { - case 1: TRACK_LABEL("asa1"); fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 1, alpha, hp); break; - case 3: TRACK_LABEL("asa2"); fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 3, alpha, hp); break; - case 4: TRACK_LABEL("asa3"); fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, 4, alpha, hp); break; - default: TRACK_LABEL("asa4"); fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, n, alpha, hp); break; + switch (n) + { + case 1: return fz_paint_affine_near_sa_alpha_1; + case 3: return fz_paint_affine_near_sa_alpha_3; + case 4: return fz_paint_affine_near_sa_alpha_4; + default: return fz_paint_affine_near_sa_alpha_N; + } } } } @@ -992,57 +2193,294 @@ fz_paint_affine_near(byte *dp, int da, const byte * restrict sp, int sw, int sh, { if (alpha == 255) { - switch (n) + if (fa == 0) + { + switch (n) + { + case 1: return fz_paint_affine_near_1_fa0; + case 3: return fz_paint_affine_near_3_fa0; + case 4: return fz_paint_affine_near_4_fa0; + default: return fz_paint_affine_near_N_fa0; + } + } + else if (fb == 0) + { + switch (n) + { + case 1: return fz_paint_affine_near_1_fb0; + case 3: return fz_paint_affine_near_3_fb0; + case 4: return fz_paint_affine_near_4_fb0; + default: return fz_paint_affine_near_N_fb0; + } + } + else { - case 1: TRACK_LABEL("a11"); fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, hp); break; - case 3: TRACK_LABEL("a13"); fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, hp); break; - case 4: TRACK_LABEL("a14"); fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, hp); break; - default: TRACK_LABEL("a1n"); fz_paint_affine_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, hp); break; + switch (n) + { + case 1: return fz_paint_affine_near_1; + case 3: return fz_paint_affine_near_3; + case 4: return fz_paint_affine_near_4; + default: return fz_paint_affine_near_N; + } } } else if (alpha > 0) { - switch (n) + if (fa == 0) + { + switch (n) + { + case 1: return fz_paint_affine_near_alpha_1_fa0; + case 3: return fz_paint_affine_near_alpha_3_fa0; + case 4: return fz_paint_affine_near_alpha_4_fa0; + default: return fz_paint_affine_near_alpha_N_fa0; + } + } + else if (fb == 0) + { + switch (n) + { + case 1: return fz_paint_affine_near_alpha_1_fb0; + case 3: return fz_paint_affine_near_alpha_3_fb0; + case 4: return fz_paint_affine_near_alpha_4_fb0; + default: return fz_paint_affine_near_alpha_N_fb0; + } + } + else { - case 1: TRACK_LABEL("asa1"); fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 1, alpha, hp); break; - case 3: TRACK_LABEL("asa3"); fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 3, alpha, hp); break; - case 4: TRACK_LABEL("asa4"); fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, 4, alpha, hp); break; - default: TRACK_LABEL("asan"); fz_paint_affine_alpha_N_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, n, alpha, hp); break; + switch (n) + { + case 1: return fz_paint_affine_near_alpha_1; + case 3: return fz_paint_affine_near_alpha_3; + case 4: return fz_paint_affine_near_alpha_4; + default: return fz_paint_affine_near_alpha_N; + } } } } } + return NULL; +} + +static void +fz_paint_affine_near_da_sa_g2rgb_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_g2rgb_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near_fa0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_da_g2rgb_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_da_alpha_g2rgb_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near_fa0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_sa_g2rgb_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_sa_alpha_g2rgb_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near_fa0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_g2rgb_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_alpha_g2rgb_fa0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near_fa0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_g2rgb_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_g2rgb_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near_fb0(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_da_g2rgb_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_da_alpha_g2rgb_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near_fb0(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_sa_g2rgb_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_sa_alpha_g2rgb_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near_fb0(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_g2rgb_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_alpha_g2rgb_fb0(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near_fb0(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_da_sa_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_da_sa_alpha_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_da_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_da_alpha_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_sa_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); +} + +static void +fz_paint_affine_near_sa_alpha_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); +} + +static void +fz_paint_affine_near_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_solid_g2rgb_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); } static void -fz_paint_affine_g2rgb_near(byte *dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color/*unused*/, byte * restrict hp) +fz_paint_affine_near_alpha_g2rgb(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n1, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_alpha_g2rgb_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); +} + +static paintfn_t * +fz_paint_affine_g2rgb_near(int da, int sa, int fa, int fb, int n, int alpha) { if (da) { if (sa) { - if (alpha == 255) + if (fa == 0) { - TRACK_LABEL("agds1"); - fz_paint_affine_solid_g2rgb_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); + if (alpha == 255) + return fz_paint_affine_near_da_sa_g2rgb_fa0; + else if (alpha > 0) + return fz_paint_affine_near_da_sa_alpha_g2rgb_fa0; } - else if (alpha > 0) + else if (fb == 0) + { + if (alpha == 255) + return fz_paint_affine_near_da_sa_g2rgb_fb0; + else if (alpha > 0) + return fz_paint_affine_near_da_sa_alpha_g2rgb_fb0; + } + else { - TRACK_LABEL("agdsa"); - fz_paint_affine_alpha_g2rgb_near(dp, 1, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); + if (alpha == 255) + return fz_paint_affine_near_da_sa_g2rgb; + else if (alpha > 0) + return fz_paint_affine_near_da_sa_alpha_g2rgb; } } else { - if (alpha == 255) + if (fa == 0) { - TRACK_LABEL("agd1"); - fz_paint_affine_solid_g2rgb_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); + if (alpha == 255) + return fz_paint_affine_near_da_g2rgb_fa0; + else if (alpha > 0) + return fz_paint_affine_near_da_alpha_g2rgb_fa0; } - else if (alpha > 0) + else if (fb == 0) + { + if (alpha == 255) + return fz_paint_affine_near_da_g2rgb_fb0; + else if (alpha > 0) + return fz_paint_affine_near_da_alpha_g2rgb_fb0; + } + else { - TRACK_LABEL("agda"); - fz_paint_affine_alpha_g2rgb_near(dp, 1, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); + if (alpha == 255) + return fz_paint_affine_near_da_g2rgb; + else if (alpha > 0) + return fz_paint_affine_near_da_alpha_g2rgb; } } } @@ -1050,81 +2488,218 @@ fz_paint_affine_g2rgb_near(byte *dp, int da, const byte * restrict sp, int sw, i { if (sa) { - if (alpha == 255) + if (fa == 0) { - TRACK_LABEL("ags1"); - fz_paint_affine_solid_g2rgb_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, hp); + if (alpha == 255) + return fz_paint_affine_near_sa_g2rgb_fa0; + else if (alpha > 0) + return fz_paint_affine_near_sa_alpha_g2rgb_fa0; } - else if (alpha > 0) + else if (fb == 0) { - TRACK_LABEL("agsa"); - fz_paint_affine_alpha_g2rgb_near(dp, 0, sp, sw, sh, ss, 1, u, v, fa, fb, w, alpha, hp); + if (alpha == 255) + return fz_paint_affine_near_sa_g2rgb_fb0; + else if (alpha > 0) + return fz_paint_affine_near_sa_alpha_g2rgb_fb0; + } + else + { + if (alpha == 255) + return fz_paint_affine_near_sa_g2rgb; + else if (alpha > 0) + return fz_paint_affine_near_sa_alpha_g2rgb; } } else { - if (alpha == 255) + if (fa == 0) { - TRACK_LABEL("ag1"); - fz_paint_affine_solid_g2rgb_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, hp); + if (alpha == 255) + return fz_paint_affine_near_g2rgb_fa0; + else if (alpha > 0) + return fz_paint_affine_near_alpha_g2rgb_fa0; } - else if (alpha > 0) + else if (fb == 0) + { + if (alpha == 255) + return fz_paint_affine_near_g2rgb_fb0; + else if (alpha > 0) + return fz_paint_affine_near_alpha_g2rgb_fb0; + } + else { - TRACK_LABEL("aga"); - fz_paint_affine_alpha_g2rgb_near(dp, 0, sp, sw, sh, ss, 0, u, v, fa, fb, w, alpha, hp); + if (alpha == 255) + return fz_paint_affine_near_g2rgb; + else if (alpha > 0) + return fz_paint_affine_near_alpha_g2rgb; } } } + return NULL; } static void -fz_paint_affine_color_lerp(byte *dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha/*unused*/, const byte * restrict color, byte * restrict hp) +fz_paint_affine_color_lerp_da_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_lerp(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 1, color, hp); +} + +static void +fz_paint_affine_color_lerp_da_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_lerp(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 3, color, hp); +} + +static void +fz_paint_affine_color_lerp_da_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_lerp(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 4, color, hp); +} + +static void +fz_paint_affine_color_lerp_da_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_lerp(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, n, color, hp); +} + +static void +fz_paint_affine_color_lerp_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_lerp(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 1, color, hp); +} + +static void +fz_paint_affine_color_lerp_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_lerp(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 3, color, hp); +} + +static void +fz_paint_affine_color_lerp_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_lerp(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 4, color, hp); +} + +static void +fz_paint_affine_color_lerp_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_lerp(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, n, color, hp); +} + +static paintfn_t * +fz_paint_affine_color_lerp(int da, int sa, int fa, int fb, int n, int alpha) { if (da) { switch (n) { - case 1: TRACK_LABEL("acld1"); fz_paint_affine_color_N_lerp(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 1, color, hp); break; - case 3: TRACK_LABEL("acld3"); fz_paint_affine_color_N_lerp(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 3, color, hp); break; - case 4: TRACK_LABEL("acld4"); fz_paint_affine_color_N_lerp(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 4, color, hp); break; - default: TRACK_LABEL("acldn"); fz_paint_affine_color_N_lerp(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, n, color, hp); break; + case 1: return fz_paint_affine_color_lerp_da_1; + case 3: return fz_paint_affine_color_lerp_da_3; + case 4: return fz_paint_affine_color_lerp_da_4; + default: return fz_paint_affine_color_lerp_da_N; } } else { switch (n) { - case 1: TRACK_LABEL("acl1"); fz_paint_affine_color_N_lerp(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 1, color, hp); break; - case 3: TRACK_LABEL("acl3"); fz_paint_affine_color_N_lerp(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 3, color, hp); break; - case 4: TRACK_LABEL("acl4"); fz_paint_affine_color_N_lerp(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 4, color, hp); break; - default: TRACK_LABEL("acln"); fz_paint_affine_color_N_lerp(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, n, color, hp); break; + case 1: return fz_paint_affine_color_lerp_1; + case 3: return fz_paint_affine_color_lerp_3; + case 4: return fz_paint_affine_color_lerp_4; + default: return fz_paint_affine_color_lerp_N; } } + return NULL; +} + +static void +fz_paint_affine_color_near_da_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_near(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 1, color, hp); +} + +static void +fz_paint_affine_color_near_da_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_near(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 3, color, hp); +} + +static void +fz_paint_affine_color_near_da_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_near(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 4, color, hp); +} + +static void +fz_paint_affine_color_near_da_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_near(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, n, color, hp); +} + +static void +fz_paint_affine_color_near_1(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_near(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 1, color, hp); +} + +static void +fz_paint_affine_color_near_3(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_near(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 3, color, hp); +} + +static void +fz_paint_affine_color_near_4(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_near(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 4, color, hp); } static void -fz_paint_affine_color_near(byte *dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha/*unused*/, const byte * restrict color, byte * restrict hp) +fz_paint_affine_color_near_N(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp) +{ + TRACK_FN(); + fz_paint_affine_color_N_near(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, n, color, hp); +} + +static paintfn_t * +fz_paint_affine_color_near(int da, int sa, int fa, int fb, int n, int alpha) { if (da) { switch (n) { - case 1: TRACK_LABEL("acd1"); fz_paint_affine_color_N_near(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 1, color, hp); break; - case 3: TRACK_LABEL("acd3"); fz_paint_affine_color_N_near(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 3, color, hp); break; - case 4: TRACK_LABEL("acd4"); fz_paint_affine_color_N_near(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, 4, color, hp); break; - default: TRACK_LABEL("acdn"); fz_paint_affine_color_N_near(dp, 1, sp, sw, sh, ss, u, v, fa, fb, w, n, color, hp); break; + case 1: return fz_paint_affine_color_near_da_1; + case 3: return fz_paint_affine_color_near_da_3; + case 4: return fz_paint_affine_color_near_da_4; + default: return fz_paint_affine_color_near_da_N; } } else { switch (n) { - case 1: TRACK_LABEL("acd1"); fz_paint_affine_color_N_near(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 1, color, hp); break; - case 3: TRACK_LABEL("acd3"); fz_paint_affine_color_N_near(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 3, color, hp); break; - case 4: TRACK_LABEL("acd4"); fz_paint_affine_color_N_near(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, 4, color, hp); break; - default: TRACK_LABEL("acdn"); fz_paint_affine_color_N_near(dp, 0, sp, sw, sh, ss, u, v, fa, fb, w, n, color, hp); break; + case 1: return fz_paint_affine_color_near_1; + case 3: return fz_paint_affine_color_near_3; + case 4: return fz_paint_affine_color_near_4; + default: return fz_paint_affine_color_near_N; } } + return NULL; } /* RJW: The following code was originally written to be sensitive to @@ -1327,7 +2902,7 @@ fz_paint_image_imp(fz_pixmap * restrict dst, const fz_irect *scissor, const fz_p int sw, sh, ss, sa, n, hs, da; fz_irect bbox; int dolerp; - void (*paintfn)(byte * restrict dp, int da, const byte * restrict sp, int sw, int sh, int ss, int sa, int u, int v, int fa, int fb, int w, int n, int alpha, const byte * restrict color, byte * restrict hp); + paintfn_t *paintfn; fz_matrix local_ctm = *ctm; fz_rect rect; int is_rectilinear; @@ -1422,9 +2997,9 @@ fz_paint_image_imp(fz_pixmap * restrict dst, const fz_irect *scissor, const fz_p if (n == 3 && img->n == 1 + sa && !color) { if (dolerp) - paintfn = fz_paint_affine_g2rgb_lerp; + paintfn = fz_paint_affine_g2rgb_lerp(da, sa, fa, fb, n, alpha); else - paintfn = fz_paint_affine_g2rgb_near; + paintfn = fz_paint_affine_g2rgb_near(da, sa, fa, fb, n, alpha); } else { @@ -1432,19 +3007,23 @@ fz_paint_image_imp(fz_pixmap * restrict dst, const fz_irect *scissor, const fz_p if (dolerp) { if (color) - paintfn = fz_paint_affine_color_lerp; + paintfn = fz_paint_affine_color_lerp(da, sa, fa, fb, n, alpha); else - paintfn = fz_paint_affine_lerp; + paintfn = fz_paint_affine_lerp(da, sa, fa, fb, n, alpha); } else { if (color) - paintfn = fz_paint_affine_color_near; + paintfn = fz_paint_affine_color_near(da, sa, fa, fb, n, alpha); else - paintfn = fz_paint_affine_near; + paintfn = fz_paint_affine_near(da, sa, fa, fb, n, alpha); } } + assert(paintfn); + if (paintfn == NULL) + return; + if (dolerp) { u -= 32768; -- cgit v1.2.3