From 02299d992b5ea844a24eb4634f5dc5990cb7d7e1 Mon Sep 17 00:00:00 2001
From: Robin Watts <robin.watts@artifex.com>
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(-)
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