// Copyright (C) 2004-2021 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 "context-imp.h"

#include "color-imp.h"

#include "draw-imp.h"

#include "glyph-imp.h"

#include "pixmap-imp.h"

#include <string.h>

#include <assert.h>

#include <math.h>

#include <float.h>

#define STACK_SIZE 96

/* Enable the following to attempt to support knockout and/or isolated

 * blending groups. */

#define ATTEMPT_KNOCKOUT_AND_ISOLATED

/* Enable the following to help debug group blending. */

#undef DUMP_GROUP_BLENDS

/* Enable the following to help debug graphics stack pushes/pops */

#undef DUMP_STACK_CHANGES

enum {

  FZ_DRAWDEV_FLAGS_TYPE3 = 1,

};

typedef struct {

  fz_irect scissor;

  fz_pixmap *dest;

  fz_pixmap *mask;

  fz_pixmap *shape;

  fz_pixmap *group_alpha;

  int blendmode;

  int id, encache;

  float alpha;

  fz_matrix ctm;

  float xstep, ystep;

  fz_irect area;

  int flags;

} fz_draw_state;

typedef struct fz_draw_device

{

  fz_device super;

  fz_matrix transform;

  fz_rasterizer *rast;

  fz_default_colorspaces *default_cs;

  fz_colorspace *proof_cs;

  int flags;

  int resolve_spots;

  int overprint_possible;

  int top;

  fz_scale_cache *cache_x;

  fz_scale_cache *cache_y;

  fz_draw_state *stack;

  int stack_cap;

  fz_draw_state init_stack[STACK_SIZE];

  fz_shade_color_cache *shade_cache;

} fz_draw_device;

#ifdef DUMP_GROUP_BLENDS

#include <stdio.h>

static int group_dump_count = 0;

static void fz_dump_blend(fz_context *ctx, const char *s, fz_pixmap *pix)

{

  char name[80];

  int psd = 0;

  if (!pix)

    return;

  if (pix->s || fz_colorspace_is_subtractive(ctx, pix->colorspace))

    psd = 1;

  fz_snprintf(name, sizeof(name), "dump%02d.%s", group_dump_count, psd ? "psd" : "png");

  printf("%s%02d%s(%p)", s ? s : "", group_dump_count++, psd ? "(PSD)" : "", pix);

  if (psd)

    fz_save_pixmap_as_psd(ctx, pix, name);

  else

    fz_save_pixmap_as_png(ctx, pix, name);

}

static void dump_spaces(int x, const char *s)

{

  int i;

  for (i = 0; i < x; i++)

    printf(" ");

  printf("%s", s);

}

#endif

#ifdef DUMP_STACK_CHANGES

#define STACK_PUSHED(A) stack_change(ctx, dev, '>', A)

#define STACK_POPPED(A) stack_change(ctx, dev, '<', A)

#define STACK_CONVERT(A) stack_change(ctx, dev, '=', A)

static void stack_change(fz_context *ctx, fz_draw_device *dev, int c, const char *s)

{

  int n, depth = dev->top;

  if (c != '<')

    depth--;

  n = depth;

  while (n-- > 0)

    fputc('\t', stderr);

  fprintf(stderr, "%c%s (%d)\n", c, s, depth);

}

#else

#define STACK_PUSHED(A) do {} while (0)

#define STACK_POPPED(A) do {} while (0)

#define STACK_CONVERT(A) do {} while (0)

#endif

/* Logic below assumes that default cs is set to color context cs if there

 * was not a default in the document for that particular cs

 */

static fz_colorspace *fz_default_colorspace(fz_context *ctx, fz_default_colorspaces *default_cs, fz_colorspace *cs)

{

  if (cs == NULL)

    return NULL;

  if (default_cs == NULL)

    return cs;

  switch (fz_colorspace_type(ctx, cs))

  {

  case FZ_COLORSPACE_GRAY:

    if (cs == fz_device_gray(ctx))

      return fz_default_gray(ctx, default_cs);

    break;

  case FZ_COLORSPACE_RGB:

    if (cs == fz_device_rgb(ctx))

      return fz_default_rgb(ctx, default_cs);

    break;

  case FZ_COLORSPACE_CMYK:

    if (cs == fz_device_cmyk(ctx))

      return fz_default_cmyk(ctx, default_cs);

    break;

  default:

    break;

  }

  return cs;

}

static void grow_stack(fz_context *ctx, fz_draw_device *dev)

{

  int max = dev->stack_cap * 2;

  fz_draw_state *stack;

  if (dev->stack == &dev->init_stack[0])

  {

    stack = fz_malloc_array(ctx, max, fz_draw_state);

    memcpy(stack, dev->stack, sizeof(*stack) * dev->stack_cap);

  }

  else

  {

    stack = fz_realloc_array(ctx, dev->stack, max, fz_draw_state);

  }

  dev->stack = Memento_label(stack, "draw_stack");

  dev->stack_cap = max;

}

/* 'Push' the stack. Returns a pointer to the current state, with state[1]

 * already having been initialised to contain the same thing. Simply

 * change any contents of state[1] that you want to and continue. */

static fz_draw_state *push_stack(fz_context *ctx, fz_draw_device *dev, const char *message)

{

  fz_draw_state *state;

  if (dev->top == dev->stack_cap-1)

    grow_stack(ctx, dev);

  state = &dev->stack[dev->top];

  dev->top++;

  memcpy(&state[1], state, sizeof(*state));

  STACK_PUSHED(message);

  return state;

}

static fz_draw_state *pop_stack(fz_context *ctx, fz_draw_device *dev, const char *message)

{

  fz_draw_state *state = &dev->stack[--dev->top];

  STACK_POPPED(message);

  return state;

}

static fz_draw_state *convert_stack(fz_context *ctx, fz_draw_device *dev, const char *message)

{

  fz_draw_state *state = &dev->stack[dev->top-1];

  STACK_CONVERT(message);

  return state;

}

static fz_draw_state *

fz_knockout_begin(fz_context *ctx, fz_draw_device *dev)

{

  fz_irect bbox, ga_bbox;

  fz_draw_state *state = &dev->stack[dev->top];

  int isolated = state->blendmode & FZ_BLEND_ISOLATED;

  if ((state->blendmode & FZ_BLEND_KNOCKOUT) == 0)

    return state;

  state = push_stack(ctx, dev, "knockout");

  bbox = fz_pixmap_bbox(ctx, state->dest);

  bbox = fz_intersect_irect(bbox, state->scissor);

  state[1].dest = fz_new_pixmap_with_bbox(ctx, state->dest->colorspace, bbox, state->dest->seps, state->dest->alpha);

  if (state[0].group_alpha)

  {

    ga_bbox = fz_pixmap_bbox(ctx, state->group_alpha);

    ga_bbox = fz_intersect_irect(ga_bbox, state->scissor);

    state[1].group_alpha = fz_new_pixmap_with_bbox(ctx, state->group_alpha->colorspace, ga_bbox, state->group_alpha->seps, state->group_alpha->alpha);

  }

  if (isolated)

  {

    fz_clear_pixmap(ctx, state[1].dest);

    if (state[1].group_alpha)

      fz_clear_pixmap(ctx, state[1].group_alpha);

  }

  else

  {

    /* Find the last but one destination to copy */

    int i = dev->top-1; /* i = the one on entry (i.e. the last one) */

    fz_draw_state *prev = state;

    while (i > 0)

    {

      prev = &dev->stack[--i];

      if (prev->dest != state->dest)

        break;

    }

    if (prev->dest)

    {

      fz_copy_pixmap_rect(ctx, state[1].dest, prev->dest, bbox, dev->default_cs);

      if (state[1].group_alpha)

      {

        if (prev->group_alpha)

          fz_copy_pixmap_rect(ctx, state[1].group_alpha, prev->group_alpha, ga_bbox, dev->default_cs);

        else

          fz_clear_pixmap(ctx, state[1].group_alpha);

      }

    }

    else

    {

      fz_clear_pixmap(ctx, state[1].dest);

      if (state[1].group_alpha)

        fz_clear_pixmap(ctx, state[1].group_alpha);

    }

  }

  /* Knockout groups (and only knockout groups) rely on shape */

  state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, bbox, NULL, 1);

  fz_clear_pixmap(ctx, state[1].shape);

#ifdef DUMP_GROUP_BLENDS

  dump_spaces(dev->top-1, "");

  fz_dump_blend(ctx, "Knockout begin: background is ", state[1].dest);

  if (state[1].shape)

    fz_dump_blend(ctx, "/S=", state[1].shape);

  if (state[1].group_alpha)

    fz_dump_blend(ctx, "/GA=", state[1].group_alpha);

  printf("\n");

#endif

  state[1].scissor = bbox;

  state[1].blendmode &= ~(FZ_BLEND_MODEMASK | FZ_BLEND_ISOLATED);

  return &state[1];

}

static void fz_knockout_end(fz_context *ctx, fz_draw_device *dev)

{

  fz_draw_state *state;

  if (dev->top == 0)

    fz_throw(ctx, FZ_ERROR_GENERIC, "unexpected knockout end");

  state = pop_stack(ctx, dev, "knockout");

  if ((state[0].blendmode & FZ_BLEND_KNOCKOUT) == 0)

    return;

  assert((state[1].blendmode & FZ_BLEND_ISOLATED) == 0);

  assert((state[1].blendmode & FZ_BLEND_MODEMASK) == 0);

  assert(state[1].shape);

#ifdef DUMP_GROUP_BLENDS

  dump_spaces(dev->top, "");

  fz_dump_blend(ctx, "Knockout end: blending ", state[1].dest);

  if (state[1].shape)

    fz_dump_blend(ctx, "/S=", state[1].shape);

  if (state[1].group_alpha)

    fz_dump_blend(ctx, "/GA=", state[1].group_alpha);

  fz_dump_blend(ctx, " onto ", state[0].dest);

  if (state[0].shape)

    fz_dump_blend(ctx, "/S=", state[0].shape);

  if (state[0].group_alpha)

    fz_dump_blend(ctx, "/GA=", state[0].group_alpha);

  if ((state->blendmode & FZ_BLEND_MODEMASK) != 0)

    printf(" (blend %d)", state->blendmode & FZ_BLEND_MODEMASK);

  if ((state->blendmode & FZ_BLEND_ISOLATED) != 0)

    printf(" (isolated)");

  printf(" (knockout)");

#endif

  fz_blend_pixmap_knockout(ctx, state[0].dest, state[1].dest, state[1].shape);

  fz_drop_pixmap(ctx, state[1].dest);

  state[1].dest = NULL;

  if (state[1].group_alpha && state[0].group_alpha != state[1].group_alpha)

  {

    if (state[0].group_alpha)

      fz_blend_pixmap_knockout(ctx, state[0].group_alpha, state[1].group_alpha, state[1].shape);

    fz_drop_pixmap(ctx, state[1].group_alpha);

    state[1].group_alpha = NULL;

  }

  if (state[0].shape != state[1].shape)

  {

    if (state[0].shape)

      fz_paint_pixmap(state[0].shape, state[1].shape, 255);

    fz_drop_pixmap(ctx, state[1].shape);

    state[1].shape = NULL;

  }

#ifdef DUMP_GROUP_BLENDS

  fz_dump_blend(ctx, " to get ", state[0].dest);

  if (state[0].shape)

    fz_dump_blend(ctx, "/S=", state[0].shape);

  if (state[0].group_alpha)

    fz_dump_blend(ctx, "/GA=", state[0].group_alpha);

  printf("\n");

#endif

}

static int

colors_supported(fz_context *ctx, fz_colorspace *cs, fz_pixmap *dest)

{

  /* Even if we support separations in the destination, if the color space has CMY or K as one of

   * its colorants and we are in RGB or Gray we will want to do the tint transform */

  if (!fz_colorspace_is_subtractive(ctx, dest->colorspace) && fz_colorspace_device_n_has_cmyk(ctx, cs))

    return 0;

  /* If we have separations then we should support it */

  if (dest->seps)

    return 1;

  /* If our destination is CMYK and the source color space is only C, M, Y or K we support it

   * even if we have no seps */

  if (fz_colorspace_is_subtractive(ctx, dest->colorspace))

  {

    int i, n;

    if (fz_colorspace_device_n_has_only_cmyk(ctx, cs))

      return 1;

    n = fz_colorspace_n(ctx, cs);

    for (i = 0; i < n; i++)

    {

      const char *name = fz_colorspace_colorant(ctx, cs, i);

      if (!name)

        return 0;

      if (!strcmp(name, "All"))

        continue;

      if (!strcmp(name, "Cyan"))

        continue;

      if (!strcmp(name, "Magenta"))

        continue;

      if (!strcmp(name, "Yellow"))

        continue;

      if (!strcmp(name, "Black"))

        continue;

      if (!strcmp(name, "None"))

        continue;

      return 0;

    }

    return 1;

  }

  return 0;

}

static fz_overprint *

set_op_from_spaces(fz_context *ctx, fz_overprint *op, const fz_pixmap *dest, fz_colorspace *src, int opm)

{

  int dn, sn, i, j, dc;

  if (!op)

    return NULL;

  if (fz_colorspace_is_indexed(ctx, src))

    src = fz_base_colorspace(ctx, src);

  if (!fz_colorspace_is_subtractive(ctx, dest->colorspace))

    return NULL;

  if (fz_colorspace_is_gray(ctx, src))

  {

    /* gray counts as a CMYK with CMY = 0 */

  }

  else if (!fz_colorspace_is_subtractive(ctx, src))

  {

    /* The source pixmap was not in a subtractive space, so we can't

     * base overprint decisions on that. But we know we've converted

     * to a subtractive destination, so we can base overprint

     * decisions on what we ended up with. */

    src = dest->colorspace;

  }

  sn = fz_colorspace_n(ctx, src);

  dn = dest->n - dest->alpha;

  dc = dn - dest->s;

  /* If a source colorant is not mentioned in the destination

   * colorants (either process or spots), then it will be mapped

   * to process colorants. In this case, the process colorants

   * can never be protected.

   */

  for (j = 0; j < sn; j++)

  {

    /* Run through the colorants looking for one that isn't mentioned.

     * i.e. continue if we we find one, break if not. */

    const char *sname = fz_colorspace_colorant(ctx, src, j);

    if (!sname)

      break;

    if (!strcmp(sname, "All") || !strcmp(sname, "None"))

      continue;

    for (i = 0; i < dc; i++)

    {

      const char *name = fz_colorspace_colorant(ctx, dest->colorspace, i);

      if (!name)

        continue;

      if (!strcmp(name, sname))

        break;

    }

    if (i != dc)

      continue;

    for (; i < dn; i++)

    {

      const char *name = fz_separation_name(ctx, dest->seps, i - dc);

      if (!name)

        continue;

      if (!strcmp(name, sname))

        break;

    }

    if (i == dn)

    {

      /* This source colorant wasn't mentioned */

      break;

    }

  }

  if (j == sn)

  {

    /* We did not find any source colorants that weren't mentioned, so

     * process colorants might not be touched... */

    for (i = 0; i < dc; i++)

    {

      const char *name = fz_colorspace_colorant(ctx, dest->colorspace, i);

      for (j = 0; j < sn; j++)

      {

        const char *sname = fz_colorspace_colorant(ctx, src, j);

        if (!name || !sname)

          continue;

        if (!strcmp(name, sname))

          break;

        if (!strcmp(sname, "All"))

          break;

      }

      if (j == sn)

        fz_set_overprint(op, i);

    }

  }

  for (i = dc; i < dn; i++)

  {

    const char *name = fz_separation_name(ctx, dest->seps, i - dc);

    for (j = 0; j < sn; j++)

    {

      const char *sname = fz_colorspace_colorant(ctx, src, j);

      if (!name || !sname)

        continue;

      if (!strcmp(name, sname))

        break;

      if (!strcmp(sname, "All"))

        break;

    }

    if (j == sn)

      fz_set_overprint(op, i);

  }

  return op;

}

static fz_overprint *

resolve_color(fz_context *ctx,

  fz_overprint *op,

  const float *color,

  fz_colorspace *colorspace,

  float alpha,

  fz_color_params color_params,

  unsigned char *colorbv,

  fz_pixmap *dest,

  int overprint_possible)

{

  float colorfv[FZ_MAX_COLORS];

  int i;

  int n = dest->n - dest->alpha;

  fz_colorspace *model = dest->colorspace;

  int devn, devgray;

  int effective_opm;

  if (colorspace == NULL && model != NULL)

    fz_throw(ctx, FZ_ERROR_GENERIC, "color destination requires source color");

  effective_opm = color_params.opm;

  devn = fz_colorspace_is_device_n(ctx, colorspace);

  devgray = fz_colorspace_is_device_gray(ctx, colorspace);

  /* We can only overprint when enabled, and when we are in a subtractive colorspace */

  if (color_params.op == 0 || !fz_colorspace_is_subtractive(ctx, dest->colorspace) || !overprint_possible)

    op = NULL;

  else if (devgray)

  {

    /* Device Gray is additive, but seems to still be

     * counted for overprint (see

     * Ghent_V3.0/030_Gray_K_black_OP_x1a.pdf 030.pdf). */

  }

  /* If we are in a CMYK space (i.e. not a devn one, given we know we are subtractive at this point),

   * then we only adhere to overprint mode if it's the same space as the destination. */

  /* FIXME: Possibly we need a better equivalency test here. */

  else if (!devn && colorspace != dest->colorspace)

  {

    effective_opm = 0;

  }

  if (n == 0)

    i = 0;

  else if (devn && colors_supported(ctx, colorspace, dest))

  {

    fz_convert_separation_colors(ctx, colorspace, color, dest->seps, dest->colorspace, colorfv, color_params);

    for (i = 0; i < n; i++)

      colorbv[i] = colorfv[i] * 255;

    op = set_op_from_spaces(ctx, op, dest, colorspace, effective_opm);

  }

  else

  {

    int c = n - dest->s;

    fz_convert_color(ctx, colorspace, color, dest->colorspace, colorfv, NULL, color_params);

    for (i = 0; i < c; i++)

      colorbv[i] = colorfv[i] * 255;

    for (; i < n; i++)

    {

      colorfv[i] = 0;

      colorbv[i] = 0;

    }

  }

  colorbv[i] = alpha * 255;

  /* op && !devn => overprinting in cmyk or devicegray. */

  if (op && !devn)

  {

    /* We are overprinting, so protect all spots. */

    for (i = 4; i < n; i++)

      fz_set_overprint(op, i);

    /* If OPM, then protect all components for which the color values are zero.

     * (but only if we're in devicecmyk). */

    if (effective_opm == 1 && colorspace != fz_device_gray(ctx))

      for (i = 0; i < n; i++)

        if (colorfv[i] == 0)

          fz_set_overprint(op, i);

  }

  return op;

}

static fz_draw_state *

push_group_for_separations(fz_context *ctx, fz_draw_device *dev, fz_color_params color_params, fz_default_colorspaces *default_cs)

{

  fz_separations *clone = fz_clone_separations_for_overprint(ctx, dev->stack[0].dest->seps);

  fz_colorspace *oi = fz_default_output_intent(ctx, default_cs);

  fz_colorspace *dcs = fz_device_cmyk(ctx);

  /* Pick sep target CMYK based upon proof and output intent settings.  Priority

  * is oi, proof, devicecmyk. */

  if (dev->proof_cs)

  {

    dcs = dev->proof_cs;

  }

  if (oi)

  {

    dcs = oi;

  }

  /* Not needed if dest has the seps, and we are not using a proof or the target is the same as the proof and we don't have an oi or the target is the same as the oi */

  if ((clone == dev->stack[0].dest->seps) && (dev->proof_cs == NULL || dev->proof_cs == dev->stack[0].dest->colorspace) && (oi == NULL || oi == dev->stack[0].dest->colorspace))

  {

    fz_drop_separations(ctx, clone);

    dev->resolve_spots = 0;

    return &dev->stack[0];

  }

  /* Make a new pixmap to render to. */

  fz_try(ctx)

  {

    push_stack(ctx, dev, "separations");

    dev->stack[1].dest = fz_clone_pixmap_area_with_different_seps(ctx, dev->stack[0].dest, &dev->stack[0].scissor, dcs, clone, color_params, default_cs);

  }

  fz_always(ctx)

    fz_drop_separations(ctx, clone);

  fz_catch(ctx)

    fz_rethrow(ctx);

  return &dev->stack[1];

}

static void

fz_draw_fill_path(fz_context *ctx, fz_device *devp, const fz_path *path, int even_odd, fz_matrix in_ctm,

  fz_colorspace *colorspace_in, const float *color, float alpha, fz_color_params color_params)

{

  fz_draw_device *dev = (fz_draw_device*)devp;

  fz_matrix ctm = fz_concat(in_ctm, dev->transform);

  fz_rasterizer *rast = dev->rast;

  fz_colorspace *colorspace = fz_default_colorspace(ctx, dev->default_cs, colorspace_in);

  float expansion = fz_matrix_expansion(ctm);

  float flatness;

  unsigned char colorbv[FZ_MAX_COLORS + 1];

  fz_irect bbox;

  fz_draw_state *state = &dev->stack[dev->top];

  fz_overprint op = { { 0 } };

  fz_overprint *eop;

  if (dev->top == 0 && dev->resolve_spots)

    state = push_group_for_separations(ctx, dev, color_params, dev->default_cs);

  if (expansion < FLT_EPSILON)

    expansion = 1;

  flatness = 0.3f / expansion;

  if (flatness < 0.001f)

    flatness = 0.001f;

  bbox = fz_intersect_irect(fz_pixmap_bbox(ctx, state->dest), state->scissor);

  if (fz_flatten_fill_path(ctx, rast, path, ctm, flatness, bbox, &bbox))

    return;

  if (alpha == 0)

    return;

  if (state->blendmode & FZ_BLEND_KNOCKOUT && alpha != 1)

    state = fz_knockout_begin(ctx, dev);

  eop = resolve_color(ctx, &op, color, colorspace, alpha, color_params, colorbv, state->dest, dev->overprint_possible);

  fz_convert_rasterizer(ctx, rast, even_odd, state->dest, colorbv, eop);

  if (state->shape)

  {

    if (!rast->fns.reusable)

      fz_flatten_fill_path(ctx, rast, path, ctm, flatness, bbox, NULL);

    colorbv[0] = 255;

    fz_convert_rasterizer(ctx, rast, even_odd, state->shape, colorbv, 0);

  }

  if (state->group_alpha)

  {

    if (!rast->fns.reusable)

      fz_flatten_fill_path(ctx, rast, path, ctm, flatness, bbox, NULL);

    colorbv[0] = alpha * 255;

    fz_convert_rasterizer(ctx, rast, even_odd, state->group_alpha, colorbv, 0);

  }

  if (state->blendmode & FZ_BLEND_KNOCKOUT && alpha != 1)

    fz_knockout_end(ctx, dev);

}

static void

fz_draw_stroke_path(fz_context *ctx, fz_device *devp, const fz_path *path, const fz_stroke_state *stroke, fz_matrix in_ctm,

  fz_colorspace *colorspace_in, const float *color, float alpha, fz_color_params color_params)

{

  fz_draw_device *dev = (fz_draw_device*)devp;

  fz_matrix ctm = fz_concat(in_ctm, dev->transform);

  fz_rasterizer *rast = dev->rast;

  fz_colorspace *colorspace = fz_default_colorspace(ctx, dev->default_cs, colorspace_in);

  float expansion = fz_matrix_expansion(ctm);

  float flatness;

  float linewidth = stroke->linewidth;

  unsigned char colorbv[FZ_MAX_COLORS + 1];

  fz_irect bbox;

  float aa_level = 2.0f/(fz_rasterizer_graphics_aa_level(rast)+2);

  fz_draw_state *state = &dev->stack[dev->top];

  float mlw = fz_rasterizer_graphics_min_line_width(rast);

  fz_overprint op = { { 0 } };

  fz_overprint *eop;

  if (dev->top == 0 && dev->resolve_spots)

    state = push_group_for_separations(ctx, dev, color_params, dev->default_cs);

  if (mlw > aa_level)

    aa_level = mlw;

  if (expansion < FLT_EPSILON)

    expansion = 1;

  if (linewidth * expansion < aa_level)

    linewidth = aa_level / expansion;

  flatness = 0.3f / expansion;

  if (flatness < 0.001f)

    flatness = 0.001f;

  bbox = fz_intersect_irect(fz_pixmap_bbox_no_ctx(state->dest), state->scissor);

  if (fz_flatten_stroke_path(ctx, rast, path, stroke, ctm, flatness, linewidth, bbox, &bbox))

    return;

  if (alpha == 0)

    return;

  if (state->blendmode & FZ_BLEND_KNOCKOUT && alpha != 1)

    state = fz_knockout_begin(ctx, dev);

  eop = resolve_color(ctx, &op, color, colorspace, alpha, color_params, colorbv, state->dest, dev->overprint_possible);

#ifdef DUMP_GROUP_BLENDS

  dump_spaces(dev->top, "");

  fz_dump_blend(ctx, "Before stroke ", state->dest);

  if (state->shape)

    fz_dump_blend(ctx, "/S=", state->shape);

  if (state->group_alpha)

    fz_dump_blend(ctx, "/GA=", state->group_alpha);

  printf("\n");

#endif

  fz_convert_rasterizer(ctx, rast, 0, state->dest, colorbv, eop);

  if (state->shape)

  {

    if (!rast->fns.reusable)

      (void)fz_flatten_stroke_path(ctx, rast, path, stroke, ctm, flatness, linewidth, bbox, NULL);

    colorbv[0] = 255;

    fz_convert_rasterizer(ctx, rast, 0, state->shape, colorbv, 0);

  }

  if (state->group_alpha)

  {

    if (!rast->fns.reusable)

      (void)fz_flatten_stroke_path(ctx, rast, path, stroke, ctm, flatness, linewidth, bbox, NULL);

    colorbv[0] = 255 * alpha;

    fz_convert_rasterizer(ctx, rast, 0, state->group_alpha, colorbv, 0);

  }

#ifdef DUMP_GROUP_BLENDS

  dump_spaces(dev->top, "");

  fz_dump_blend(ctx, "After stroke ", state->dest);

  if (state->shape)

    fz_dump_blend(ctx, "/S=", state->shape);

  if (state->group_alpha)

    fz_dump_blend(ctx, "/GA=", state->group_alpha);

  printf("\n");

#endif

  if (state->blendmode & FZ_BLEND_KNOCKOUT && alpha != 1)

    fz_knockout_end(ctx, dev);

}

static void

fz_draw_clip_path(fz_context *ctx, fz_device *devp, const fz_path *path, int even_odd, fz_matrix in_ctm, fz_rect scissor)

{

  fz_draw_device *dev = (fz_draw_device*)devp;

  fz_matrix ctm = fz_concat(in_ctm, dev->transform);

  fz_rasterizer *rast = dev->rast;

  float expansion = fz_matrix_expansion(ctm);

  float flatness;

  fz_irect bbox;

  fz_draw_state *state = &dev->stack[dev->top];

  fz_colorspace *model;

  if (dev->top == 0 && dev->resolve_spots)

    state = push_group_for_separations(ctx, dev, fz_default_color_params /* FIXME */, dev->default_cs);

  if (expansion < FLT_EPSILON)

    expansion = 1;

  flatness = 0.3f / expansion;

  if (flatness < 0.001f)

    flatness = 0.001f;

  state = push_stack(ctx, dev, "clip path");

  model = state->dest->colorspace;

  if (!fz_is_infinite_rect(scissor))

  {

    bbox = fz_irect_from_rect(fz_transform_rect(scissor, dev->transform));

    bbox = fz_intersect_irect(bbox, fz_pixmap_bbox(ctx, state->dest));

    bbox = fz_intersect_irect(bbox, state->scissor);

  }

  else

  {

    bbox = fz_intersect_irect(fz_pixmap_bbox(ctx, state->dest), state->scissor);

  }

  if (fz_flatten_fill_path(ctx, rast, path, ctm, flatness, bbox, &bbox) || fz_is_rect_rasterizer(ctx, rast))

  {

    state[1].scissor = bbox;

    state[1].mask = NULL;

#ifdef DUMP_GROUP_BLENDS

    dump_spaces(dev->top-1, "Clip (rectangular) begin\n");

#endif

    return;

  }

  state[1].mask = fz_new_pixmap_with_bbox(ctx, NULL, bbox, NULL, 1);

  fz_clear_pixmap(ctx, state[1].mask);

  state[1].dest = fz_new_pixmap_with_bbox(ctx, model, bbox, state[0].dest->seps, state[0].dest->alpha);

  fz_copy_pixmap_rect(ctx, state[1].dest, state[0].dest, bbox, dev->default_cs);

  if (state[1].shape)

  {

    state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, bbox, NULL, 1);

    fz_copy_pixmap_rect(ctx, state[1].shape, state[0].shape, bbox, dev->default_cs);

  }

  if (state[1].group_alpha)

  {

    state[1].group_alpha = fz_new_pixmap_with_bbox(ctx, NULL, bbox, NULL, 1);

    fz_copy_pixmap_rect(ctx, state[1].group_alpha, state[0].group_alpha, bbox, dev->default_cs);

  }

  fz_convert_rasterizer(ctx, rast, even_odd, state[1].mask, NULL, 0);

  state[1].scissor = bbox;

#ifdef DUMP_GROUP_BLENDS

  dump_spaces(dev->top-1, "Clip (non-rectangular) begin\n");

#endif

}

static void

fz_draw_clip_stroke_path(fz_context *ctx, fz_device *devp, const fz_path *path, const fz_stroke_state *stroke, fz_matrix in_ctm, fz_rect scissor)

{

  fz_draw_device *dev = (fz_draw_device*)devp;

  fz_matrix ctm = fz_concat(in_ctm, dev->transform);

  fz_rasterizer *rast = dev->rast;

  float expansion = fz_matrix_expansion(ctm);

  float flatness;

  float linewidth = stroke->linewidth;

  fz_irect bbox;

  fz_draw_state *state = &dev->stack[dev->top];

  fz_colorspace *model;

  float aa_level = 2.0f/(fz_rasterizer_graphics_aa_level(rast)+2);

  float mlw = fz_rasterizer_graphics_min_line_width(rast);

  if (dev->top == 0 && dev->resolve_spots)

    state = push_group_for_separations(ctx, dev, fz_default_color_params /* FIXME */, dev->default_cs);

  if (mlw > aa_level)

    aa_level = mlw;

  if (expansion < FLT_EPSILON)

    expansion = 1;

  if (linewidth * expansion < aa_level)

    linewidth = aa_level / expansion;

  flatness = 0.3f / expansion;

  if (flatness < 0.001f)

    flatness = 0.001f;

  state = push_stack(ctx, dev, "clip stroke");

  model = state->dest->colorspace;

  if (!fz_is_infinite_rect(scissor))

  {

    bbox = fz_irect_from_rect(fz_transform_rect(scissor, dev->transform));

    bbox = fz_intersect_irect(bbox, fz_pixmap_bbox(ctx, state->dest));

    bbox = fz_intersect_irect(bbox, state->scissor);

  }

  else

  {

    bbox = fz_intersect_irect(fz_pixmap_bbox(ctx, state->dest), state->scissor);

  }

  if (fz_flatten_stroke_path(ctx, rast, path, stroke, ctm, flatness, linewidth, bbox, &bbox))

  {

    state[1].scissor = bbox;

    state[1].mask = NULL;

#ifdef DUMP_GROUP_BLENDS

    dump_spaces(dev->top-1, "Clip (stroke, empty) begin\n");

#endif

    return;

  }

  state[1].mask = fz_new_pixmap_with_bbox(ctx, NULL, bbox, NULL, 1);

  fz_clear_pixmap(ctx, state[1].mask);

  /* When there is no alpha in the current destination (state[0].dest->alpha == 0)

   * we have a choice. We can either create the new destination WITH alpha, or

   * we can copy the old pixmap contents in. We opt for the latter here, but

   * may want to revisit this decision in the future. */

  state[1].dest = fz_new_pixmap_with_bbox(ctx, model, bbox, state[0].dest->seps, state[0].dest->alpha);

  if (state[0].dest->alpha)

    fz_clear_pixmap(ctx, state[1].dest);

  else

    fz_copy_pixmap_rect(ctx, state[1].dest, state[0].dest, bbox, dev->default_cs);

  if (state->shape)

  {

    state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, bbox, NULL, 1);

    fz_copy_pixmap_rect(ctx, state[1].shape, state[0].shape, bbox, dev->default_cs);

  }

  if (state->group_alpha)

  {

    state[1].group_alpha = fz_new_pixmap_with_bbox(ctx, NULL, bbox, NULL, 1);

    fz_copy_pixmap_rect(ctx, state[1].group_alpha, state[0].group_alpha, bbox, dev->default_cs);

  }

  fz_convert_rasterizer(ctx, rast, 0, state[1].mask, NULL, 0);

  state[1].blendmode |= FZ_BLEND_ISOLATED;

  state[1].scissor = bbox;

#ifdef DUMP_GROUP_BLENDS

  dump_spaces(dev->top-1, "Clip (stroke) begin\n");

#endif

}

static void

draw_glyph(unsigned char *colorbv, fz_pixmap *dst, fz_glyph *glyph,

  int xorig, int yorig, const fz_irect *scissor, fz_overprint *eop)

{

  unsigned char *dp;

  fz_irect bbox;

  int x, y, w, h;

  int skip_x, skip_y;

  fz_pixmap *msk;

  bbox = fz_glyph_bbox_no_ctx(glyph);

  bbox = fz_translate_irect(bbox, xorig, yorig);

  bbox = fz_intersect_irect(bbox, *scissor); /* scissor < dst */

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

  if (fz_is_empty_irect(bbox))

    return;

  x = bbox.x0;

  y = bbox.y0;

  w = bbox.x1 - bbox.x0;

  h = bbox.y1 - bbox.y0;

  skip_x = x - glyph->x - xorig;

  skip_y = y - glyph->y - yorig;

  msk = glyph->pixmap;

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

  if (msk == NULL)

  {

    fz_paint_glyph(colorbv, dst, dp, glyph, w, h, skip_x, skip_y, eop);

  }

  else

  {

    unsigned char *mp = msk->samples + skip_y * msk->stride + skip_x;

    int da = dst->alpha;

    if (dst->colorspace)

    {

      fz_span_color_painter_t *fn;

      fn = fz_get_span_color_painter(dst->n, da, colorbv, eop);

      if (fn == NULL)

        return;

      while (h--)

      {