/* Copyright (C) 2001-2025 Artifex Software, Inc.

   All Rights Reserved.

   This software is provided AS-IS with no warranty, either express or

   implied.

   This software is distributed under license and may not be copied,

   modified or distributed except as expressly authorized under the terms

   of the license contained in the file LICENSE in this distribution.

   Refer to licensing information at http://www.artifex.com or contact

   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,

   CA 94129, USA, for further information.

*/

/* A topological spot decomposition algorithm with dropout prevention. */

/*

   This is a dramaticly reorganized and improved revision of the

   filling algorithm, which was initially coded by Henry Stiles.

   The main improvements are:

        1. A dropout prevention for character fill.

        2. The spot topology analysis support

           for True Type grid fitting.

        3. Fixed the contiguity of a spot covering

           for shading fills with no dropouts.

*/

/* See is_spotan about the spot topology analysis support. */

/* Also defining lower-level path filling procedures */

#include "gx.h"

#include "gserrors.h"

#include "gsstruct.h"

#include "gxfixed.h"

#include "gxdevice.h"

#include "gzpath.h"

#include "gzcpath.h"

#include "gxdcolor.h"

#include "gxhttile.h"

#include "gxgstate.h"

#include "gxpaint.h"            /* for prototypes */

#include "gxfill.h"

#include "gxpath.h"

#include "gsptype1.h"

#include "gsptype2.h"

#include "gxpcolor.h"

#include "gdevddrw.h"

#include "gzspotan.h" /* Only for gx_san_trap_store. */

#include "memory_.h"

#include "stdint_.h"

#include "gsstate.h"            /* for gs_currentcpsimode */

#include "gxdevsop.h"

#include "gxscanc.h"

/*

#include "gxfilltr.h" - Do not remove this comment. "gxfilltr.h" is included below.

#include "gxfillsl.h" - Do not remove this comment. "gxfillsl.h" is included below.

#include "gxfillts.h" - Do not remove this comment. "gxfillts.h" is included below.

*/

#include "assert_.h"

/* #define ENABLE_TRAP_AMALGAMATION */

/*

 * ENABLE_TRAP_AMALGAMATION - Experimental trap amalgamation code, disabled

 * by default.

 *

 * Set this if you think that the potential gains from only having to send

 * one trapezoid rather than 3 trapezoids justifies the costs in

 * calculating whether this is possible.

 *

 * Note: Due to rounding inaccuracies while scan converting, there are

 * cases where the rectangles can round to different pixel boundaries than

 * the trapezoids do. This means that enabling the TRY_TO_EXTEND_TRAP

 * define will cause rendering differences, but tests seem to indicate that

 * this only happens in very borderline cases.

 */

#ifdef ENABLE_TRAP_AMALGAMATION

#define TRY_TO_EXTEND_TRAP 1

#else

#define TRY_TO_EXTEND_TRAP 0

#endif

#ifdef COLLECT_STATS_FILL

/* Define the statistics structure instance. */

stats_fill_t stats_fill;

#endif

/* A predicate for spot insideness. */

/* rule = -1 for winding number rule, i.e. */

/* we are inside if the winding number is non-zero; */

/* rule = 1 for even-odd rule, i.e. */

/* we are inside if the winding number is odd. */

#define INSIDE_PATH_P(inside, rule) ((inside & rule) != 0)

/* ---------------- Active line management ---------------- */

/*

 * Define the ordering criterion for active lines that overlap in Y.

 * Return -1, 0, or 1 if lp1 precedes, coincides with, or follows lp2.

 *

 * The lines' x_current values are correct for some Y value that crosses

 * both of them and that is not both the start of one and the end of the

 * other.  (Neither line is horizontal.)  We want the ordering at this

 * Y value, or, of the x_current values are equal, greater Y values

 * (if any: this Y value might be the end of both lines).

 */

static int

x_order(const active_line *lp1, const active_line *lp2)

{

    bool s1;

    INCR(order);

    if (!lp1 || !lp2 || lp1->x_current < lp2->x_current)

        return -1;

    else if (lp1->x_current > lp2->x_current)

        return 1;

    /*

     * We need to compare the slopes of the lines.  Start by

     * checking one fast case, where the slopes have opposite signs.

     */

    if ((s1 = lp1->start.x < lp1->end.x) != (lp2->start.x < lp2->end.x))

        return (s1 ? 1 : -1);

    /*

     * We really do have to compare the slopes.  Fortunately, this isn't

     * needed very often.  We want the sign of the comparison

     * dx1/dy1 - dx2/dy2, or (since we know dy1 and dy2 are positive)

     * dx1 * dy2 - dx2 * dy1.  In principle, we can't simply do this using

     * doubles, since we need complete accuracy and doubles don't have

     * enough fraction bits.  However, with the usual 20+12-bit fixeds and

     * 64-bit doubles, both of the factors would have to exceed 2^15

     * device space pixels for the result to be inaccurate, so we

     * simply disregard this possibility.  ****** FIX SOMEDAY ******

     */

    INCR(slow_order);

    {

        fixed dx1 = lp1->end.x - lp1->start.x,

            dy1 = lp1->end.y - lp1->start.y;

        fixed dx2 = lp2->end.x - lp2->start.x,

            dy2 = lp2->end.y - lp2->start.y;

        double diff = (double)dx1 * dy2 - (double)dx2 * dy1;

        return (diff < 0 ? -1 : diff > 0 ? 1 : 0);

    }

}

/*

 * The active_line structure isn't really simple, but since its instances

 * only exist temporarily during a fill operation, we don't have to

 * worry about a garbage collection occurring.

 */

gs_private_st_simple(st_active_line, active_line, "active_line");

#ifdef DEBUG

/* Internal procedures for printing and checking active lines. */

static void

print_active_line(const gs_memory_t *mem, const char *label, const active_line * alp)

{

    dmlprintf5(mem, "[f]%s "PRI_INTPTR"(%d): x_current=%f x_next=%f\n",

               label, (intptr_t)alp, alp->direction,

               fixed2float(alp->x_current), fixed2float(alp->x_next));

    dmlprintf5(mem, "    start=(%f,%f) pt_end="PRI_INTPTR"(%f,%f)\n",

               fixed2float(alp->start.x), fixed2float(alp->start.y),

               (intptr_t)alp->pseg,

               fixed2float(alp->end.x), fixed2float(alp->end.y));

    dmlprintf2(mem, "    prev="PRI_INTPTR" next="PRI_INTPTR"\n",

               (intptr_t)alp->prev, (intptr_t)alp->next);

}

static void

print_line_list(const gs_memory_t *mem, const active_line * flp)

{

    const active_line *lp;

    for (lp = flp; lp != 0; lp = lp->next) {

        fixed xc = lp->x_current, xn = lp->x_next;

        dmlprintf3(mem, "[f]"PRI_INTPTR"(%d): x_current/next=%g",

                  (intptr_t)lp, lp->direction,

                  fixed2float(xc));

        if (xn != xc)

            dmprintf1(mem, "/%g", fixed2float(xn));

        dmputc(mem, '\n');

    }

}

static inline void

print_al(const gs_memory_t *mem, const char *label, const active_line * alp)

{

    if (gs_debug_c('F'))

        print_active_line(mem, label, alp);

}

#else

#define print_al(mem,label,alp) DO_NOTHING

#endif

static inline bool

is_spotan_device(gx_device * dev)

{

    /* Use open_device procedure to identify the type of the device

     * instead of the standard gs_object_type() because gs_cpath_accum_device

     * is allocated on the stack i.e. has no block header with a descriptor

     * but has dev->memory set like a heap-allocated device.

     */

    return dev_proc(dev, open_device) == san_open;

}

/* Forward declarations */

static void free_line_list(line_list *);

static int add_y_list(gx_path *, line_list *);

static int add_y_line_aux(const segment * prev_lp, const segment * lp,

            const gs_fixed_point *curr, const gs_fixed_point *prev, int dir, line_list *ll);

static void insert_x_new(active_line *, line_list *);

static int  end_x_line(active_line *, const line_list *, bool);

static int step_al(active_line *alp, bool move_iterator);

#define FILL_LOOP_PROC(proc) int proc(line_list *, fixed band_mask)

static FILL_LOOP_PROC(spot_into_scan_lines);

static FILL_LOOP_PROC(spot_into_trapezoids);

/*

 * This is the general path filling algorithm.

 * It uses the center-of-pixel rule for filling

 * We can implement Microsoft's upper-left-corner-of-pixel rule

 * by subtracting (0.5, 0.5) from all the coordinates in the path.

 *

 * The adjust parameters are a hack for keeping regions

 * from coming out too faint: they specify an amount by which to expand

 * the sides of every filled region.

 * Setting adjust = fixed_half is supposed to produce the effect of Adobe's

 * any-part-of-pixel rule, but it doesn't quite, because of the

 * closed/open interval rule for regions.  We detect this as a special case

 * and do the slightly ugly things necessary to make it work.

 */

/* Initialize the line list for a path. */

static inline void

init_line_list(line_list *ll, gs_memory_t * mem)

{

    ll->memory = mem;

    ll->active_area = 0;

    ll->next_active = ll->local_active;

    ll->limit = ll->next_active + MAX_LOCAL_ACTIVE;

    ll->close_count = 0;

    ll->y_list = 0;

    ll->y_line = 0;

    ll->h_list0 = ll->h_list1 = 0;

    ll->x_head.prev = NULL;

    /* Bug 695234: Initialise the following to pacify valgrind */

    ll->x_head.start.x = 0;

    ll->x_head.start.y = 0;

    ll->x_head.end.x = 0;

    ll->x_head.end.y = 0;

    /* Do not initialize ll->bbox_left, ll->bbox_width - they were set in advance. */

    INCR(fill);

}

/* Unlink any line_close segments added temporarily. */

static inline void

unclose_path(gx_path * ppath, int count)

{

    subpath *psub;

    for (psub = ppath->first_subpath; count != 0;

         psub = (subpath *) psub->last->next

        )

        if (psub->last == (segment *) & psub->closer) {

            segment *prev = psub->closer.prev, *next = psub->closer.next;

            prev->next = next;

            if (next)

                next->prev = prev;

            psub->last = prev;

            count--;

        }

}

/*

 * The general fill  path algorithm.

 */

static int

gx_general_fill_path(gx_device * pdev, const gs_gstate * pgs,

                     gx_path * ppath, const gx_fill_params * params,

                 const gx_device_color * pdevc, const gx_clip_path * pcpath)

{

    gs_fixed_point adjust;

    gs_logical_operation_t lop = pgs->log_op;

    gs_fixed_rect ibox, bbox, sbox;

    gx_device_clip cdev;

    gx_device *dev = pdev;

    gx_device *save_dev = dev;

    gx_path ffpath;

    gx_path *pfpath;

    int code;

    int max_fill_band = dev->max_fill_band;

#define NO_BAND_MASK ((fixed)(-1) << (sizeof(fixed) * 8 - 1))

    const bool is_character = params->adjust.x == -1; /* See gxgstate.h */

    bool fill_by_trapezoids;

    bool big_path = ppath->subpath_count > 50;

    fill_options fo;

    line_list lst;

    int clipping = 0;

    int scanconverter;

    *(const fill_options **)&lst.fo = &fo; /* break 'const'. */

    /*

     * Compute the bounding box before we flatten the path.

     * This can save a lot of time if the path has curves.

     * If the path is neither fully within nor fully outside

     * the quick-check boxes, we could recompute the bounding box

     * and make the checks again after flattening the path,

     * but right now we don't bother.

     */

    gx_path_bbox(ppath, &ibox);

    if (is_character)

        adjust.x = adjust.y = 0;

    else

        adjust = params->adjust;

    lst.contour_count = 0;

    lst.windings = NULL;

    lst.bbox_left = fixed2int(ibox.p.x - adjust.x - fixed_epsilon);

    lst.bbox_width = fixed2int(fixed_ceiling(ibox.q.x + adjust.x)) - lst.bbox_left;

    /* Check the bounding boxes. */

    if_debug6m('f', pdev->memory, "[f]adjust=%g,%g bbox=(%g,%g),(%g,%g)\n",

               fixed2float(adjust.x), fixed2float(adjust.y),

               fixed2float(ibox.p.x), fixed2float(ibox.p.y),

               fixed2float(ibox.q.x), fixed2float(ibox.q.y));

    if (pcpath)

        gx_cpath_inner_box(pcpath, &bbox);

    else

        (*dev_proc(dev, get_clipping_box)) (dev, &bbox);

    if (!rect_within(ibox, bbox)) {

        /*

         * Intersect the path box and the clip bounding box.

         * If the intersection is empty, this fill is a no-op.

         */

        if (pcpath)

            gx_cpath_outer_box(pcpath, &bbox);

        if_debug4m('f', pdev->memory, "   outer_box=(%g,%g),(%g,%g)\n",

                   fixed2float(bbox.p.x), fixed2float(bbox.p.y),

                   fixed2float(bbox.q.x), fixed2float(bbox.q.y));

        rect_intersect(ibox, bbox);

        if (ibox.p.x - adjust.x >= ibox.q.x + adjust.x ||

            ibox.p.y - adjust.y >= ibox.q.y + adjust.y

            ) {                 /* Intersection of boxes is empty! */

            return 0;

        }

        /*

         * The path is neither entirely inside the inner clip box

         * nor entirely outside the outer clip box.

         * If we had to flatten the path, this is where we would

         * recompute its bbox and make the tests again,

         * but we don't bother right now.

         *

         * If there is a clipping path, set up a clipping device.

         */

        if (pcpath) {

            dev = (gx_device *) & cdev;

            gx_make_clip_device_on_stack(&cdev, pcpath, save_dev);

            cdev.max_fill_band = save_dev->max_fill_band;

            clipping = 1;

        }

    }

    /*

     * Compute the proper adjustment values.

     * To get the effect of the any-part-of-pixel rule,

     * we may have to tweak them slightly.

     * NOTE: We changed the adjust_right/above value from 0.5+epsilon

     * to 0.5 in release 5.01; even though this does the right thing

     * in every case we could imagine, we aren't confident that it's

     * correct.  (The old values were definitely incorrect, since they

     * caused 1-pixel-wide/high objects to color 2 pixels even if

     * they fell exactly on pixel boundaries.)

     */

    if (adjust.x == fixed_half)

        fo.adjust_left = fixed_half - fixed_epsilon,

            fo.adjust_right = fixed_half /* + fixed_epsilon */ ;        /* see above */

    else

        fo.adjust_left = fo.adjust_right = adjust.x;

    if (adjust.y == fixed_half)

        fo.adjust_below = fixed_half - fixed_epsilon,

            fo.adjust_above = fixed_half /* + fixed_epsilon */ ;        /* see above */

    else

        fo.adjust_below = fo.adjust_above = adjust.y;

    sbox.p.x = ibox.p.x - adjust.x;

    sbox.p.y = ibox.p.y - adjust.y;

    sbox.q.x = ibox.q.x + adjust.x;

    sbox.q.y = ibox.q.y + adjust.y;

    fo.pdevc = pdevc;

    fo.lop = lop;

    fo.fixed_flat = float2fixed(params->flatness);

    fo.ymin = ibox.p.y;

    fo.ymax = ibox.q.y;

    fo.dev = dev;

    fo.pbox = &sbox;

    fo.rule = params->rule;

    fo.is_spotan = is_spotan_device(dev);

    fo.fill_direct = color_writes_pure(pdevc, lop);

    fo.fill_rect = (fo.fill_direct ? dev_proc(dev, fill_rectangle) : NULL);

    fo.fill_trap = dev_proc(dev, fill_trapezoid);

    /*

     * We have a choice of two different filling algorithms:

     * scan-line-based and trapezoid-based.  They compare as follows:

     *

     *      Scan    Trap

     *      ----    ----

     *       skip   +draw   0-height horizontal lines

     *       slow   +fast   rectangles

     *      +fast    slow   curves

     *      +yes     no     write pixels at most once when adjust != 0

     *

     * Normally we use the scan line algorithm for characters, where curve

     * speed is important, and for non-idempotent RasterOps, where double

     * pixel writing must be avoided, and the trapezoid algorithm otherwise.

     * However, we always use the trapezoid algorithm for rectangles.

     */

    fill_by_trapezoids = (!gx_path_has_curves(ppath) ||

                          params->flatness >= 1.0 || fo.is_spotan);

    if (fill_by_trapezoids && !fo.is_spotan && !lop_is_idempotent(lop)) {

        gs_fixed_rect rbox;

        if (gx_path_is_rectangular(ppath, &rbox)) {

            int x0 = fixed2int_pixround(rbox.p.x - fo.adjust_left);

            int y0 = fixed2int_pixround(rbox.p.y - fo.adjust_below);

            int x1 = fixed2int_pixround(rbox.q.x + fo.adjust_right);

            int y1 = fixed2int_pixround(rbox.q.y + fo.adjust_above);

            code = gx_fill_rectangle_device_rop(x0, y0, x1 - x0, y1 - y0,

                                                pdevc, dev, lop);

            goto exit;

        }

        if (fo.adjust_left | fo.adjust_right | fo.adjust_below | fo.adjust_above)

            fill_by_trapezoids = false; /* avoid double writing pixels */

    }

    if (!fo.is_spotan && ((scanconverter = gs_getscanconverter(pdev->memory)) >= GS_SCANCONVERTER_EDGEBUFFER ||

                          (scanconverter == GS_SCANCONVERTER_DEFAULT && GS_SCANCONVERTER_DEFAULT_IS_EDGEBUFFER))) {

        gx_scan_converter_t *sc;

        /* If we have a request for accurate curves, make sure we exactly

         * match what we'd get for stroking. */

        if (!big_path && pgs->accurate_curves && gx_path_has_curves(ppath))

        {

            gx_path_init_local(&ffpath, ppath->memory);

            code = gx_path_copy_reducing(ppath, &ffpath, fo.fixed_flat, NULL,

                                         pco_small_curves | pco_accurate);

            if (code < 0)

                goto exit;

            ppath = &ffpath;

        }

        if (fill_by_trapezoids && !lop_is_idempotent(lop))

            fill_by_trapezoids = 0;

        if (!fill_by_trapezoids)

        {

            if (adjust.x == 0 && adjust.y == 0)

                sc = &gx_scan_converter;

            else

                sc = &gx_scan_converter_app;

        } else {

            if (adjust.x == 0 && adjust.y == 0)

                sc = &gx_scan_converter_tr;

            else

                sc = &gx_scan_converter_tr_app;

        }

        code = gx_scan_convert_and_fill(sc,

                                        dev,

                                        ppath,

                                        &ibox,

                                        fo.fixed_flat,

                                        params->rule,

                                        pdevc,

                                       (!fill_by_trapezoids && fo.fill_direct) ? -1 : (int)pgs->log_op);

        if (ppath == &ffpath)

            gx_path_free(ppath, "gx_general_fill_path");

        goto exit;

    }

    gx_path_init_local(&ffpath, ppath->memory);

    if (!big_path && !gx_path_has_curves(ppath))        /* don't need to flatten */

        pfpath = ppath;

    else if (is_spotan_device(dev))

        pfpath = ppath;

    else if (!big_path && !pgs->accurate_curves && gx_path__check_curves(ppath, pco_small_curves, fo.fixed_flat))

        pfpath = ppath;

    else {

        code = gx_path_copy_reducing(ppath, &ffpath, fo.fixed_flat, NULL,

                                     pco_small_curves | (pgs->accurate_curves ? pco_accurate : 0));

        if (code < 0)

            goto exit;

        pfpath = &ffpath;

        if (big_path) {

            code = gx_path_merge_contacting_contours(pfpath);

            if (code < 0)

                goto exit;

        }

    }

    fo.fill_by_trapezoids = fill_by_trapezoids;

    /* Initialize the active line list. */

    init_line_list(&lst, ppath->memory);

    if ((code = add_y_list(pfpath, &lst)) < 0)

        goto nope;

    {

        FILL_LOOP_PROC((*fill_loop));

        /* Some short-sighted compilers won't allow a conditional here.... */

        if (fill_by_trapezoids)

            fill_loop = spot_into_trapezoids;

        else

            fill_loop = spot_into_scan_lines;

        if (gs_currentcpsimode(pgs->memory) && is_character) {

            if (lst.contour_count > countof(lst.local_windings)) {

                lst.windings = (int *)gs_alloc_byte_array(pdev->memory, lst.contour_count,

                                sizeof(int), "gx_general_fill_path");

                if (lst.windings == NULL)

                    return_error(gs_error_VMerror);

            } else

                lst.windings = lst.local_windings;

            memset(lst.windings, 0, sizeof(lst.windings[0]) * lst.contour_count);

        }

        code = (*fill_loop)

            (&lst, (max_fill_band == 0 ? NO_BAND_MASK : int2fixed(-max_fill_band)));

        if (lst.windings != NULL && lst.windings != lst.local_windings)

            gs_free_object(pdev->memory, lst.windings, "gx_general_fill_path");

    }

  nope:if (lst.close_count != 0)

        unclose_path(pfpath, lst.close_count);

    free_line_list(&lst);

    if (pfpath != ppath)        /* had to flatten */

        gx_path_free(pfpath, "gx_general_fill_path");

#ifdef COLLECT_STATS_FILL

    if (gs_debug_c('f')) {

        dmlputs(ppath->memory,

                "[f]  # alloc    up  down horiz step slowx  iter  find  band bstep bfill\n");

        dmlprintf5(ppath->memory, " %5ld %5ld %5ld %5ld %5ld",

                   stats_fill.fill, stats_fill.fill_alloc,

                   stats_fill.y_up, stats_fill.y_down,

                   stats_fill.horiz);

        dmlprintf4(ppath->memory, " %5ld %5ld %5ld %5ld",

                   stats_fill.x_step, stats_fill.slow_x,

                   stats_fill.iter, stats_fill.find_y);

        dmlprintf3(ppath->memory, " %5ld %5ld %5ld\n",

                   stats_fill.band, stats_fill.band_step,

                   stats_fill.band_fill);

        dmlputs(ppath->memory,

                "[f]    afill slant shall sfill mqcrs order slowo\n");

        dmlprintf7(ppath->memory, "       %5ld %5ld %5ld %5ld %5ld %5ld %5ld\n",

                   stats_fill.afill, stats_fill.slant,

                   stats_fill.slant_shallow, stats_fill.sfill,

                   stats_fill.mq_cross, stats_fill.order,

                   stats_fill.slow_order);

    }

#endif

exit:

    if (clipping)

        gx_destroy_clip_device_on_stack(&cdev);

    return code;

}

static int

pass_shading_area_through_clip_path_device(gx_device * pdev, const gs_gstate * pgs,

                     gx_path * ppath, const gx_fill_params * params,

                 const gx_device_color * pdevc, const gx_clip_path * pcpath)

{

    if (pdevc == NULL) {

        gx_device_clip *cdev = (gx_device_clip *)pdev;

        return dev_proc(cdev->target, fill_path)(cdev->target, pgs, ppath, params, pdevc, pcpath);

    }

    /* We know that tha clip path device implements fill_path with default proc. */

    return gx_default_fill_path(pdev, pgs, ppath, params, pdevc, pcpath);

}

/*  Optimization for shading and halftone fill :

    The general filling algorithm subdivides the fill region into

    trapezoid or rectangle subregions and then paints each subregion

    with given color. If the color is complex, it also needs to be subdivided

    into constant color rectangles. In the worst case it gives

    a multiple of numbers of rectangles, which may be too slow.

    A faster processing may be obtained with installing a clipper

    device with the filling path, and then render the complex color

    through it. The speeding up happens due to the clipper device

    is optimised for fast scans through neighbour clipping rectangles.

*/

int

gx_default_fill_path_shading_or_pattern(gx_device * pdev, const gs_gstate * pgs,

                                        gx_path * ppath, const gx_fill_params * params,

                                        const gx_device_color * pdevc, const gx_clip_path * pcpath)

{

    int code = 0, clipping = 0;

    /*  We need a single clipping path here, because shadings and

        halftones don't take 2 paths. Compute the clipping path intersection.

    */

    gx_clip_path cpath_intersection, cpath_with_shading_bbox;

    const gx_clip_path *pcpath1, *pcpath2;

    gs_gstate *pgs_noconst = (gs_gstate *)pgs; /* Break const. */

    if (ppath != NULL) {

        code = gx_cpath_init_local_shared_nested(&cpath_intersection, pcpath, pdev->memory, 1);

        if (code < 0)

            return code;

        if (pcpath == NULL) {

            gs_fixed_rect clip_box1;

            (*dev_proc(pdev, get_clipping_box)) (pdev, &clip_box1);

            code = gx_cpath_from_rectangle(&cpath_intersection, &clip_box1);

        }

        if (code >= 0)

            code = gx_cpath_intersect_with_params(&cpath_intersection, ppath, params->rule,

                                                  pgs_noconst, params);

        pcpath1 = &cpath_intersection;

    } else

        pcpath1 = pcpath;

    pcpath2 = pcpath1;

    if (code >= 0)

        code = gx_dc_pattern2_clip_with_bbox(pdevc, pdev, &cpath_with_shading_bbox, &pcpath1);

    /* Do fill : */

    if (code >= 0) {

        gs_fixed_rect clip_box;

        gs_int_rect cb;

        const gx_rop_source_t *rs = NULL;

        gx_device *dev;

        gx_device_clip cdev;

        gx_cpath_outer_box(pcpath1, &clip_box);

        cb.p.x = fixed2int_pixround(clip_box.p.x);

        cb.p.y = fixed2int_pixround(clip_box.p.y);

        cb.q.x = fixed2int_pixround(clip_box.q.x);

        cb.q.y = fixed2int_pixround(clip_box.q.y);

        if (gx_dc_is_pattern2_color(pdevc) &&

                (*dev_proc(pdev, dev_spec_op))(pdev,

                         gxdso_pattern_handles_clip_path, NULL, 0) > 0) {

            /* A special interaction with clist writer device :

               pass the intersected clipping path. It uses an unusual call to

               fill_path with NULL device color. */

            code = (*dev_proc(pdev, fill_path))(pdev, pgs, ppath, params, NULL, pcpath1);

            dev = pdev;

        } else {

            gx_make_clip_device_on_stack(&cdev, pcpath1, pdev);

            dev = (gx_device *)&cdev;

            if ((*dev_proc(pdev, dev_spec_op))(pdev,

                        gxdso_pattern_shading_area, NULL, 0) > 0)

                set_dev_proc(&cdev, fill_path, pass_shading_area_through_clip_path_device);

            code = 0;

            clipping = 1;

        }

        if (code >= 0) {

            /* Check clip rectangle covers an actual area */

            if (cb.p.x != cb.q.x && cb.p.y != cb.q.y)

                code = pdevc->type->fill_rectangle(pdevc,

                        cb.p.x, cb.p.y, cb.q.x - cb.p.x, cb.q.y - cb.p.y,

                        dev, pgs->log_op, rs);

        }

        if (clipping)

            gx_destroy_clip_device_on_stack(&cdev);

    }

    if (ppath != NULL)

        gx_cpath_free(&cpath_intersection, "shading_fill_cpath_intersection");

    if (pcpath1 != pcpath2)

        gx_cpath_free(&cpath_with_shading_bbox, "shading_fill_cpath_intersection");

    return code;

}

/*

 * Fill a path.  This is the default implementation of the driver

 * fill_path procedure.

 */

int

gx_default_fill_path(gx_device * pdev, const gs_gstate * pgs,

                     gx_path * ppath, const gx_fill_params * params,

                 const gx_device_color * pdevc, const gx_clip_path * pcpath)

{

    if (gx_dc_is_pattern2_color(pdevc) ||

        pdevc->type == &gx_dc_type_data_ht_colored ||

        (gx_dc_is_pattern1_color(pdevc) &&

         gx_pattern_tile_is_clist(pdevc->colors.pattern.p_tile)))

        return gx_default_fill_path_shading_or_pattern(pdev, pgs, ppath, params, pdevc, pcpath);

    else

        return gx_general_fill_path(pdev, pgs, ppath, params, pdevc, pcpath);

}

int

gx_default_lock_pattern(gx_device *pdev,

                        gs_gstate *pgs,

                        gs_id      pattern_id,

                        int        lock)

{

    return gx_pattern_cache_entry_set_lock(pgs, pattern_id, lock);

}

/*

 * Fill/Stroke a path.  This is the default implementation of the driver

 * fill_path procedure.

 */

int

gx_default_fill_stroke_path(gx_device * pdev, const gs_gstate * pgs,

                            gx_path * ppath,

                            const gx_fill_params * params_fill,

                            const gx_device_color * pdevc_fill,

                            const gx_stroke_params * params_stroke,

                            const gx_device_color * pdevc_stroke,

                            const gx_clip_path * pcpath)

{

    int code = dev_proc(pdev, fill_path)(pdev, pgs, ppath, params_fill, pdevc_fill, pcpath);

    if (code < 0)

        return code;

    /* Swap colors to make sure the pgs colorspace is correct for stroke */

    gs_swapcolors_quick(pgs);

    code = dev_proc(pdev, stroke_path)(pdev, pgs, ppath, params_stroke, pdevc_stroke, pcpath);

    gs_swapcolors_quick(pgs);

    return code;

}

/* Free the line list. */

static void

free_line_list(line_list *ll)

{

    /* Free any individually allocated active_lines. */

    gs_memory_t *mem = ll->memory;

    active_line *alp;

    while ((alp = ll->active_area) != 0) {

        active_line *next = alp->alloc_next;

        gs_free_object(mem, alp, "active line");

        ll->active_area = next;

    }

}

static inline active_line *

make_al(line_list *ll)

{

    active_line *alp = ll->next_active;

    if (alp == ll->limit) {     /* Allocate separately */

        alp = gs_alloc_struct(ll->memory, active_line,

                              &st_active_line, "active line");

        if (alp == 0)

            return NULL;

        alp->alloc_next = ll->active_area;

        ll->active_area = alp;

        INCR(fill_alloc);

    } else

        ll->next_active++;

    alp->contour_count = ll->contour_count;

    return alp;

}

/* Insert the new line in the Y ordering */

static void

insert_y_line(line_list *ll, active_line *alp)

{

    active_line *yp = ll->y_line;

    active_line *nyp;

    fixed y_start = alp->start.y;

    if (yp == 0) {

        alp->next = alp->prev = 0;

        ll->y_list = alp;

    } else if (y_start >= yp->start.y) {        /* Insert the new line after y_line */

        while (INCR_EXPR(y_up),

               ((nyp = yp->next) != NULL &&

                y_start > nyp->start.y)

            )

            yp = nyp;

        alp->next = nyp;

        alp->prev = yp;

        yp->next = alp;

        if (nyp)

            nyp->prev = alp;

    } else {            /* Insert the new line before y_line */

        while (INCR_EXPR(y_down),

               ((nyp = yp->prev) != NULL &&

                y_start < nyp->start.y)

            )

            yp = nyp;

        alp->prev = nyp;

        alp->next = yp;

        yp->prev = alp;

        if (nyp)

            nyp->next = alp;

        else

            ll->y_list = alp;

    }

    ll->y_line = alp;

    print_al(ll->memory, "add ", alp);

}

typedef struct contour_cursor_s {

    segment *prev, *pseg, *pfirst, *plast;

    gx_flattened_iterator fi;

    bool more_flattened;

    bool first_flattened;

    int dir;

    bool monotonic_y;

    bool monotonic_x;

    bool crossing;

} contour_cursor;

static inline int

compute_dir(const fill_options *fo, fixed y0, fixed y1)

{

    if (max(y0, y1) < fo->ymin)

        return DIR_OUT_OF_Y_RANGE;

    if (min(y0, y1) > fo->ymax)

        return DIR_OUT_OF_Y_RANGE;

    return (y0 < y1 ? DIR_UP :

            y0 > y1 ? DIR_DOWN : DIR_HORIZONTAL);

}

static inline int

add_y_curve_part(line_list *ll, segment *s0, segment *s1, int dir,

    gx_flattened_iterator *fi, bool more1, bool step_back, bool monotonic_x)

{

    active_line *alp = make_al(ll);

    int code;

    if (alp == NULL)

        return_error(gs_error_VMerror);

    alp->pseg = (dir == DIR_UP ? s1 : s0);

    alp->direction = dir;

    alp->fi = *fi;

    alp->more_flattened = more1;

    if (dir != DIR_UP && more1)

        gx_flattened_iterator__switch_to_backscan(&alp->fi, more1);

    if (step_back) {

        do {

            code = gx_flattened_iterator__prev(&alp->fi);

            if (code < 0)

                return code;

            alp->more_flattened = code;

            if (compute_dir(ll->fo, alp->fi.ly0, alp->fi.ly1) != 2)

                break;

        } while (alp->more_flattened);

    }

    code = step_al(alp, false);

    if (code < 0)

        return code;

    alp->monotonic_y = false;

    alp->monotonic_x = monotonic_x;

    insert_y_line(ll, alp);

    return 0;

}

static inline int

add_y_line(const segment * prev_lp, const segment * lp, int dir, line_list *ll)

{

    return add_y_line_aux(prev_lp, lp, &lp->pt, &prev_lp->pt, dir, ll);

}

static inline int

start_al_pair(line_list *ll, contour_cursor *q, contour_cursor *p)

{

    int code;

    if (q->monotonic_y)

        code = add_y_line(q->prev, q->pseg, DIR_DOWN, ll);

    else

        code = add_y_curve_part(ll, q->prev, q->pseg, DIR_DOWN, &q->fi,

                            !q->first_flattened, false, q->monotonic_x);

    if (code < 0)

        return code;

    if (p->monotonic_y)

        code = add_y_line(p->prev, p->pseg, DIR_UP, ll);

    else

        code = add_y_curve_part(ll, p->prev, p->pseg, DIR_UP, &p->fi,

                            p->more_flattened, false, p->monotonic_x);

    return code;

}

/* Start active lines from a minimum of a possibly non-monotonic curve. */

static int

start_al_pair_from_min(line_list *ll, contour_cursor *q)

{

    int dir, code;

    const fill_options * const fo = ll->fo;

    /* q stands at the first segment, which isn't last. */

    do {

        code = gx_flattened_iterator__next(&q->fi);

        if (code < 0)

            return code;

        q->more_flattened = code;

        dir = compute_dir(fo, q->fi.ly0, q->fi.ly1);

        if (q->fi.ly0 > fo->ymax && ll->y_break > q->fi.y0)

            ll->y_break = q->fi.ly0;

        if (q->fi.ly1 > fo->ymax && ll->y_break > q->fi.ly1)

            ll->y_break = q->fi.ly1;

        if (q->fi.ly0 >= fo->ymin) {

            if (dir == DIR_UP && ll->main_dir == DIR_DOWN) {

                code = add_y_curve_part(ll, q->prev, q->pseg, DIR_DOWN, &q->fi,

                                        true, true, q->monotonic_x);

                if (code < 0)

                    return code;

                code = add_y_curve_part(ll, q->prev, q->pseg, DIR_UP, &q->fi,

                                        q->more_flattened, false, q->monotonic_x);

                if (code < 0)

                    return code;

            } else if (q->fi.ly1 < fo->ymin) {

                code = add_y_curve_part(ll, q->prev, q->pseg, DIR_DOWN, &q->fi,

                                        true, false, q->monotonic_x);

                if (code < 0)

                    return code;

            }

        } else if (q->fi.ly1 >= fo->ymin) {

            code = add_y_curve_part(ll, q->prev, q->pseg, DIR_UP, &q->fi,

                                    q->more_flattened, false, q->monotonic_x);

            if (code < 0)

                return code;

        }

        q->first_flattened = false;

        q->dir = dir;

        if (dir == DIR_DOWN || dir == DIR_UP)

            ll->main_dir = dir;

    } while(q->more_flattened);

    /* q stands at the last segment. */

    return 0;

    /* note : it doesn't depend on the number of curve minimums,

       which may vary due to arithmetic errors. */

}

static inline int

init_contour_cursor(const fill_options * const fo, contour_cursor *q)

{

    if (q->pseg->type == s_curve) {

        curve_segment *s = (curve_segment *)q->pseg;

        fixed ymin = min(min(q->prev->pt.y, s->p1.y), min(s->p2.y, s->pt.y));

        fixed ymax = max(max(q->prev->pt.y, s->p1.y), max(s->p2.y, s->pt.y));

        bool in_band = ymin <= fo->ymax && ymax >= fo->ymin;

        q->crossing = ymin < fo->ymin && ymax >= fo->ymin;

        q->monotonic_y = !in_band ||

            (!q->crossing &&

            ((q->prev->pt.y <= s->p1.y && s->p1.y <= s->p2.y && s->p2.y <= s->pt.y) ||

             (q->prev->pt.y >= s->p1.y && s->p1.y >= s->p2.y && s->p2.y >= s->pt.y)));

        q->monotonic_x =

            ((q->prev->pt.x <= s->p1.x && s->p1.x <= s->p2.x && s->p2.x <= s->pt.x) ||

             (q->prev->pt.x >= s->p1.x && s->p1.x >= s->p2.x && s->p2.x >= s->pt.x));

    } else

        q->monotonic_y = true;

    if (!q->monotonic_y) {

        curve_segment *s = (curve_segment *)q->pseg;

        int k = gx_curve_log2_samples(q->prev->pt.x, q->prev->pt.y, s, fo->fixed_flat);

        if (!gx_flattened_iterator__init(&q->fi, q->prev->pt.x, q->prev->pt.y, s, k))

            return_error(gs_error_rangecheck);

    } else {

        q->dir = compute_dir(fo, q->prev->pt.y, q->pseg->pt.y);

        gx_flattened_iterator__init_line(&q->fi,

            q->prev->pt.x, q->prev->pt.y, q->pseg->pt.x, q->pseg->pt.y); /* fake for curves. */

    }

    q->first_flattened = true;

    return 0;

}

static int