/src/mupdf/source/fitz/draw-paint.c

Source
// Copyright (C) 2004-2025 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.

#include "mupdf/fitz.h"

#include "draw-imp.h"
#include "glyph-imp.h"
#include "pixmap-imp.h"

#include <string.h>
#include <assert.h>

/*

The functions in this file implement various flavours of Porter-Duff blending.

We take the following as definitions:

  Cx = Color (from plane x)
  ax = Alpha (from plane x)
  cx = Cx.ax = Premultiplied color (from plane x)

The general PorterDuff blending equation is:

  Blend Z = X op Y  cz = Fx.cx + Fy.cy  where Fx and Fy depend on op

The two operations we use in this file are: '(X in Y) over Z' and
'S over Z'. The definitions of the 'over' and 'in' operations are as
follows:

  For S over Z, Fs = 1, Fz = 1-as
  For X in Y, Fx = ay, Fy = 0

We have 2 choices; we can either work with premultiplied data, or non
premultiplied data. Our

First the premultiplied case:

  Let S = (X in Y)
  Let R = (X in Y) over Z = S over Z

  cs  = cx.Fx + cy.Fy (where Fx = ay, Fy = 0)
    = cx.ay
  as  = ax.Fx + ay.Fy
    = ax.ay

  cr  = cs.Fs + cz.Fz (where Fs = 1, Fz = 1-as)
    = cs + cz.(1-as)
    = cx.ay + cz.(1-ax.ay)
  ar  = as.Fs + az.Fz
    = as + az.(1-as)
    = ax.ay + az.(1-ax.ay)

This has various nice properties, like not needing any divisions, and
being symmetric in color and alpha, so this is what we use. Because we
went through the pain of deriving the non premultiplied forms, we list
them here too, though they are not used.

Non Pre-multiplied case:

  Cs.as = Fx.Cx.ax + Fy.Cy.ay (where Fx = ay, Fy = 0)
    = Cx.ay.ax
  Cs  = (Cx.ay.ax)/(ay.ax)
    = Cx
  Cr.ar = Fs.Cs.as + Fz.Cz.az (where Fs = 1, Fz = 1-as)
    = Cs.as + (1-as).Cz.az
    = Cx.ax.ay + Cz.az.(1-ax.ay)
  Cr  = (Cx.ax.ay + Cz.az.(1-ax.ay))/(ax.ay + az.(1-ax.ay))

Much more complex, it seems. However, if we could restrict ourselves to
the case where we were always plotting onto an opaque background (i.e.
az = 1), then:

  Cr  = Cx.(ax.ay) + Cz.(1-ax.ay)
    = (Cx-Cz)*(1-ax.ay) + Cz  (a single MLA operation)
  ar  = 1

Sadly, this is not true in the general case, so we abandon this effort
and stick to using the premultiplied form.

*/

typedef unsigned char byte;

/* These are used by the non-aa scan converter */

static fz_forceinline void
template_solid_color_1_da(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  int sa = FZ_EXPAND(color[1]);
  FZ_TRACK_FUNCTION();
  if (sa == 0)
    return;
  if (sa == 256)
  {
    do
    {
      dp[0] = color[0];
      dp[1] = 255;
      dp += 2;
    }
    while (--w);
  }
  else
  {
    do
    {
      dp[0] = FZ_BLEND(color[0], dp[0], sa);
      dp[1] = FZ_BLEND(255, dp[1], sa);
      dp += 2;
    }
    while (--w);
  }
}

static inline int isbigendian(void)
{
  union { int i; char c[sizeof(int)]; } u = {1};
  return u.c[0] != 1;
}

static fz_forceinline void
template_solid_color_3_da(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  unsigned int rgba = *(int *)color;
  int sa = FZ_EXPAND(color[3]);
  FZ_TRACK_FUNCTION();
  if (sa == 0)
    return;
  if (isbigendian())
    rgba |= 0x000000FF;
  else
    rgba |= 0xFF000000;
  if (sa == 256)
  {
    do
    {
      *(unsigned int *)dp = rgba;
      dp += 4;
    }
    while (--w);
  }
  else
  {
    unsigned int mask = 0xFF00FF00;
    unsigned int rb = rgba & (mask>>8);
    unsigned int ga = (rgba & mask)>>8;
    do
    {
      unsigned int RGBA = *(unsigned int *)dp;
      unsigned int RB = (RGBA<<8) & mask;
      unsigned int GA = RGBA & mask;
      RB += (rb-(RB>>8))*sa;
      GA += (ga-(GA>>8))*sa;
      RB &= mask;
      GA &= mask;
      *(unsigned int *)dp = (RB>>8) | GA;
      dp += 4;
    }
    while (--w);
  }
}

static fz_forceinline void
template_solid_color_4_da(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  int sa = FZ_EXPAND(color[4]);
  FZ_TRACK_FUNCTION();
  if (sa == 0)
    return;
  if (sa == 256)
  {
#ifdef ARCH_UNALIGNED_OK
    if (w > 4)
    {
      if (isbigendian())
      {
        const uint32_t a = *(uint32_t*)color;
        const uint32_t b = 0xFF000000|(a>>8);
        const uint32_t c = 0x00FF0000|(a>>16)|(a<<24);
        const uint32_t d = 0x0000FF00|(a>>24)|(a<<16);
        const uint32_t e = 0x000000FF|(a<<8);
        w -= 3;
        do
        {
          ((uint32_t *)(void *)dp)[0] = a;
          ((uint32_t *)(void *)dp)[1] = b;
          ((uint32_t *)(void *)dp)[2] = c;
          ((uint32_t *)(void *)dp)[3] = d;
          ((uint32_t *)(void *)dp)[4] = e;
          dp += 20;
          w -= 4;
        }
        while (w > 0);
      }
      else
      {
        const uint32_t a = *(uint32_t*)color;
        const uint32_t b = 0x000000FF|(a<<8);
        const uint32_t c = 0x0000FF00|(a<<16)|(a>>24);
        const uint32_t d = 0x00FF0000|(a<<24)|(a>>16);
        const uint32_t e = 0xFF000000|(a>>8);
        w -= 3;
        do
        {
          ((uint32_t *)(void *)dp)[0] = a;
          ((uint32_t *)(void *)dp)[1] = b;
          ((uint32_t *)(void *)dp)[2] = c;
          ((uint32_t *)(void *)dp)[3] = d;
          ((uint32_t *)(void *)dp)[4] = e;
          dp += 20;
          w -= 4;
        }
        while (w > 0);
      }
      w += 3;
      if (w == 0)
        return;
    }
#endif
    do
    {
      dp[0] = color[0];
      dp[1] = color[1];
      dp[2] = color[2];
      dp[3] = color[3];
      dp[4] = 255;
      dp += 5;
    }
    while (--w);
  }
  else
  {
    do
    {
      dp[0] = FZ_BLEND(color[0], dp[0], sa);
      dp[1] = FZ_BLEND(color[1], dp[1], sa);
      dp[2] = FZ_BLEND(color[2], dp[2], sa);
      dp[3] = FZ_BLEND(color[3], dp[3], sa);
      dp[4] = FZ_BLEND(255, dp[5], sa);
      dp += 5;
    }
    while (--w);
  }
}

static fz_forceinline void
template_solid_color_N_256(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  int k;
  int n1 = n - da;
  if (n == 3 && da == 0 && w >= 7)
  {
    union {uint32_t w[3]; byte b[12];} u;

    u.b[0] = u.b[3] = u.b[6] = u.b[9] = color[0];
    u.b[1] = u.b[4] = u.b[7] = u.b[10] = color[1];
    u.b[2] = u.b[5] = u.b[8] = u.b[11] = color[2];

    switch (((intptr_t)dp) & 3)
    {
    case 3:
      *dp++ = color[0];
      *(uint32_t *)dp = u.w[1];
      dp += 4;
      *(uint32_t *)dp = u.w[2];
      dp += 4;
      w -= 3;
      break;
    case 2:
      *dp++ = color[0];
      *dp++ = color[1];
      *(uint32_t *)dp = u.w[2];
      dp += 4;
      w -= 2;
      break;
    case 1:
      *dp++ = color[0];
      *dp++ = color[1];
      *dp++ = color[2];
      w -= 1;
      break;
    }
    w -= 4;
    do
    {
      *(uint32_t *)dp = u.w[0];
      dp += 4;
      *(uint32_t *)dp = u.w[1];
      dp += 4;
      *(uint32_t *)dp = u.w[2];
      dp += 4;
      w -= 4;
    }
    while (w > 0);
    w += 4;
    if (w == 0)
      return;
  }
  do
  {
    dp[0] = color[0];
    if (n1 > 1)
      dp[1] = color[1];
    if (n1 > 2)
      dp[2] = color[2];
    for (k = 3; k < n1; k++)
      dp[k] = color[k];
    if (da)
      dp[n1] = 255;
    dp += n;
  }
  while (--w);
}

static fz_forceinline void
template_solid_color_N_256_op(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  int k;
  int n1 = n - da;
  do
  {
    if (fz_overprint_component(eop, 0))
      dp[0] = color[0];
    if (n1 > 1)
      if (fz_overprint_component(eop, 1))
        dp[1] = color[1];
    if (n1 > 2)
      if (fz_overprint_component(eop, 2))
        dp[2] = color[2];
    for (k = 3; k < n1; k++)
      if (fz_overprint_component(eop, k))
        dp[k] = color[k];
    if (da)
      dp[n1] = 255;
    dp += n;
  }
  while (--w);
}

static fz_forceinline void
template_solid_color_N_sa(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, int sa)
{
  int k;
  int n1 = n - da;
  do
  {
    for (k = 0; k < n1; k++)
      dp[k] = FZ_BLEND(color[k], dp[k], sa);
    if (da)
      dp[k] = FZ_BLEND(255, dp[k], sa);
    dp += n;
  }
  while (--w);
}

static fz_forceinline void
template_solid_color_N_sa_op(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, int sa, const fz_overprint * FZ_RESTRICT eop)
{
  int k;
  int n1 = n - da;
  do
  {
    for (k = 0; k < n1; k++)
      if (fz_overprint_component(eop, k))
        dp[k] = FZ_BLEND(color[k], dp[k], sa);
    if (da)
      dp[k] = FZ_BLEND(255, dp[k], sa);
    dp += n;
  }
  while (--w);
}

#if FZ_PLOTTERS_N
static fz_forceinline void
template_solid_color_N_general(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, int sa)
{
  int k;
  int n1 = n - da;
  if (sa == 256)
  {
    do
    {
      dp[0] = color[0];
      if (n1 > 1)
        dp[1] = color[1];
      if (n1 > 2)
        dp[2] = color[2];
      for (k = 3; k < n1; k++)
        dp[k] = color[k];
      if (da)
        dp[n1] = 255;
      dp += n;
    }
    while (--w);
  }
  else
  {
    do
    {
      for (k = 0; k < n1; k++)
        dp[k] = FZ_BLEND(color[k], dp[k], sa);
      if (da)
        dp[k] = FZ_BLEND(255, dp[k], sa);
      dp += n;
    }
    while (--w);
  }
}

static fz_forceinline void
template_solid_color_N_general_op(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, int sa, const fz_overprint * FZ_RESTRICT eop)
{
  int k;
  int n1 = n - da;
  if (sa == 256)
  {
    do
    {
      if (fz_overprint_component(eop, 0))
        dp[0] = color[0];
      if (n1 > 1)
        if (fz_overprint_component(eop, 1))
          dp[1] = color[1];
      if (n1 > 2)
        if (fz_overprint_component(eop, 2))
          dp[2] = color[2];
      for (k = 3; k < n1; k++)
        if (fz_overprint_component(eop, k))
          dp[k] = color[k];
      if (da)
        dp[n1] = 255;
      dp += n;
    }
    while (--w);
  }
  else
  {
    do
    {
      for (k = 0; k < n1; k++)
        if (fz_overprint_component(eop, k))
          dp[k] = FZ_BLEND(color[k], dp[k], sa);
      if (da)
        dp[k] = FZ_BLEND(255, dp[k], sa);
      dp += n;
    }
    while (--w);
  }
}
#endif

static fz_forceinline void
template_solid_color_0_da(byte * FZ_RESTRICT dp, int w, int sa)
{
  if (sa == 256)
  {
    memset(dp, 255, w);
  }
  else
  {
    do
    {
      *dp = FZ_BLEND(255, *dp, sa);
      dp++;
    }
    while (--w);
  }
}

#if FZ_PLOTTERS_G
static void paint_solid_color_1_alpha(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_sa(dp, 1, w, color, 0, FZ_EXPAND(color[1]));
}

static void paint_solid_color_1(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_256(dp, 1, w, color, 0);
}

static void paint_solid_color_1_da(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_1_da(dp, 2, w, color, 1);
}
#endif /* FZ_PLOTTERS_G */

static void paint_solid_color_0_da(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_0_da(dp, w, 256);
}

#if FZ_PLOTTERS_RGB
static void paint_solid_color_3_alpha(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_sa(dp, 3, w, color, 0, FZ_EXPAND(color[3]));
}

static void paint_solid_color_3(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_256(dp, 3, w, color, 0);
}

static void paint_solid_color_3_da(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_3_da(dp, 4, w, color, 1);
}
#endif /* FZ_PLOTTERS_RGB */

#if FZ_PLOTTERS_CMYK
static void paint_solid_color_4_alpha(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_sa(dp, 4, w, color, 0, FZ_EXPAND(color[4]));
}

static void paint_solid_color_4(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_256(dp, 4, w, color, 0);
}

static void paint_solid_color_4_da(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_4_da(dp, 5, w, color, 1);
}
#endif /* FZ_PLOTTERS_CMYK */

#if FZ_PLOTTERS_N
static void paint_solid_color_N_alpha(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_sa(dp, n, w, color, 0, FZ_EXPAND(color[n]));
}

static void paint_solid_color_N(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_256(dp, n, w, color, 0);
}

static void paint_solid_color_N_da(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_general(dp, n, w, color, 1, FZ_EXPAND(color[n-1]));
}
#endif /* FZ_PLOTTERS_N */

#if FZ_ENABLE_SPOT_RENDERING
static void paint_solid_color_N_alpha_op(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_sa_op(dp, n, w, color, 0, FZ_EXPAND(color[n]), eop);
}

static void paint_solid_color_N_op(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_256_op(dp, n, w, color, 0, eop);
}

static void paint_solid_color_N_da_op(byte * FZ_RESTRICT dp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_solid_color_N_general_op(dp, n, w, color, 1, FZ_EXPAND(color[n-1]), eop);
}
#endif /* FZ_ENABLE_SPOT_RENDERING */

fz_solid_color_painter_t *
fz_get_solid_color_painter(int n, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
#if FZ_ENABLE_SPOT_RENDERING
  if (fz_overprint_required(eop))
  {
    if (da)
      return paint_solid_color_N_da_op;
    else if (color[n] == 255)
      return paint_solid_color_N_op;
    else
      return paint_solid_color_N_alpha_op;
  }
#endif /* FZ_ENABLE_SPOT_RENDERING */
  switch (n-da)
  {
    case 0:
      return paint_solid_color_0_da;
#if FZ_PLOTTERS_G
    case 1:
      if (da)
        return paint_solid_color_1_da;
      else if (color[1] == 255)
        return paint_solid_color_1;
      else
        return paint_solid_color_1_alpha;
#endif /* FZ_PLOTTERS_G */
#if FZ_PLOTTERS_RGB
    case 3:
      if (da)
        return paint_solid_color_3_da;
      else if (color[3] == 255)
        return paint_solid_color_3;
      else
        return paint_solid_color_3_alpha;
#endif /* FZ_PLOTTERS_RGB */
#if FZ_PLOTTERS_CMYK
    case 4:
      if (da)
        return paint_solid_color_4_da;
      else if (color[4] == 255)
        return paint_solid_color_4;
      else
        return paint_solid_color_4_alpha;
#endif /* FZ_PLOTTERS_CMYK */
    default:
#if FZ_PLOTTERS_N
      if (da)
        return paint_solid_color_N_da;
      else if (color[n] == 255)
        return paint_solid_color_N;
      else
        return paint_solid_color_N_alpha;
#else
      return NULL;
#endif /* FZ_PLOTTERS_N */
  }
}

/* Blend a non-premultiplied color in mask over destination */

static fz_forceinline void
template_span_with_color_1_da_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  int g = color[0];
  do
  {
    int ma = *mp++;
    if (ma)
    {
      if (ma == 255)
      {
        dp[0] = g;
        dp[1] = 255;
      }
      else
      {
        ma = FZ_EXPAND(ma);
        dp[0] = FZ_BLEND(g, dp[0], ma);
        dp[1] = FZ_BLEND(255, dp[1], ma);
      }
    }
    dp += 2;
  }
  while (--w);
}

static fz_forceinline void
template_span_with_color_1_da_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  int sa = FZ_EXPAND(color[1]);
  int g = color[0];
  if (sa == 0)
    return;
  if (sa == 256)
  {
    do
    {
      int ma = *mp++;
      if (ma != 0)
      {
        if (ma == 255)
        {
          dp[0] = g;
          dp[1] = 255;
        }
        else
        {
          ma = FZ_EXPAND(ma);
          dp[0] = FZ_BLEND(g, dp[0], ma);
          dp[1] = FZ_BLEND(255, dp[1], ma);
        }
      }
      dp += 2;
    }
    while (--w);
  } else {
    do
    {
      int ma = *mp++;
      if (ma != 0)
      {
        ma = FZ_EXPAND(ma);
        ma = FZ_COMBINE(ma, sa);
        dp[0] = FZ_BLEND(g, dp[0], ma);
        dp[1] = FZ_BLEND(255, dp[1], ma);
      }
      dp += 2;
    }
    while (--w);
  }
}

static fz_forceinline void
template_span_with_color_3_da_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  unsigned int rgba = *((const unsigned int *)color);
  unsigned int mask, rb, ga;
  if (isbigendian())
    rgba |= 0x000000FF;
  else
    rgba |= 0xFF000000;
  mask = 0xFF00FF00;
  rb = rgba & (mask>>8);
  ga = (rgba & mask)>>8;
  do
  {
    unsigned int ma = *mp++;
    dp += 4;
    if (!ma)
      continue;
    if (ma == 255)
    {
      ((unsigned int *)dp)[-1] = rgba;
    }
    else
    {
      unsigned int RGBA = ((unsigned int *)dp)[-1];
      unsigned int RB = (RGBA<<8) & mask;
      unsigned int GA = RGBA & mask;
      ma = FZ_EXPAND(ma);
      RB += (rb-(RB>>8))*ma;
      GA += (ga-(GA>>8))*ma;
      RB &= mask;
      GA &= mask;
      ((unsigned int *)dp)[-1] = (RB>>8) | GA;
    }
  }
  while (--w);
}

static fz_forceinline void
template_span_with_color_3_da_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  unsigned int rgba = *((const unsigned int *)color);
  unsigned int mask, rb, ga;
  int sa = FZ_EXPAND(color[3]);
  if (isbigendian())
    rgba |= 0x000000FF;
  else
    rgba |= 0xFF000000;
  mask = 0xFF00FF00;
  rb = rgba & (mask>>8);
  ga = (rgba & mask)>>8;
  if (sa == 0)
    return;
  if (sa == 256)
  {
    do
    {
      unsigned int ma = *mp++;
      dp += 4;
      if (ma != 0)
      {
        if (ma == 255)
        {
          ((unsigned int *)dp)[-1] = rgba;
        }
        else
        {
          unsigned int RGBA = ((unsigned int*)dp)[-1];
          unsigned int RB = (RGBA<<8) & mask;
          unsigned int GA = RGBA & mask;
          ma = FZ_EXPAND(ma);
          RB += (rb-(RB>>8))*ma;
          GA += (ga-(GA>>8))*ma;
          RB &= mask;
          GA &= mask;
          ((unsigned int *)dp)[-1] = (RB>>8) | GA;
        }
      }
    }
    while (--w);
  }
  else
  {
    do
    {
      unsigned int ma = *mp++;
      ma = FZ_COMBINE(FZ_EXPAND(ma), sa);
      dp += 4;
      if (ma != 0)
      {
        unsigned int RGBA = ((unsigned int*)dp)[-1];
        unsigned int RB = (RGBA<<8) & mask;
        unsigned int GA = RGBA & mask;
        RB += (rb-(RB>>8))*ma;
        GA += (ga-(GA>>8))*ma;
        RB &= mask;
        GA &= mask;
        ((unsigned int *)dp)[-1] = (RB>>8) | GA;
      }
    }
    while (--w);
  }
}

static fz_forceinline void
template_span_with_color_4_da_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  int c = color[0];
  int m = color[1];
  int y = color[2];
  int k = color[3];
  FZ_TRACK_FUNCTION();
  do
  {
    int ma = *mp++;
    if (ma)
    {
      if (ma == 255)
      {
        dp[0] = c;
        dp[1] = m;
        dp[2] = y;
        dp[3] = k;
        dp[4] = 255;
      }
      else
      {
        ma = FZ_EXPAND(ma);
        dp[0] = FZ_BLEND(c, dp[0], ma);
        dp[1] = FZ_BLEND(m, dp[1], ma);
        dp[2] = FZ_BLEND(y, dp[2], ma);
        dp[3] = FZ_BLEND(k, dp[3], ma);
        dp[4] = FZ_BLEND(255, dp[4], ma);
      }
    }
    dp += 5;
  }
  while (--w);
}

static fz_forceinline void
template_span_with_color_4_da_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  int sa = FZ_EXPAND(color[4]);
  int c = color[0];
  int m = color[1];
  int y = color[2];
  int k = color[3];
  FZ_TRACK_FUNCTION();
  do
  {
    int ma = *mp++;
    if (ma != 0)
    {
      ma = FZ_EXPAND(ma);
      ma = FZ_COMBINE(ma, sa);
      dp[0] = FZ_BLEND(c, dp[0], ma);
      dp[1] = FZ_BLEND(m, dp[1], ma);
      dp[2] = FZ_BLEND(y, dp[2], ma);
      dp[3] = FZ_BLEND(k, dp[3], ma);
      dp[4] = FZ_BLEND(255, dp[4], ma);
    }
    dp += 5;
  }
  while (--w);
}

static fz_forceinline void
template_span_with_color_N_general_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  int k;
  int n1 = n - da;
  do
  {
    int ma = *mp++;
    if (ma != 0)
    {
      if (ma == 255)
      {
        if (n1 > 0)
          dp[0] = color[0];
        if (n1 > 1)
          dp[1] = color[1];
        if (n1 > 2)
          dp[2] = color[2];
        for (k = 3; k < n1; k++)
          dp[k] = color[k];
        if (da)
          dp[n1] = 255;
      }
      else
      {
        ma = FZ_EXPAND(ma);
        if (n1 > 0)
          dp[0] = FZ_BLEND(color[0], dp[0], ma);
        if (n1 > 1)
          dp[1] = FZ_BLEND(color[1], dp[1], ma);
        if (n1 > 2)
          dp[2] = FZ_BLEND(color[2], dp[2], ma);
        for (k = 3; k < n1; k++)
          dp[k] = FZ_BLEND(color[k], dp[k], ma);
        if (da)
          dp[n1] = FZ_BLEND(255, dp[n1], ma);
      }
    }
    dp += n;
  }
  while (--w);
}

static fz_forceinline void
template_span_with_color_N_general_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da)
{
  int k;
  int n1 = n - da;
  int sa = FZ_EXPAND(color[n1]);
  do
  {
    int ma = *mp++;
    ma = FZ_COMBINE(FZ_EXPAND(ma), sa);
    if (n1 > 0)
      dp[0] = FZ_BLEND(color[0], dp[0], ma);
    if (n1 > 1)
      dp[1] = FZ_BLEND(color[1], dp[1], ma);
    if (n1 > 2)
      dp[2] = FZ_BLEND(color[2], dp[2], ma);
    for (k = 3; k < n1; k++)
      dp[k] = FZ_BLEND(color[k], dp[k], ma);
    if (da)
      dp[n1] = FZ_BLEND(255, dp[n1], ma);
    dp += n;
  }
  while (--w);
}

static fz_forceinline void
template_span_with_color_N_general_op_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  int k;
  int n1 = n - da;
  do
  {
    int ma = *mp++;
    if (ma)
    {
      if (ma == 255)
      {
        if (n1 > 0)
          if (fz_overprint_component(eop, 0))
            dp[0] = color[0];
        if (n1 > 1)
          if (fz_overprint_component(eop, 1))
            dp[1] = color[1];
        if (n1 > 2)
          if (fz_overprint_component(eop, 2))
            dp[2] = color[2];
        for (k = 3; k < n1; k++)
          if (fz_overprint_component(eop, k))
            dp[k] = color[k];
        if (da)
          dp[n1] = 255;
      }
      else
      {
        ma = FZ_EXPAND(ma);
          for (k = 0; k < n1; k++)
          if (fz_overprint_component(eop, k))
            dp[k] = FZ_BLEND(color[k], dp[k], ma);
        if (da)
          dp[n1] = FZ_BLEND(255, dp[k], ma);
      }
    }
    dp += n;
  }
  while (--w);
}

static fz_forceinline void
template_span_with_color_N_general_op_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  int k;
  int n1 = n - da;
  int sa = FZ_EXPAND(color[n1]);
  if (sa == 256)
  {
    do
    {
      int ma = *mp++;
      if (ma)
      {
        if (ma == 255)
        {
          for (k = 0; k < n1; k++)
            if (fz_overprint_component(eop, k))
              dp[k] = color[k];
          if (da)
            dp[k] = 255;
        }
        else
        {
          ma = FZ_EXPAND(ma);
          for (k = 0; k < n1; k++)
            if (fz_overprint_component(eop, k))
              dp[k] = FZ_BLEND(color[k], dp[k], ma);
          if (da)
            dp[k] = FZ_BLEND(255, dp[k], ma);
        }
      }
      dp += n;
    }
    while (--w);
  }
  else
  {
    do
    {
      int ma = *mp++;
      if (ma)
      {
        ma = FZ_COMBINE(FZ_EXPAND(ma), sa);
        for (k = 0; k < n1; k++)
          if (fz_overprint_component(eop, k))
            dp[k] = FZ_BLEND(color[k], dp[k], ma);
        if (da)
          dp[k] = FZ_BLEND(255, dp[k], ma);
      }
      dp += n;
    }
    while (--w);
  }
}

static void
paint_span_with_color_0_da_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_solid(dp, mp, 1, w, color, 1);
}

static void
paint_span_with_color_0_da_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_alpha(dp, mp, 1, w, color, 1);
}

static void
paint_span_with_color_1_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_solid(dp, mp, 1, w, color, 0);
}

static void
paint_span_with_color_1_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_alpha(dp, mp, 1, w, color, 0);
}

static void
paint_span_with_color_1_da_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_1_da_solid(dp, mp, 2, w, color, 1);
}

static void
paint_span_with_color_1_da_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_1_da_alpha(dp, mp, 2, w, color, 1);
}

#if FZ_PLOTTERS_RGB
static void
paint_span_with_color_3_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_solid(dp, mp, 3, w, color, 0);
}

static void
paint_span_with_color_3_da_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_3_da_solid(dp, mp, 4, w, color, 1);
}

static void
paint_span_with_color_3_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_alpha(dp, mp, 3, w, color, 0);
}

static void
paint_span_with_color_3_da_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_3_da_alpha(dp, mp, 4, w, color, 1);
}
#endif /* FZ_PLOTTERS_RGB */

#if FZ_PLOTTERS_CMYK
static void
paint_span_with_color_4_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_solid(dp, mp, 4, w, color, 0);
}

static void
paint_span_with_color_4_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_alpha(dp, mp, 4, w, color, 0);
}

static void
paint_span_with_color_4_da_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_4_da_solid(dp, mp, 5, w, color, 1);
}

static void
paint_span_with_color_4_da_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_4_da_alpha(dp, mp, 5, w, color, 1);
}
#endif /* FZ_PLOTTERS_CMYK */

#if FZ_PLOTTERS_N
static void
paint_span_with_color_N_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_solid(dp, mp, n, w, color, 0);
}

static void
paint_span_with_color_N_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_alpha(dp, mp, n, w, color, 0);
}

static void
paint_span_with_color_N_da_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_solid(dp, mp, n, w, color, 1);
}

static void
paint_span_with_color_N_da_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_alpha(dp, mp, n, w, color, 1);
}
#endif /* FZ_PLOTTERS_N */

#if FZ_ENABLE_SPOT_RENDERING
static void
paint_span_with_color_N_op_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_op_solid(dp, mp, n, w, color, 0, eop);
}

static void
paint_span_with_color_N_op_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_op_alpha(dp, mp, n, w, color, 0, eop);
}

static void
paint_span_with_color_N_da_op_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_op_solid(dp, mp, n, w, color, 1, eop);
}

static void
paint_span_with_color_N_da_op_alpha(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT mp, int n, int w, const byte * FZ_RESTRICT color, int da, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_color_N_general_op_alpha(dp, mp, n, w, color, 1, eop);
}
#endif /* FZ_ENABLE_SPOT_RENDERING */

fz_span_color_painter_t *
fz_get_span_color_painter(int n, int da, const byte * FZ_RESTRICT color, const fz_overprint * FZ_RESTRICT eop)
{
  byte alpha = color[n-da];
  if (alpha == 0)
    return NULL;
#if FZ_ENABLE_SPOT_RENDERING
  if (fz_overprint_required(eop))
  {
    if (alpha == 255)
      return da ? paint_span_with_color_N_da_op_solid : paint_span_with_color_N_op_solid;
    else
      return da ? paint_span_with_color_N_da_op_alpha : paint_span_with_color_N_op_alpha;
  }
#endif /* FZ_ENABLE_SPOT_RENDERING */
  switch(n-da)
  {
  case 0:
    if (alpha == 255)
      return da ? paint_span_with_color_0_da_solid : NULL;
    else
      return da ? paint_span_with_color_0_da_alpha : NULL;
  case 1:
    if (alpha == 255)
      return da ? paint_span_with_color_1_da_solid : paint_span_with_color_1_solid;
    else
      return da ? paint_span_with_color_1_da_alpha : paint_span_with_color_1_alpha;
#if FZ_PLOTTERS_RGB
  case 3:
    if (alpha == 255)
      return da ? paint_span_with_color_3_da_solid : paint_span_with_color_3_solid;
    else
      return da ? paint_span_with_color_3_da_alpha : paint_span_with_color_3_alpha;
#endif/* FZ_PLOTTERS_RGB */
#if FZ_PLOTTERS_CMYK
  case 4:
    if (alpha == 255)
      return da ? paint_span_with_color_4_da_solid : paint_span_with_color_4_solid;
    else
      return da ? paint_span_with_color_4_da_alpha : paint_span_with_color_4_alpha;
#endif/* FZ_PLOTTERS_CMYK */
#if FZ_PLOTTERS_N
  default:
    if (alpha == 255)
      return da ? paint_span_with_color_N_da_solid : paint_span_with_color_N_solid;
    else
      return da ? paint_span_with_color_N_da_alpha : paint_span_with_color_N_alpha;
#else
  default: return NULL;
#endif /* FZ_PLOTTERS_N */
  }
}

/* Blend source in mask over destination */

/* FIXME: There is potential for SWAR optimisation here */
static fz_forceinline void
template_span_with_mask_1_general(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, int a, const byte * FZ_RESTRICT mp, int w)
{
  do
  {
    int ma = *mp++;
    if (ma == 0 || (a && sp[1] == 0))
    {
      dp += 1 + a;
      sp += 1 + a;
    }
    else if (ma == 255)
    {
      *dp++ = *sp++;
      if (a)
        *dp++ = *sp++;
    }
    else
    {
      ma = FZ_EXPAND(ma);
      *dp = FZ_BLEND(*sp, *dp, ma);
      sp++; dp++;
      if (a)
      {
        *dp = FZ_BLEND(*sp, *dp, ma);
        sp++; dp++;
      }
    }
  }
  while (--w);
}

static fz_forceinline void
template_span_with_mask_3_general(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, int a, const byte * FZ_RESTRICT mp, int w)
{
  do
  {
    int ma = *mp++;
    if (ma == 0 || (a && sp[3] == 0))
    {
      dp += 3 + a;
      sp += 3 + a;
    }
    else if (ma == 255)
    {
      if (a)
      {
        *(int32_t *)dp = *(int32_t *)sp;
        sp += 4; dp += 4;
      }
      else
      {
        *dp++ = *sp++;
        *dp++ = *sp++;
        *dp++ = *sp++;
      }
    }
    else if (a)
    {
      const uint32_t mask = 0x00ff00ff;
      uint32_t d0 = *(uint32_t *)dp;
      uint32_t d1 = d0>>8;
      uint32_t s0 = *(uint32_t *)sp;
      uint32_t s1 = s0>>8;
      ma = FZ_EXPAND(ma);
      d0 &= mask;
      d1 &= mask;
      s0 &= mask;
      s1 &= mask;
      d0 = (((d0<<8) + (s0-d0)*ma)>>8) & mask;
      d1 = ((d1<<8) + (s1-d1)*ma) & ~mask;
      d0 |= d1;

#ifndef NDEBUG
      if (isbigendian())
      {
        assert((d0 & 0xff) >= (d0>>24));
        assert((d0 & 0xff) >= ((d0>>16) & 0xff));
        assert((d0 & 0xff) >= ((d0>>8) & 0xff));
      }
      else
      {
        assert((d0>>24) >= (d0 & 0xff));
        assert((d0>>24) >= ((d0>>8) & 0xff));
        assert((d0>>24) >= ((d0>>16) & 0xff));
      }
#endif

      *(uint32_t *)dp = d0;
      sp += 4;
      dp += 4;
    }
    else
    {
      ma = FZ_EXPAND(ma);
      *dp = FZ_BLEND(*sp, *dp, ma);
      sp++; dp++;
      *dp = FZ_BLEND(*sp, *dp, ma);
      sp++; dp++;
      *dp = FZ_BLEND(*sp, *dp, ma);
      sp++; dp++;
    }
  }
  while (--w);
}

static fz_forceinline void
template_span_with_mask_4_general(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, int a, const byte * FZ_RESTRICT mp, int w)
{
  do
  {
    int ma = *mp++;
    if (ma == 0 || (a && sp[4] == 0))
    {
      dp += 4 + a;
      sp += 4 + a;
    }
    else if (ma == 255)
    {
      if (!a)
      {
        *(uint32_t *)dp = *(uint32_t *)sp;
        dp += 4;
        sp += 4;
      }
      else
      {
        *dp++ = *sp++;
        *dp++ = *sp++;
        *dp++ = *sp++;
        *dp++ = *sp++;
        *dp++ = *sp++;
      }
    }
    else if (a)
    {
      ma = FZ_EXPAND(ma);
      *dp = FZ_BLEND(*sp, *dp, ma);
      sp++; dp++;
      *dp = FZ_BLEND(*sp, *dp, ma);
      sp++; dp++;
      *dp = FZ_BLEND(*sp, *dp, ma);
      sp++; dp++;
      *dp = FZ_BLEND(*sp, *dp, ma);
      sp++; dp++;
      *dp = FZ_BLEND(*sp, *dp, ma);
      sp++; dp++;
    }
    else
    {
      const uint32_t mask = 0x00ff00ff;
      uint32_t d0 = *(uint32_t *)dp;
      uint32_t d1 = d0>>8;
      uint32_t s0 = *(uint32_t *)sp;
      uint32_t s1 = s0>>8;
      ma = FZ_EXPAND(ma);
      sp += 4;
      d0 &= mask;
      d1 &= mask;
      s0 &= mask;
      s1 &= mask;
      d0 = (((d0<<8) + (s0-d0)*ma)>>8) & mask;
      d1 = ((d1<<8) + (s1-d1)*ma) & ~mask;
      d0 |= d1;
      *(uint32_t *)dp = d0;
      dp += 4;
    }
  }
  while (--w);
}

static fz_forceinline void
template_span_with_mask_N_general(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, int a, const byte * FZ_RESTRICT mp, int n, int w)
{
  do
  {
    int ma = *mp++;
    if (ma == 0 || (a && sp[n] == 0))
    {
      dp += n + a;
      sp += n + a;
    }
    else if (ma == 255)
    {
      int k;
      for (k = 0; k < n; k++)
        *dp++ = *sp++;
      if (a)
        *dp++ = *sp++;
    }
    else
    {
      int k;
      ma = FZ_EXPAND(ma);
      for (k = 0; k < n; k++)
      {
        *dp = FZ_BLEND(*sp, *dp, ma);
        sp++; dp++;
      }
      if (a)
      {
        *dp = FZ_BLEND(*sp, *dp, ma);
        sp++; dp++;
      }
    }
  }
  while (--w);
}

static void
paint_span_with_mask_0_a(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_mask_N_general(dp, sp, 1, mp, 0, w);
}

static void
paint_span_with_mask_1_a(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_mask_1_general(dp, sp, 1, mp, w);
}

static void
paint_span_with_mask_1(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_mask_1_general(dp, sp, 0, mp, w);
}

#if FZ_PLOTTERS_RGB
static void
paint_span_with_mask_3_a(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_mask_3_general(dp, sp, 1, mp, w);
}

static void
paint_span_with_mask_3(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_mask_3_general(dp, sp, 0, mp, w);
}
#endif /* FZ_PLOTTERS_RGB */

#if FZ_PLOTTERS_CMYK
static void
paint_span_with_mask_4_a(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_mask_4_general(dp, sp, 1, mp, w);
}

static void
paint_span_with_mask_4(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_mask_4_general(dp, sp, 0, mp, w);
}
#endif /* FZ_PLOTTERS_CMYK */

#if FZ_PLOTTERS_N
static void
paint_span_with_mask_N_a(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_mask_N_general(dp, sp, 1, mp, n, w);
}

static void
paint_span_with_mask_N(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_with_mask_N_general(dp, sp, 0, mp, n, w);
}
#endif /* FZ_PLOTTERS_N */

typedef void (fz_span_mask_painter_t)(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w, int n, int a, const fz_overprint * FZ_RESTRICT eop);

static fz_span_mask_painter_t *
fz_get_span_mask_painter(int a, int n)
{
  switch(n)
  {
    case 0:
      /* assert(a); */
      return paint_span_with_mask_0_a;
    case 1:
      if (a)
        return paint_span_with_mask_1_a;
      else
        return paint_span_with_mask_1;
#if FZ_PLOTTERS_RGB
    case 3:
      if (a)
        return paint_span_with_mask_3_a;
      else
        return paint_span_with_mask_3;
#endif /* FZ_PLOTTERS_RGB */
#if FZ_PLOTTERS_CMYK
    case 4:
      if (a)
        return paint_span_with_mask_4_a;
      else
        return paint_span_with_mask_4;
#endif /* FZ_PLOTTERS_CMYK */
    default:
    {
#if FZ_PLOTTERS_N
      if (a)
        return paint_span_with_mask_N_a;
      else
        return paint_span_with_mask_N;
#else
      return NULL;
#endif /* FZ_PLOTTERS_N */
    }
  }
}

/* Blend source in constant alpha over destination */

static fz_forceinline void
template_span_1_with_alpha_general(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int w, int alpha)
{
  if (sa)
    alpha = FZ_EXPAND(alpha);
  do
  {
    int masa = (sa ? FZ_COMBINE(sp[1], alpha) : alpha);
    int t = FZ_EXPAND(255-masa);
    *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
    dp++; sp++;
    if (da)
    {
      *dp = masa + FZ_COMBINE(*dp, t);
      dp++;
    }
    if (sa)
       sp++;
  }
  while (--w);
}

static fz_forceinline void
template_span_3_with_alpha_general(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int w, int alpha)
{
  if (sa)
    alpha = FZ_EXPAND(alpha);
  do
  {
    int masa = (sa ? FZ_COMBINE(sp[3], alpha) : alpha);
    int t = FZ_EXPAND(255-masa);
    *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
    sp++; dp++;
    *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
    sp++; dp++;
    *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
    sp++; dp++;
    if (da)
    {
      *dp = masa + FZ_COMBINE(*dp, t);
      dp++;
    }
    if (sa)
      sp++;
  }
  while (--w);
}

static fz_forceinline void
template_span_4_with_alpha_general(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int w, int alpha)
{
  if (sa)
    alpha = FZ_EXPAND(alpha);
  do
  {
    int masa = (sa ? FZ_COMBINE(sp[4], alpha) : alpha);
    int t = FZ_EXPAND(255-masa);
    *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
    sp++; dp++;
    *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
    sp++; dp++;
    *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
    sp++; dp++;
    *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
    sp++; dp++;
    if (da)
    {
      *dp = masa + FZ_COMBINE(*dp, t);
      dp++;
    }
    if (sa)
      sp++;
  }
  while (--w);
}

#if FZ_PLOTTERS_N
static fz_forceinline void
template_span_N_with_alpha_general(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n1, int w, int alpha)
{
  if (sa)
    alpha = FZ_EXPAND(alpha);
  do
  {
    int masa = (sa ? FZ_COMBINE(sp[n1], alpha) : alpha);
    int t = FZ_EXPAND(255-masa);
    int k;
    for (k = 0; k < n1; k++)
    {
      *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
      sp++; dp++;
    }
    if (da)
    {
      *dp = masa + FZ_COMBINE(*dp, t);
      dp++;
    }
    if (sa)
      sp++;
  }
  while (--w);
}

static fz_forceinline void
template_span_N_with_alpha_general_op(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n1, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  if (sa)
    alpha = FZ_EXPAND(alpha);
  do
  {
    int masa = (sa ? FZ_COMBINE(sp[n1], alpha) : alpha);
    int t = FZ_EXPAND(255-masa);
    int k;
    for (k = 0; k < n1; k++)
    {
      if (fz_overprint_component(eop, k))
        *dp = FZ_COMBINE(*sp, alpha) + FZ_COMBINE(*dp, t);
      sp++;
      dp++;
    }
    if (da)
    {
      *dp = masa + FZ_COMBINE(*dp, t);
      dp++;
    }
    if (sa)
      sp++;
  }
  while (--w);
}
#endif

/* Blend source over destination */

static fz_forceinline void
template_span_1_general(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int w)
{
  do
  {
    if (sa)
    {
      int t = sp[1];
      if (t == 0)
      {
        dp += 1 + da; sp += 1 + sa;
        continue;
      }
      if (t != 255)
      {
        t = 256 - FZ_EXPAND(t);
        *dp = *sp + FZ_COMBINE(*dp, t);
        sp++;
        dp++;
        if (da)
        {
          *dp = *sp + FZ_COMBINE(*dp, t);
          dp++;
        }
        sp++;
        continue;
      }
    }
    if (da && sa)
      *(int16_t *)dp = *(const int16_t *)sp;
    else
    {
      dp[0] = sp[0];
      if (da)
        dp[1] = 255;
    }
    dp += 1+da; sp += 1+sa;
  }
  while (--w);
}

static fz_forceinline void
template_span_3_general(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int w)
{
  do
  {
    if (sa)
    {
      int t = sp[3];
      if (t == 0)
      {
        /* At least 1 pixel has 0 alpha */
        int w0 = w;
        int w1 = w - 4;
        if (w1 > 0)
        {
          /* If the next 4 are all zero, skip 4. */
          while ((sp[7] | sp[11] | sp[15] | sp[19]) == 0)
          {
            sp += 16;
            w1 -= 4;
            if (w1 <= 0)
              break;
          }
          w = w1 + 4;
        }
        /* Still at least 1 is zero. */
        do
        {
          w--;
          if (w == 0)
            return;
          sp += 4;
        }
        while ((t = sp[3]) == 0);
        dp += (3+da)*(w0-w);
        /* Fall through, because we know t is not 0 and w != 0. */
      }
      if (t != 255)
      {
        t = 256 - FZ_EXPAND(t);
        /* sa != 0 as t != 0 */
        *dp = *sp++ + FZ_COMBINE(*dp, t);
        dp++;
        *dp = *sp++ + FZ_COMBINE(*dp, t);
        dp++;
        *dp = *sp++ + FZ_COMBINE(*dp, t);
        dp++;
        if (da)
        {
          *dp = *sp + FZ_COMBINE(*dp, t);
          dp++;
        }
        sp++;
        continue;
      }
    }
    if (da && sa)
      *(int32_t *)dp = *(const int32_t *)sp;
    else
    {
      dp[0] = sp[0];
      dp[1] = sp[1];
      dp[2] = sp[2];
      if (da)
        dp[3] = 255;
    }
    dp += 3+da; sp += 3+sa;
  }
  while (--w);
}

static fz_forceinline void
template_span_4_general(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int w)
{
  do
  {
    if (sa)
    {
      int t = sp[4];
      if (t == 0)
      {
        dp += 4+da; sp += 4+sa;
        continue;
      }
      if (t != 255)
      {
        t = 256 - FZ_EXPAND(t);
        /* sa != 0 as t != 0 */
        *dp = *sp++ + FZ_COMBINE(*dp, t);
        dp++;
        *dp = *sp++ + FZ_COMBINE(*dp, t);
        dp++;
        *dp = *sp++ + FZ_COMBINE(*dp, t);
        dp++;
        *dp = *sp++ + FZ_COMBINE(*dp, t);
        dp++;
        if (da)
        {
          *dp = *sp + FZ_COMBINE(*dp, t);
          dp++;
        }
        sp++;
        continue;
      }
    }
    if (!sa && !da)
      *(int32_t *)dp = *(const int32_t *)sp;
    else
    {
      dp[0] = sp[0];
      dp[1] = sp[1];
      dp[2] = sp[2];
      dp[3] = sp[3];
      if (da)
        dp[4] = (sa ? sp[4] : 255);
    }
    dp += 4+da; sp += 4+sa;
  }
  while (--w);
}

#if FZ_PLOTTERS_N
static fz_forceinline void
template_span_N_general(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n1, int w)
{
  do
  {
    int k;
    if (sa)
    {
      int t = sp[n1];
      if (t == 0)
      {
        dp += n1 + da; sp += n1 + sa;
        continue;
      }
      if (t != 255)
      {
        t = 256 - FZ_EXPAND(t);
        /* sa != 0, as t != 0 */
        for (k = 0; k < n1; k++)
        {
          *dp = *sp + FZ_COMBINE(*dp, t);
          sp++;
          dp++;
        }
        if (da)
        {
          *dp = *sp + FZ_COMBINE(*dp, t);
          dp++;
        }
        sp++;
        continue;
      }
    }
    for (k = 0; k < n1; k++)
      *dp++ = *sp++;
    if (da)
      *dp++ = (sa ? *sp : 255);
    if (sa)
      sp++;
  }
  while (--w);
}

static fz_forceinline void
template_span_N_general_op(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n1, int w, const fz_overprint * FZ_RESTRICT eop)
{
  do
  {
    int k;
    if (sa)
    {
      int t = sp[n1];
      if (t == 0)
      {
        dp += n1 + da; sp += n1 + sa;
        continue;
      }
      if (t != 255)
      {
        t = 256 - FZ_EXPAND(t);
        /* sa can never be 0 here, as t != 0. */
        for (k = 0; k < n1; k++)
        {
          if (fz_overprint_component(eop, k))
            *dp = *sp + FZ_COMBINE(*dp, t);
          sp++;
          dp++;
        }
        if (da)
        {
          *dp = *sp + FZ_COMBINE(*dp, t);
          dp++;
        }
        sp++;
        continue;
      }
    }
    for (k = 0; k < n1; k++)
    {
      if (fz_overprint_component(eop, k))
        *dp = *sp;
      dp++;
      sp++;
    }
    if (da)
      *dp++ = (sa ? *sp : 255);
    if (sa)
      sp++;
  }
  while (--w);
}
#endif

static void
paint_span_0_da_sa(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  do
  {
    int s = *sp++;
    int t = FZ_EXPAND(255 - s);
    *dp = s + FZ_COMBINE(*dp, t);
    dp ++;
  }
  while (--w);
}

static void
paint_span_0_da_sa_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  alpha = FZ_EXPAND(alpha);
  do
  {
    int masa = FZ_COMBINE(sp[0], alpha);
    int t = FZ_EXPAND(255-masa);
    *dp = masa + FZ_COMBINE(*dp, t);
    dp++;
    sp++;
  }
  while (--w);
}

static void
paint_span_1_sa(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_1_general(dp, 0, sp, 1, w);
}

static void
paint_span_1_sa_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_1_with_alpha_general(dp, 0, sp, 1, w, alpha);
}

static void
paint_span_1_da_sa(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_1_general(dp, 1, sp, 1, w);
}

static void
paint_span_1_da_sa_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_1_with_alpha_general(dp, 1, sp, 1, w, alpha);
}

#if FZ_PLOTTERS_G
static void
paint_span_1_da(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_1_general(dp, 1, sp, 0, w);
}

static void
paint_span_1_da_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_1_with_alpha_general(dp, 1, sp, 0, w, alpha);
}

static void
paint_span_1(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_1_general(dp, 0, sp, 0, w);
}

static void
paint_span_1_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_1_with_alpha_general(dp, 0, sp, 0, w, alpha);
}
#endif /* FZ_PLOTTERS_G */

#if FZ_PLOTTERS_RGB
static void
paint_span_3_da_sa(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_3_general(dp, 1, sp, 1, w);
}

static void
paint_span_3_da_sa_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_3_with_alpha_general(dp, 1, sp, 1, w, alpha);
}

static void
paint_span_3_da(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_3_general(dp, 1, sp, 0, w);
}

static void
paint_span_3_da_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_3_with_alpha_general(dp, 1, sp, 0, w, alpha);
}

static void
paint_span_3_sa(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_3_general(dp, 0, sp, 1, w);
}

static void
paint_span_3_sa_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_3_with_alpha_general(dp, 0, sp, 1, w, alpha);
}

static void
paint_span_3(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_3_general(dp, 0, sp, 0, w);
}

static void
paint_span_3_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_3_with_alpha_general(dp, 0, sp, 0, w, alpha);
}
#endif /* FZ_PLOTTERS_RGB */

#if FZ_PLOTTERS_CMYK
static void
paint_span_4_da_sa(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_4_general(dp, 1, sp, 1, w);
}

static void
paint_span_4_da_sa_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_4_with_alpha_general(dp, 1, sp, 1, w, alpha);
}

static void
paint_span_4_da(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_4_general(dp, 1, sp, 0, w);
}

static void
paint_span_4_da_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_4_with_alpha_general(dp, 1, sp, 0, w, alpha);
}

static void
paint_span_4_sa(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_4_general(dp, 0, sp, 1, w);
}

static void
paint_span_4_sa_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_4_with_alpha_general(dp, 0, sp, 1, w, alpha);
}

static void
paint_span_4(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_4_general(dp, 0, sp, 0, w);
}

static void
paint_span_4_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_4_with_alpha_general(dp, 0, sp, 0, w, alpha);
}
#endif /* FZ_PLOTTERS_CMYK */

#if FZ_PLOTTERS_N
static void
paint_span_N_da_sa(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_general(dp, 1, sp, 1, n, w);
}

static void
paint_span_N_da_sa_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_with_alpha_general(dp, 1, sp, 1, n, w, alpha);
}

static void
paint_span_N_da(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_general(dp, 1, sp, 0, n, w);
}

static void
paint_span_N_da_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_with_alpha_general(dp, 1, sp, 0, n, w, alpha);
}

static void
paint_span_N_sa(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_general(dp, 0, sp, 1, n, w);
}

static void
paint_span_N_sa_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_with_alpha_general(dp, 0, sp, 1, n, w, alpha);
}

static void
paint_span_N(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_general(dp, 0, sp, 0, n, w);
}

static void
paint_span_N_alpha(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_with_alpha_general(dp, 0, sp, 0, n, w, alpha);
}
#endif /* FZ_PLOTTERS_N */

#if FZ_ENABLE_SPOT_RENDERING
static void
paint_span_N_general_op(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_general_op(dp, da, sp, sa, n, w, eop);
}

static void
paint_span_N_general_alpha_op(byte * FZ_RESTRICT dp, int da, const byte * FZ_RESTRICT sp, int sa, int n, int w, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
  FZ_TRACK_FUNCTION();
  template_span_N_with_alpha_general_op(dp, da, sp, sa, n, w, alpha, eop);
}
#endif /* FZ_ENABLE_SPOT_RENDERING */

fz_span_painter_t *
fz_get_span_painter(int da, int sa, int n, int alpha, const fz_overprint * FZ_RESTRICT eop)
{
#if FZ_ENABLE_SPOT_RENDERING
  if (fz_overprint_required(eop))
  {
    if (alpha == 255)
      return paint_span_N_general_op;
    else if (alpha > 0)
      return paint_span_N_general_alpha_op;
    else
      return NULL;
  }
#endif /* FZ_ENABLE_SPOT_RENDERING */
  switch (n)
  {
  case 0:
    if (alpha == 255)
      return paint_span_0_da_sa;
    else if (alpha > 0)
      return paint_span_0_da_sa_alpha;
    break;
  case 1:
    if (sa)
      if (da)
      {
        if (alpha == 255)
          return paint_span_1_da_sa;
        else if (alpha > 0)
          return paint_span_1_da_sa_alpha;
      }
      else
      {
        if (alpha == 255)
          return paint_span_1_sa;
        else if (alpha > 0)
          return paint_span_1_sa_alpha;
      }
    else
#if FZ_PLOTTERS_G
      if (da)
      {
        if (alpha == 255)
          return paint_span_1_da;
        else if (alpha > 0)
          return paint_span_1_da_alpha;
      }
      else
      {
        if (alpha == 255)
          return paint_span_1;
        else if (alpha > 0)
          return paint_span_1_alpha;
      }
#else
      goto fallback;
#endif /* FZ_PLOTTERS_G */
    break;
#if FZ_PLOTTERS_RGB
  case 3:
    if (da)
      if (sa)
      {
        if (alpha == 255)
          return paint_span_3_da_sa;
        else if (alpha > 0)
          return paint_span_3_da_sa_alpha;
      }
      else
      {
        if (alpha == 255)
          return paint_span_3_da;
        else if (alpha > 0)
          return paint_span_3_da_alpha;
      }
    else
      if (sa)
      {
        if (alpha == 255)
          return paint_span_3_sa;
        else if (alpha > 0)
          return paint_span_3_sa_alpha;
      }
      else
      {
        if (alpha == 255)
          return paint_span_3;
        else if (alpha > 0)
          return paint_span_3_alpha;
      }
    break;
#endif /* FZ_PLOTTERS_RGB */
#if FZ_PLOTTERS_CMYK
  case 4:
    if (da)
      if (sa)
      {
        if (alpha == 255)
          return paint_span_4_da_sa;
        else if (alpha > 0)
          return paint_span_4_da_sa_alpha;
      }
      else
      {
        if (alpha == 255)
          return paint_span_4_da;
        else if (alpha > 0)
          return paint_span_4_da_alpha;
      }
    else
      if (sa)
      {
        if (alpha == 255)
          return paint_span_4_sa;
        else if (alpha > 0)
          return paint_span_4_sa_alpha;
      }
      else
      {
        if (alpha == 255)
          return paint_span_4;
        else if (alpha > 0)
          return paint_span_4_alpha;
      }
    break;
#endif /* FZ_PLOTTERS_CMYK */
  default:
  {
#if !FZ_PLOTTERS_G
fallback:{}
#endif /* FZ_PLOTTERS_G */
#if FZ_PLOTTERS_N
    if (da)
      if (sa)
      {
        if (alpha == 255)
          return paint_span_N_da_sa;
        else if (alpha > 0)
          return paint_span_N_da_sa_alpha;
      }
      else
      {
        if (alpha == 255)
          return paint_span_N_da;
        else if (alpha > 0)
          return paint_span_N_da_alpha;
      }
    else
      if (sa)
      {
        if (alpha == 255)
          return paint_span_N_sa;
        else if (alpha > 0)
          return paint_span_N_sa_alpha;
      }
      else
      {
        if (alpha == 255)
          return paint_span_N;
        else if (alpha > 0)
          return paint_span_N_alpha;
      }
#endif /* FZ_PLOTTERS_N */
    break;
  }
  }
  return NULL;
}

/*
 * Pixmap blending functions
 */

void
fz_paint_pixmap_with_bbox(fz_pixmap * FZ_RESTRICT dst, const fz_pixmap * FZ_RESTRICT src, int alpha, fz_irect bbox)
{
  const unsigned char *sp;
  unsigned char *dp;
  int x, y, w, h, n, da, sa;
  fz_span_painter_t *fn;

  assert(dst->n - dst->alpha == src->n - src->alpha);

  if (alpha == 0)
    return;

  bbox = fz_intersect_irect(bbox, fz_pixmap_bbox_no_ctx(dst));
  bbox = fz_intersect_irect(bbox, fz_pixmap_bbox_no_ctx(src));

  x = bbox.x0;
  y = bbox.y0;
  w = fz_irect_width(bbox);
  h = fz_irect_height(bbox);
  if (w == 0 || h == 0)
    return;

  n = src->n;
  sp = src->samples + (y - src->y) * (size_t)src->stride + (x - src->x) * (size_t)src->n;
  sa = src->alpha;
  dp = dst->samples + (y - dst->y) * (size_t)dst->stride + (x - dst->x) * (size_t)dst->n;
  da = dst->alpha;

  n -= sa;
  fn = fz_get_span_painter(da, sa, n, alpha, 0);
  if (fn == NULL)
    return;

  while (h--)
  {
    (*fn)(dp, da, sp, sa, n, w, alpha, 0);
    sp += src->stride;
    dp += dst->stride;
  }
}

void
fz_paint_pixmap(fz_pixmap * FZ_RESTRICT dst, const fz_pixmap * FZ_RESTRICT src, int alpha)
{
  const unsigned char *sp;
  unsigned char *dp;
  fz_irect bbox;
  int x, y, w, h, n, da, sa;
  fz_span_painter_t *fn;

  if (alpha == 0)
    return;

  if (dst->n - dst->alpha != src->n - src->alpha)
  {
    // fprintf(stderr, "fz_paint_pixmap - FIXME\n");
    return;
  }
  assert(dst->n - dst->alpha == src->n - src->alpha);

  bbox = fz_intersect_irect(fz_pixmap_bbox_no_ctx(src), fz_pixmap_bbox_no_ctx(dst));
  x = bbox.x0;
  y = bbox.y0;
  w = fz_irect_width(bbox);
  h = fz_irect_height(bbox);
  if (w == 0 || h == 0)
    return;

  n = src->n;
  sp = src->samples + (y - src->y) * (size_t)src->stride + (x - src->x) * (size_t)src->n;
  sa = src->alpha;
  dp = dst->samples + (y - dst->y) * (size_t)dst->stride + (x - dst->x) * (size_t)dst->n;
  da = dst->alpha;

  n -= sa;
  fn = fz_get_span_painter(da, sa, n, alpha, 0);
  if (fn == NULL)
    return;

  while (h--)
  {
    (*fn)(dp, da, sp, sa, n, w, alpha, 0);
    sp += src->stride;
    dp += dst->stride;
  }
}

static fz_forceinline void
paint_span_alpha_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, int n, int w)
{
  FZ_TRACK_FUNCTION();
  sp += n-1;
  do
  {
    int s = *sp;
    int t = FZ_EXPAND(255 - s);
    sp += n;
    *dp = s + FZ_COMBINE(*dp, t);
    dp ++;
  }
  while (--w);
}

static fz_forceinline void
paint_span_alpha_not_solid(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, int n, int w, int alpha)
{
  FZ_TRACK_FUNCTION();
  sp += n-1;
  alpha = FZ_EXPAND(alpha);
  do
  {
    int masa = FZ_COMBINE(sp[0], alpha);
    sp += n;
    *dp = FZ_BLEND(*sp, *dp, masa);
    dp++;
  }
  while (--w);
}

void
fz_paint_pixmap_alpha(fz_pixmap * FZ_RESTRICT dst, const fz_pixmap * FZ_RESTRICT src, int alpha)
{
  const unsigned char *sp;
  unsigned char *dp;
  fz_irect bbox;
  int x, y, w, h, n;

  if (alpha == 0)
    return;

  assert(dst->n == 1 && dst->alpha == 1 && src->n >= 1 && src->alpha == 1);

  bbox = fz_intersect_irect(fz_pixmap_bbox_no_ctx(src), fz_pixmap_bbox_no_ctx(dst));
  x = bbox.x0;
  y = bbox.y0;
  w = fz_irect_width(bbox);
  h = fz_irect_height(bbox);
  if (w == 0 || h == 0)
    return;

  n = src->n;
  sp = src->samples + (y - src->y) * (size_t)src->stride + (x - src->x) * (size_t)src->n;
  dp = dst->samples + (y - dst->y) * (size_t)dst->stride + (x - dst->x) * (size_t)dst->n;

  if (alpha == 255)
  {
    while (h--)
    {
      paint_span_alpha_solid(dp, sp, n, w);
      sp += src->stride;
      dp += dst->stride;
    }
  }
  else
  {
    while (h--)
    {
      paint_span_alpha_not_solid(dp, sp, n, w, alpha);
      sp += src->stride;
      dp += dst->stride;
    }
  }
}

void
fz_paint_pixmap_with_overprint(fz_pixmap * FZ_RESTRICT dst, const fz_pixmap * FZ_RESTRICT src, const fz_overprint * FZ_RESTRICT eop)
{
  const unsigned char *sp;
  unsigned char *dp;
  fz_irect bbox;
  int x, y, w, h, n, da, sa;
  fz_span_painter_t *fn;

  if (dst->n - dst->alpha != src->n - src->alpha)
  {
    // fprintf(stderr, "fz_paint_pixmap_with_overprint - FIXME\n");
    return;
  }
  assert(dst->n - dst->alpha == src->n - src->alpha);

  bbox = fz_intersect_irect(fz_pixmap_bbox_no_ctx(src), fz_pixmap_bbox_no_ctx(dst));
  x = bbox.x0;
  y = bbox.y0;
  w = fz_irect_width(bbox);
  h = fz_irect_height(bbox);
  if (w == 0 || h == 0)
    return;

  n = src->n;
  sp = src->samples + (y - src->y) * (size_t)src->stride + (x - src->x) * (size_t)src->n;
  sa = src->alpha;
  dp = dst->samples + (y - dst->y) * (size_t)dst->stride + (x - dst->x) * (size_t)dst->n;
  da = dst->alpha;

  n -= sa;
  fn = fz_get_span_painter(da, sa, n, 255, eop);
  if (fn == NULL)
    return;

  while (h--)
  {
    (*fn)(dp, da, sp, sa, n, w, 255, eop);
    sp += src->stride;
    dp += dst->stride;
  }
}

void
fz_paint_pixmap_with_mask(fz_pixmap * FZ_RESTRICT dst, const fz_pixmap * FZ_RESTRICT src, const fz_pixmap * FZ_RESTRICT msk)
{
  const unsigned char *sp, *mp;
  unsigned char *dp;
  fz_irect bbox;
  int x, y, w, h, n, sa, da;
  fz_span_mask_painter_t *fn;

  assert(dst->n == src->n);
  assert(msk->n == 1);

  bbox = fz_pixmap_bbox_no_ctx(dst);
  bbox = fz_intersect_irect(bbox, fz_pixmap_bbox_no_ctx(src));
  bbox = fz_intersect_irect(bbox, fz_pixmap_bbox_no_ctx(msk));

  x = bbox.x0;
  y = bbox.y0;
  w = fz_irect_width(bbox);
  h = fz_irect_height(bbox);
  if (w == 0 || h == 0)
    return;

  n = src->n;
  sp = src->samples + (y - src->y) * (size_t)src->stride + (x - src->x) * (size_t)src->n;
  sa = src->alpha;
  mp = msk->samples + (y - msk->y) * (size_t)msk->stride + (x - msk->x) * (size_t)msk->n;
  dp = dst->samples + (y - dst->y) * (size_t)dst->stride + (x - dst->x) * (size_t)dst->n;
  da = dst->alpha;

  /* sa == da, or something has gone very wrong! */
  assert(sa == da);

  n -= sa;
  fn = fz_get_span_mask_painter(da, n);
  if (fn == NULL)
    return;

  while (h--)
  {
    (*fn)(dp, sp, mp, w, n, sa, NULL);
    sp += src->stride;
    dp += dst->stride;
    mp += msk->stride;
  }
}

static fz_forceinline void
paint_over_span_with_mask(byte * FZ_RESTRICT dp, const byte * FZ_RESTRICT sp, const byte * FZ_RESTRICT mp, int w)
{
  do
  {
    int ma = *mp++;
    ma = FZ_EXPAND(ma);
    if (ma == 0 || *sp == 0)
    {
      dp++;
      sp++;
    }
    else
    {
      int a = *sp++;
      if (ma != 256)
        a = fz_mul255(ma, a);
      *dp = 255 - fz_mul255(255 - a, 255 - *dp);
      dp++;
    }
  }
  while (--w);
}

void
fz_paint_over_pixmap_with_mask(fz_pixmap * FZ_RESTRICT dst, const fz_pixmap * FZ_RESTRICT src, const fz_pixmap * FZ_RESTRICT msk)
{
  const unsigned char *sp, *mp;
  unsigned char *dp;
  fz_irect bbox;
  int x, y, w, h;

  assert(dst->n == src->n);
  assert(msk->n == 1);

  bbox = fz_pixmap_bbox_no_ctx(dst);
  bbox = fz_intersect_irect(bbox, fz_pixmap_bbox_no_ctx(src));
  bbox = fz_intersect_irect(bbox, fz_pixmap_bbox_no_ctx(msk));

  x = bbox.x0;
  y = bbox.y0;
  w = fz_irect_width(bbox);
  h = fz_irect_height(bbox);
  if (w == 0 || h == 0)
    return;

  /* sa == da, or something has gone very wrong! */
  assert(src->alpha == dst->alpha && dst->alpha == 1 && src->n == 1);
  sp = src->samples + (y - src->y) * (size_t)src->stride + (size_t)(x - src->x);
  mp = msk->samples + (y - msk->y) * (size_t)msk->stride + (size_t)(x - msk->x);
  dp = dst->samples + (y - dst->y) * (size_t)dst->stride + (size_t)(x - dst->x);


  while (h--)
  {
    paint_over_span_with_mask(dp, sp, mp, w);
    sp += src->stride;
    dp += dst->stride;
    mp += msk->stride;
  }
}

static inline void
fz_paint_glyph_mask(int span, unsigned char *dp, int da, const fz_glyph *glyph, int w, int h, int skip_x, int skip_y)
{
  while (h--)
  {
    int skip_xx, ww, len, extend;
    const unsigned char *runp;
    unsigned char *ddp = dp;
    int offset = ((const int *)(glyph->data))[skip_y++];
    if (offset >= 0)
    {
      int eol = 0;
      runp = &glyph->data[offset];
      extend = 0;
      ww = w;
      skip_xx = skip_x;
      while (skip_xx)
      {
        int v = *runp++;
        switch (v & 3)
        {
        case 0: /* Extend */
          extend = v>>2;
          len = 0;
          break;
        case 1: /* Transparent */
          len = (v>>2) + 1 + (extend<<6);
          extend = 0;
          if (len > skip_xx)
          {
            len -= skip_xx;
            goto transparent_run;
          }
          break;
        case 2: /* Solid */
          eol = v & 4;
          len = (v>>3) + 1 + (extend<<5);
          extend = 0;
          if (len > skip_xx)
          {
            len -= skip_xx;
            goto solid_run;
          }
          break;
        default: /* Intermediate */
          eol = v & 4;
          len = (v>>3) + 1 + (extend<<5);
          extend = 0;
          if (len > skip_xx)
          {
            runp += skip_xx;
            len -= skip_xx;
            goto intermediate_run;
          }
          runp += len;
          break;
        }
        if (eol)
        {
          ww = 0;
          break;
        }
        skip_xx -= len;
      }
      while (ww > 0)
      {
        int v = *runp++;
        switch(v & 3)
        {
        case 0: /* Extend */
          extend = v>>2;
          break;
        case 1: /* Transparent */
          len = (v>>2) + 1 + (extend<<6);
          extend = 0;
transparent_run:
          if (len > ww)
            len = ww;
          ww -= len;
          ddp += len;
          break;
        case 2: /* Solid */
          eol = v & 4;
          len = (v>>3) + 1 + (extend<<5);
          extend = 0;
solid_run:
          if (len > ww)
            len = ww;
          ww -= len;
          do
          {
            *ddp++ = 0xFF;
          }
          while (--len);
          break;
        default: /* Intermediate */
          eol = v & 4;
          len = (v>>3) + 1 + (extend<<5);
          extend = 0;
intermediate_run:
          if (len > ww)
            len = ww;
          ww -= len;
          do
          {
            int a = *runp++;
            v = *ddp;
            if (v == 0)
            {
              *ddp++ = a;
            }
            else
            {
              a = FZ_EXPAND(a);
              *ddp = FZ_BLEND(0xFF, v, a);
              ddp++;
            }
          }
          while (--len);
          break;
        }
        if (eol)
          break;
      }
    }
    dp += span;
  }
}

static inline void
fz_paint_glyph_mask_alpha(int span, unsigned char *dp, int da, const fz_glyph *glyph, int w, int h, int skip_x, int skip_y, unsigned char alpha)
{
  while (h--)
  {
    int skip_xx, ww, len, extend;
    const unsigned char *runp;
    unsigned char *ddp = dp;
    int offset = ((const int *)(glyph->data))[skip_y++];
    if (offset >= 0)
    {
      int eol = 0;
      runp = &glyph->data[offset];
      extend = 0;
      ww = w;
      skip_xx = skip_x;
      while (skip_xx)
      {
        int v = *runp++;
        switch (v & 3)
        {
        case 0: /* Extend */
          extend = v>>2;
          len = 0;
          break;
        case 1: /* Transparent */
          len = (v>>2) + 1 + (extend<<6);
          extend = 0;
          if (len > skip_xx)
          {
            len -= skip_xx;
            goto transparent_run;
          }
          break;
        case 2: /* Solid */
          eol = v & 4;
          len = (v>>3) + 1 + (extend<<5);
          extend = 0;
          if (len > skip_xx)
          {
            len -= skip_xx;
            goto solid_run;
          }
          break;
        default: /* Intermediate */
          eol = v & 4;
          len = (v>>3) + 1 + (extend<<5);
          extend = 0;
          if (len > skip_xx)
          {
            runp += skip_xx;
            len -= skip_xx;
            goto intermediate_run;
          }
          runp += len;
          break;
        }
        if (eol)
        {
          ww = 0;
          break;
        }
        skip_xx -= len;
      }
      while (ww > 0)
      {
        int v = *runp++;
        switch(v & 3)
        {
        case 0: /* Extend */
          extend = v>>2;
          break;
        case 1: /* Transparent */
          len = (v>>2) + 1 + (extend<<6);
          extend = 0;
transparent_run:
          if (len > ww)
            len = ww;
          ww -= len;
          ddp += len;
          break;
        case 2: /* Solid */
          eol = v & 4;
          len = (v>>3) + 1 + (extend<<5);
          extend = 0;
solid_run:
          if (len > ww)
            len = ww;
          ww -= len;
          do
          {
            *ddp++ = alpha;
          }
          while (--len);
          break;
        default: /* Intermediate */
          eol = v & 4;
          len = (v>>3) + 1 + (extend<<5);
          extend = 0;
intermediate_run:
          if (len > ww)
            len = ww;
          ww -= len;
          do
          {
            int a = *runp++;
            v = *ddp;
            if (v == 0)
            {
              *ddp++ = fz_mul255(a, alpha);
            }
            else
            {
              a = FZ_EXPAND(a);
              *ddp = FZ_BLEND(alpha, v, a);
              ddp++;
            }
          }
          while (--len);
          break;
        }
        if (eol)
          break;
      }
    }
    dp += span;
  }
}

#define N 1
#include "paint-glyph.h"

#define ALPHA
#define N 1
#include "paint-glyph.h"

#if FZ_PLOTTERS_G
#define DA
#define N 1
#include "paint-glyph.h"

#define DA
#define ALPHA
#define N 1
#include "paint-glyph.h"
#endif /* FZ_PLOTTERS_G */

#if FZ_PLOTTERS_RGB
#define DA
#define N 3
#include "paint-glyph.h"

#define DA
#define ALPHA
#define N 3
#include "paint-glyph.h"

#define N 3
#include "paint-glyph.h"

#define ALPHA
#define N 3
#include "paint-glyph.h"
#endif /* FZ_PLOTTERS_RGB */

#if FZ_PLOTTERS_CMYK
#define DA
#define N 4
#include "paint-glyph.h"

#define DA
#define ALPHA
#define N 4
#include "paint-glyph.h"

#define ALPHA
#define N 4
#include "paint-glyph.h"

#define N 4
#include "paint-glyph.h"
#endif /* FZ_PLOTTERS_CMYK */

#if FZ_PLOTTERS_N
#define ALPHA
#include "paint-glyph.h"

#define DA
#include "paint-glyph.h"

#define DA
#define ALPHA
#include "paint-glyph.h"

#include "paint-glyph.h"
#endif /* FZ_PLOTTERS_N */

#if FZ_ENABLE_SPOT_RENDERING
#define ALPHA
#define EOP
#include "paint-glyph.h"

#define DA
#define EOP
#include "paint-glyph.h"

#define DA
#define ALPHA
#define EOP
#include "paint-glyph.h"

#define EOP
#include "paint-glyph.h"
#endif /* FZ_ENABLE_SPOT_RENDERING */

static void
fz_paint_glyph_alpha(const unsigned char * FZ_RESTRICT colorbv, int n, int span, unsigned char * FZ_RESTRICT dp, int da, const fz_glyph *glyph, int w, int h, int skip_x, int skip_y, const fz_overprint * FZ_RESTRICT eop)
{
#if FZ_ENABLE_SPOT_RENDERING
  if (fz_overprint_required(eop))
  {
    if (da)
      fz_paint_glyph_alpha_N_da_op(colorbv, n, span, dp, glyph, w, h, skip_x, skip_y, eop);
    else
      fz_paint_glyph_alpha_N_op(colorbv, n, span, dp, glyph, w, h, skip_x, skip_y, eop);
    return;
  }
#endif /* FZ_ENABLE_SPOT_RENDERING */
  switch (n)
  {
  case 1:
    if (da)
#if FZ_PLOTTERS_G
      fz_paint_glyph_alpha_1_da(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
#else
      goto fallback;
#endif /* FZ_PLOTTERS_G */
    else
      fz_paint_glyph_alpha_1(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    break;
#if FZ_PLOTTERS_RGB
  case 3:
    if (da)
      fz_paint_glyph_alpha_3_da(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    else
      fz_paint_glyph_alpha_3(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    break;
#endif /* FZ_PLOTTERS_RGB */
#if FZ_PLOTTERS_CMYK
  case 4:
    if (da)
      fz_paint_glyph_alpha_4_da(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    else
      fz_paint_glyph_alpha_4(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    break;
#endif /* FZ_PLOTTERS_CMYK */
  default:
  {
#if !FZ_PLOTTERS_G
fallback:{}
#endif /* !FZ_PLOTTERS_G */
#if FZ_PLOTTERS_N
    if (da)
      fz_paint_glyph_alpha_N_da(colorbv, n, span, dp, glyph, w, h, skip_x, skip_y);
    else
      fz_paint_glyph_alpha_N(colorbv, n, span, dp, glyph, w, h, skip_x, skip_y);
#endif /* FZ_PLOTTERS_N */
    break;
  }
  }
}

static void
fz_paint_glyph_solid(const unsigned char * FZ_RESTRICT colorbv, int n, int span, unsigned char * FZ_RESTRICT dp, int da, const fz_glyph * FZ_RESTRICT glyph, int w, int h, int skip_x, int skip_y, const fz_overprint * FZ_RESTRICT eop)
{
#if FZ_ENABLE_SPOT_RENDERING
  if (fz_overprint_required(eop))
  {
    if (da)
      fz_paint_glyph_solid_N_da_op(colorbv, n, span, dp, glyph, w, h, skip_x, skip_y, eop);
    else
      fz_paint_glyph_solid_N_op(colorbv, n, span, dp, glyph, w, h, skip_x, skip_y, eop);
    return;
  }
#endif /* FZ_ENABLE_SPOT_RENDERING */
  switch (n)
  {
  case 1:
    if (da)
#if FZ_PLOTTERS_G
      fz_paint_glyph_solid_1_da(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
#else
      goto fallback;
#endif /* FZ_PLOTTERS_G */
    else
      fz_paint_glyph_solid_1(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    break;
#if FZ_PLOTTERS_RGB
  case 3:
    if (da)
      fz_paint_glyph_solid_3_da(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    else
      fz_paint_glyph_solid_3(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    break;
#endif /* FZ_PLOTTERS_RGB */
#if FZ_PLOTTERS_CMYK
  case 4:
    if (da)
      fz_paint_glyph_solid_4_da(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    else
      fz_paint_glyph_solid_4(colorbv, span, dp, glyph, w, h, skip_x, skip_y);
    break;
#endif /* FZ_PLOTTERS_CMYK */
  default:
  {
#if !FZ_PLOTTERS_G
fallback:{}
#endif /* FZ_PLOTTERS_G */
#if FZ_PLOTTERS_N
    if (da)
      fz_paint_glyph_solid_N_da(colorbv, n, span, dp, glyph, w, h, skip_x, skip_y);
    else
      fz_paint_glyph_solid_N(colorbv, n, span, dp, glyph, w, h, skip_x, skip_y);
    break;
#endif /* FZ_PLOTTERS_N */
  }
  }
}

void
fz_paint_glyph(const unsigned char * FZ_RESTRICT colorbv, fz_pixmap * FZ_RESTRICT dst, unsigned char * FZ_RESTRICT dp, const fz_glyph * FZ_RESTRICT glyph, int w, int h, int skip_x, int skip_y, const fz_overprint * FZ_RESTRICT eop)
{
  int n = dst->n - dst->alpha;
  if (dst->colorspace)
  {
    assert(n > 0);
    if (colorbv[n] == 255)
      fz_paint_glyph_solid(colorbv, n, dst->stride, dp, dst->alpha, glyph, w, h, skip_x, skip_y, eop);
    else if (colorbv[n] != 0)
      fz_paint_glyph_alpha(colorbv, n, dst->stride, dp, dst->alpha, glyph, w, h, skip_x, skip_y, eop);
  }
  else
  {
    assert(dst->alpha && dst->n == 1 && dst->colorspace == NULL && !fz_overprint_required(eop));
    if (colorbv == NULL || colorbv[0] == 255)
      fz_paint_glyph_mask(dst->stride, dp, dst->alpha, glyph, w, h, skip_x, skip_y);
    else
      fz_paint_glyph_mask_alpha(dst->stride, dp, dst->alpha, glyph, w, h, skip_x, skip_y, colorbv[0]);
  }
}

Coverage Report

Created: 2026-08-14 07:34