/* Copyright (C) 2001-2022 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.,  1305 Grant Avenue - Suite 200, Novato,

   CA 94945, U.S.A., +1(415)492-9861, for further information.

*/

/* Path drawing procedures for pdfwrite driver */

#include "math_.h"

#include "memory_.h"

#include "gx.h"

#include "gxdevice.h"

#include "gxfixed.h"

#include "gxgstate.h"

#include "gxpaint.h"

#include "gxcoord.h"

#include "gxdevmem.h"

#include "gxcolor2.h"

#include "gxhldevc.h"

#include "gsstate.h"

#include "gxstate.h"

#include "gserrors.h"

#include "gsptype2.h"

#include "gsshade.h"

#include "gzpath.h"

#include "gzcpath.h"

#include "gdevpdfx.h"

#include "gdevpdfg.h"

#include "gdevpdfo.h"

#include "gsutil.h"

#include "gdevpdtf.h"

#include "gdevpdts.h"

#include "gxdevsop.h"

/* ---------------- Drawing ---------------- */

/* Fill a rectangle. */

int

gdev_pdf_fill_rectangle(gx_device * dev, int x, int y, int w, int h,

                        gx_color_index color)

{

    gx_device_pdf *pdev = (gx_device_pdf *) dev;

    int code;

    if (pdev->Eps2Write) {

        float x0, y0, x1, y1;

        gs_rect *Box;

        if (!pdev->accumulating_charproc) {

            Box = &pdev->BBox;

            x0 = x / (pdev->HWResolution[0] / 72.0);

            y0 = y / (pdev->HWResolution[1] / 72.0);

            x1 = x0 + (w / (pdev->HWResolution[0] / 72.0));

            y1 = y0 + (h / (pdev->HWResolution[1] / 72.0));

        }

        else {

            Box = &pdev->charproc_BBox;

            x0 = (float)x / 100;

            y0 = (float)y / 100;

            x1 = x0 + (w / 100);

            y1 = y0 + (h / 100);

        }

        if (Box->p.x > x0)

            Box->p.x = x0;

        if (Box->p.y > y0)

            Box->p.y = y0;

        if (Box->q.x < x1)

            Box->q.x = x1;

        if (Box->q.y < y1)

            Box->q.y = y1;

        if (pdev->AccumulatingBBox)

            return 0;

    }

    code = pdf_open_page(pdev, PDF_IN_STREAM);

    if (code < 0)

        return code;

    /* Make sure we aren't being clipped. */

    code = pdf_put_clip_path(pdev, NULL);

    if (code < 0)

        return code;

    pdf_set_pure_color(pdev, color, &pdev->saved_fill_color,

                       &pdev->fill_used_process_color,

                       &psdf_set_fill_color_commands);

    if (!pdev->HaveStrokeColor)

        pdev->saved_stroke_color = pdev->saved_fill_color;

    pprintd4(pdev->strm, "%d %d %d %d re f\n", x, y, w, h);

    return 0;

}

/* ---------------- Path drawing ---------------- */

/* ------ Vector device implementation ------ */

static int

pdf_setlinewidth(gx_device_vector * vdev, double width)

{

    /* Acrobat Reader doesn't accept negative line widths. */

    return psdf_setlinewidth(vdev, fabs(width));

}

static int

pdf_can_handle_hl_color(gx_device_vector * vdev, const gs_gstate * pgs,

                 const gx_drawing_color * pdc)

{

    return pgs != NULL;

}

static int

pdf_setfillcolor(gx_device_vector * vdev, const gs_gstate * pgs,

                 const gx_drawing_color * pdc)

{

    gx_device_pdf *const pdev = (gx_device_pdf *)vdev;

    bool hl_color = (*vdev_proc(vdev, can_handle_hl_color)) (vdev, pgs, pdc);

    const gs_gstate *pgs_for_hl_color = (hl_color ? pgs : NULL);

    if (!pdev->HaveStrokeColor) {

        /* opdfread.ps assumes same color for stroking and non-stroking operations. */

        int code = pdf_set_drawing_color(pdev, pgs_for_hl_color, pdc, &pdev->saved_stroke_color,

                                    &pdev->stroke_used_process_color,

                                    &psdf_set_stroke_color_commands);

        if (code < 0)

            return code;

    }

    return pdf_set_drawing_color(pdev, pgs_for_hl_color, pdc, &pdev->saved_fill_color,

                                 &pdev->fill_used_process_color,

                                 &psdf_set_fill_color_commands);

}

static int

pdf_setstrokecolor(gx_device_vector * vdev, const gs_gstate * pgs,

                   const gx_drawing_color * pdc)

{

    gx_device_pdf *const pdev = (gx_device_pdf *)vdev;

    bool hl_color = (*vdev_proc(vdev, can_handle_hl_color)) (vdev, pgs, pdc);

    const gs_gstate *pgs_for_hl_color = (hl_color ? pgs : NULL);

    if (!pdev->HaveStrokeColor) {

        /* opdfread.ps assumes same color for stroking and non-stroking operations. */

        int code = pdf_set_drawing_color(pdev, pgs_for_hl_color, pdc, &pdev->saved_fill_color,

                                 &pdev->fill_used_process_color,

                                 &psdf_set_fill_color_commands);

        if (code < 0)

            return code;

    }

    return pdf_set_drawing_color(pdev, pgs_for_hl_color, pdc, &pdev->saved_stroke_color,

                                 &pdev->stroke_used_process_color,

                                 &psdf_set_stroke_color_commands);

}

static int

pdf_dorect(gx_device_vector * vdev, fixed x0, fixed y0, fixed x1, fixed y1,

           gx_path_type_t type)

{

    gx_device_pdf *pdev = (gx_device_pdf *)vdev;

    fixed xmax = int2fixed(32766), ymax = int2fixed(32766);

    int bottom = (pdev->ResourcesBeforeUsage ? 1 : 0);

    fixed xmin = (pdev->sbstack_depth > bottom ? -xmax : 0);

    fixed ymin = (pdev->sbstack_depth > bottom ? -ymax : 0);

    /*

     * If we're doing a stroke operation, expand the checking box by the

     * stroke width.

     */

    if (type & gx_path_type_stroke) {

        double w = vdev->state.line_params.half_width;

        double xw = w * (fabs(vdev->state.ctm.xx) + fabs(vdev->state.ctm.yx));

        int d = float2fixed(xw) + fixed_1;

        xmin -= d;

        xmax += d;

        ymin -= d;

        ymax += d;

    }

    if (pdev->PDFA == 1) {

        /* Check values, and decide how to proceed based on PDFACompatibilitylevel */

        if (x0 < xmin || y0 < ymin || x1 - x0 > xmax || y1 - y0 >ymax) {

            switch(pdev->PDFACompatibilityPolicy) {

                case 0:

                    emprintf(pdev->memory,

                         "Required co-ordinate outside valid range for PDF/A-1, reverting to normal PDF output.\n");

                    pdev->AbortPDFAX = true;

                    pdev->PDFA = 0;

                    break;

                case 1:

                    emprintf(pdev->memory,

                         "Required co-ordinate outside valid range for PDF/A-1, clamping to valid range, output may be incorrect.\n");

                    /*

                     * Clamp coordinates to avoid tripping over Acrobat Reader's limit

                     * of 32K on user coordinate values, which was adopted by the PDF/A-1 spec.

                     */

                    if (x0 < xmin)

                        x0 = xmin;

                    if (y0 < ymin)

                        y0 = ymin;

                    /* We used to clamp x1 and y1 here, but actually, because this is a rectangle

                     * we don't need to do that, we need to clamp the *difference* between x0,x1

                     * and y0,y1 to keep it inside the Acrobat 4 or 5 limits.

                     */

                    if (x1 - x0 > xmax)

                        x1 = x0 + xmax;

                    if (y1 - y0 > ymax)

                        y1 = y0 + ymax;

                    break;

                default:

                case 2:

                    emprintf(pdev->memory,

                         "Required co-ordinate outside valid range for PDF/A-1, aborting.\n");

                    return_error(gs_error_limitcheck);

                    break;

            }

        }

    }

    return psdf_dorect(vdev, x0, y0, x1, y1, type);

}

static int

pdf_endpath(gx_device_vector * vdev, gx_path_type_t type)

{

    return 0;     /* always handled by caller */

}

const gx_device_vector_procs pdf_vector_procs = {

        /* Page management */

    NULL,

        /* Imager state */

    pdf_setlinewidth,

    psdf_setlinecap,

    psdf_setlinejoin,

    psdf_setmiterlimit,

    psdf_setdash,

    psdf_setflat,

    psdf_setlogop,

        /* Other state */

    pdf_can_handle_hl_color,

    pdf_setfillcolor,

    pdf_setstrokecolor,

        /* Paths */

    psdf_dopath,

    pdf_dorect,

    psdf_beginpath,

    psdf_moveto,

    psdf_lineto,

    psdf_curveto,

    psdf_closepath,

    pdf_endpath

};

/* ------ Utilities ------ */

/* Store a copy of clipping path. */

int

pdf_remember_clip_path(gx_device_pdf * pdev, const gx_clip_path * pcpath)

{

    int code = 0;

    /* Used for skipping redundant clip paths. SF bug #624168. */

    if (pdev->clip_path != 0) {

        gx_path_free(pdev->clip_path, "pdf clip path");

    }

    if (pcpath == 0) {

        pdev->clip_path = 0;

        return 0;

    }

    pdev->clip_path = gx_path_alloc(pdev->pdf_memory, "pdf clip path");

    if (pdev->clip_path == 0)

        return_error(gs_error_VMerror);

    code = gx_cpath_to_path((gx_clip_path *)pcpath, pdev->clip_path);

    if (code < 0)

        return code;

    /* gx_cpath_to_path above ends up going through gx_path_assign_preserve

     * which specifically states that the segments of the paths (in this case pcpath

     * and pdev->clip_path) must have been allocated with the same allocator.

     * If that's not true (eg pdfi running inside GS) then we need to 'unshare'

     * the path. Otherwise we mauy end up with pcpath being freed and discarded

     * while the pdfwrite devcie still thinks it has a pointer to it.

     */

    if (pcpath->path.memory != pdev->pdf_memory)

        code = gx_path_unshare(pdev->clip_path);

    return code;

}

/* Check if same clipping path. */

static int

pdf_is_same_clip_path(gx_device_pdf * pdev, const gx_clip_path * pcpath)

{

    /* Used for skipping redundant clip paths. SF bug #624168. */

    gs_cpath_enum cenum;

    gs_path_enum penum;

    gs_fixed_point vs0[3], vs1[3];

    int code, pe_op;

    if ((pdev->clip_path != 0) != (pcpath != 0))

        return 0;

    /* Both clip paths are empty, so the same */

    if (pdev->clip_path == 0)

        return 1;

    code = gx_path_enum_init(&penum, pdev->clip_path);

    if (code < 0)

        return code;

    code = gx_cpath_enum_init(&cenum, (gx_clip_path *)pcpath);

    if (code < 0)

        return code;

    /* This flags a warning in Coverity, uninitialised variable cenum.first_visit */

    /* This is because gx_cpath_enum_init doesn't initialise first_visit, but the */

    /* variable can be used in enum_next. However, this is not truly used this    */

    /* way. The enum_init sets the 'state' to 'scan', and the first thing that happens */

    /* in enum_next when state is 'scan' is to set first_visit. */

    while ((code = gx_cpath_enum_next(&cenum, vs0)) > 0) {

        pe_op = gx_path_enum_next(&penum, vs1);

        if (pe_op < 0)

            return pe_op;

        if (pe_op != code)

            return 0;

        switch (pe_op) {

            case gs_pe_curveto:

                if (vs0[1].x != vs1[1].x || vs0[1].y != vs1[1].y ||

                    vs0[2].x != vs1[2].x || vs0[2].y != vs1[2].y)

                    return 0;

                /* fall through */

            case gs_pe_moveto:

            case gs_pe_lineto:

            case gs_pe_gapto:

                if (vs0[0].x != vs1[0].x || vs0[0].y != vs1[0].y)

                    return 0;

        }

    }

    if (code < 0)

        return code;

    code = gx_path_enum_next(&penum, vs1);

    if (code < 0)

        return code;

    return (code == 0);

}

int

pdf_check_soft_mask(gx_device_pdf * pdev, gs_gstate * pgs)

{

    int code = 0;

    if (pgs && pdev->state.soft_mask_id != pgs->soft_mask_id) {

    /*

     * The contents must be open already, so the following will only exit

     * text or string context.

     */

    code = pdf_open_contents(pdev, PDF_IN_STREAM);

    if (code < 0)

        return code;

    if (pdev->vgstack_depth > pdev->vgstack_bottom) {

        code = pdf_restore_viewer_state(pdev, pdev->strm);

        if (code < 0)

            return code;

    }

    }

    return code;

}

/* Test whether we will need to put the clipping path. */

bool

pdf_must_put_clip_path(gx_device_pdf * pdev, const gx_clip_path * pcpath)

{

    if (pcpath == NULL) {

        if (pdev->clip_path_id == pdev->no_clip_path_id)

            return false;

    } else {

        if (pdev->clip_path_id == pcpath->id)

            return false;

        if (gx_cpath_includes_rectangle(pcpath, fixed_0, fixed_0,

                                        int2fixed(pdev->width),

                                        int2fixed(pdev->height)))

            if (pdev->clip_path_id == pdev->no_clip_path_id)

                return false;

        if (pdf_is_same_clip_path(pdev, pcpath) > 0) {

            pdev->clip_path_id = pcpath->id;

            return false;

        }

    }

    return true;

}

static int pdf_write_path(gx_device_pdf * pdev, gs_path_enum *cenum, gdev_vector_dopath_state_t *state, gx_path *path, int is_clip_enum,

                               gx_path_type_t type, const gs_matrix *pmat)

{

    int pe_op;

    gdev_vector_path_seg_record segments[5] = {0};

    int i, seg_index = 0, is_rect = 1, buffering = 0, initial_m = 0, segs = 0, code, matrix_optimisable = 0;

    gx_path_rectangular_type rtype = prt_none;

    gs_fixed_rect rbox;

    gx_device_vector *vdev = (gx_device_vector *)pdev;

    gs_fixed_point line_start = {0,0};

    gs_point p, q;

    bool do_close = (type & (gx_path_type_clip | gx_path_type_stroke | gx_path_type_always_close)) != 0;

    bool stored_moveto = false;

    gdev_vector_dopath_init(state, (gx_device_vector *)pdev,

                            type, pmat);

    if (is_clip_enum)

        code = gx_cpath_enum_init((gs_cpath_enum *)cenum, (gx_clip_path *)path);

    else {

        code = gx_path_enum_init(cenum, path);

        rtype = gx_path_is_rectangular(path, &rbox);

    }

    if (code < 0)

        return code;

    if((pmat == 0 || is_xxyy(pmat) || is_xyyx(pmat)) &&

        (state->scale_mat.xx == 1.0 && state->scale_mat.yy == 1.0 &&

        is_xxyy(&state->scale_mat) && is_fzero2(state->scale_mat.tx, state->scale_mat.ty))) {

         matrix_optimisable = 1;

         buffering = 1;

    }

    /*

     * if the path type is stroke, we only recognize closed

     * rectangles; otherwise, we recognize all rectangles.

     * Note that for stroking with a transformation, we can't use dorect,

     * which requires (untransformed) device coordinates.

     */

    if (rtype != prt_none &&

        (!(type & gx_path_type_stroke) || rtype == prt_closed) &&

          matrix_optimisable == 1)

    {

        gs_point p, q;

        gs_point_transform_inverse((double)rbox.p.x, (double)rbox.p.y,

                                   &state->scale_mat, &p);

        gs_point_transform_inverse((double)rbox.q.x, (double)rbox.q.y,

                                   &state->scale_mat, &q);

        code = vdev_proc(vdev, dorect)(vdev, (fixed)p.x, (fixed)p.y,

                                       (fixed)q.x, (fixed)q.y, type);

        if (code >= 0) {

            if (code == 0)

                return 1;

            return code;

        }

        /* If the dorect proc failed, use a general path. */

    }

    /* The following is an optimisation for space. If we see a closed subpath

     * which is a rectangle, emit it as a 're' instead of writing the individual

     * segments of the path. Note that 're' always applies the width before the

     * height when constructing the path, so we must take care to ensure that

     * we get the path direction correct. We do ths by detecting whether the path

     * moves first in the x or y directoin, if it moves in the y direction first,

     * we simply move one vertex round the rectangle, ie we start at point 2.

     */

    do {

        if (is_clip_enum)

            segments[seg_index].op = pe_op = gx_cpath_enum_next((gs_cpath_enum *)cenum, segments[seg_index].vs);

        else

            segments[seg_index].op = pe_op = gx_path_enum_next(cenum, segments[seg_index].vs);

        if (segs == 0 && pe_op > 0)

            segs = 1;

        switch(pe_op) {

            case gs_pe_moveto:

            case gs_pe_gapto:

                if (!buffering) {

                    stored_moveto = true;

                    line_start = segments[0].vs[0];

                    seg_index = -1;

                } else {

                    for (i=0;i<seg_index;i++) {

                        gdev_vector_dopath_segment(state, segments[i].op, segments[i].vs);

                    }

                    line_start = segments[seg_index].vs[0];

                    segments[0] = segments[seg_index];

                    seg_index = 0;

                    initial_m = 1;

                }

                break;

            case gs_pe_lineto:

                if (!buffering) {

                    if (stored_moveto) {

                        gdev_vector_dopath_segment(state, gs_pe_moveto, &line_start);

                        stored_moveto = false;

                    }

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

                        gdev_vector_dopath_segment(state, segments[i].op, segments[i].vs);

                    seg_index = -1;

                } else {

                    if (!initial_m) {

                        for (i=0;i<=seg_index;i++) {

                            gdev_vector_dopath_segment(state, segments[i].op, segments[i].vs);

                        }

                        buffering = 0;

                        seg_index = -1;

                    }

                    if (type & gx_path_type_optimize && seg_index > 0) {

                        if (segments[seg_index - 1].op == gs_pe_lineto) {

                            if (segments[seg_index].vs[0].x == segments[seg_index - 1].vs[0].x && segments[seg_index].vs[0].x == line_start.x) {

                                if (segments[seg_index - 1].vs[0].y > line_start.y && segments[seg_index].vs[0].y >= segments[seg_index - 1].vs[0].y) {

                                    segments[seg_index - 1].vs[0].y = segments[seg_index].vs[0].y;

                                    seg_index--;

                                } else {

                                    if (segments[seg_index - 1].vs[0].y < line_start.y && segments[seg_index].vs[0].y <= segments[seg_index - 1].vs[0].y) {

                                        segments[seg_index - 1].vs[0].y = segments[seg_index].vs[0].y;

                                        seg_index--;

                                    } else

                                        line_start = segments[seg_index - 1].vs[0];

                                }

                            } else {

                                if (segments[seg_index].vs[0].y == segments[seg_index - 1].vs[0].y && segments[seg_index].vs[0].y == line_start.y) {

                                    if (segments[seg_index - 1].vs[0].x > line_start.x && segments[seg_index].vs[0].x > segments[seg_index - 1].vs[0].x) {

                                        segments[seg_index - 1].vs[0].x = segments[seg_index].vs[0].x;

                                        seg_index--;

                                    } else {

                                        if (segments[seg_index - 1].vs[0].x < line_start.x && segments[seg_index].vs[0].x < segments[seg_index - 1].vs[0].x) {

                                            segments[seg_index - 1].vs[0].x = segments[seg_index].vs[0].x;

                                            seg_index--;

                                        } else

                                            line_start = segments[seg_index - 1].vs[0];

                                    }

                                } else

                                    line_start = segments[seg_index - 1].vs[0];

                            }

                        }

                    }

                }

                break;

            case gs_pe_curveto:

                if (stored_moveto) {

                    gdev_vector_dopath_segment(state, gs_pe_moveto, &line_start);

                    stored_moveto = false;

                }

                for (i=0;i<=seg_index;i++) {

                    gdev_vector_dopath_segment(state, segments[i].op, segments[i].vs);

                }

                line_start = segments[seg_index].vs[2];

                seg_index = -1;

                buffering = 0;

                break;

            case gs_pe_closepath:

                if (!buffering || seg_index < 4) {

                    if (stored_moveto && ((type & gx_path_type_stroke) && !(type & gx_path_type_fill)))

                        gdev_vector_dopath_segment(state, gs_pe_moveto, &line_start);

                    stored_moveto = false;

                    if (!do_close) {

                        i = seg_index;

                        while (i > 0 && segments[i - 1].op == gs_pe_moveto) {

                            segments[i - 1] = segments[i];

                            i--;

                        }

                        seg_index = i;

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

                            gdev_vector_dopath_segment(state, segments[i].op, segments[i].vs);

                        seg_index = 0;

                        if (is_clip_enum)

                            segments[seg_index].op = pe_op = gx_cpath_enum_next((gs_cpath_enum *)cenum, segments[seg_index].vs);

                        else

                            segments[seg_index].op = pe_op = gx_path_enum_next(cenum, segments[seg_index].vs);

                        if (pe_op > 0) {

                            gdev_vector_dopath_segment(state, gs_pe_closepath, segments[0].vs);

                            if (pe_op == gs_pe_moveto) {

                                if (matrix_optimisable)

                                    buffering = 1;

                                else

                                    buffering = 0;

                                seg_index = 0;

                                initial_m = 1;

                                line_start = segments[0].vs[0];

                            } else {

                                gdev_vector_dopath_segment(state, segments[0].op, segments[0].vs);

                                buffering = 0;

                                seg_index = -1;

                            }

                        }

                    } else {

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

                            gdev_vector_dopath_segment(state, segments[i].op, segments[i].vs);

                        if (matrix_optimisable)

                            buffering = 1;

                        else

                            buffering = 0;

                        seg_index = -1;

                    }

                } else {

                    is_rect = 1;

                    for (i=1;i<seg_index;i++) {

                        if (segments[i - 1].vs[0].x != segments[i].vs[0].x) {

                            if (segments[i - 1].vs[0].y != segments[i].vs[0].y) {

                                is_rect = 0;

                                break;

                            } else {

                                if (segments[i].vs[0].x != segments[i + 1].vs[0].x || segments[i].vs[0].y == segments[i + 1].vs[0].x){

                                    is_rect = 0;

                                    break;

                                }

                            }

                        } else {

                            if (segments[i - 1].vs[0].y == segments[i].vs[0].y) {

                                is_rect = 0;

                                break;

                            } else {

                                if (segments[i].vs[0].y != segments[i + 1].vs[0].y || segments[i].vs[0].x == segments[i + 1].vs[0].x){

                                    is_rect = 0;

                                    break;

                                }

                            }

                        }

                    }

                    if (segments[0].vs[0].x != segments[seg_index].vs[0].x || segments[0].vs[0].y != segments[seg_index].vs[0].y)

                        is_rect = 0;

                    /* If we would have to alter the starting point, and we are dashing a stroke, then don't treat

                     * this as a rectangle. Changing the start vertex will alter the dash pattern.

                     */

                    if (segments[0].vs[0].x == segments[1].vs[0].x && (type & gx_path_type_dashed_stroke))

                        is_rect = 0;

                    if (is_rect == 1) {

                        gs_fixed_point *pt = &segments[0].vs[0];

                        fixed width, height;

                        if (segments[0].vs[0].x == segments[1].vs[0].x) {

                            pt = &segments[1].vs[0];

                            width = segments[2].vs[0].x - segments[1].vs[0].x;

                            height = segments[0].vs[0].y - segments[1].vs[0].y;

                        } else {

                            width = segments[1].vs[0].x - segments[0].vs[0].x;

                            height = segments[2].vs[0].y - segments[1].vs[0].y;

                        }

                        gs_point_transform_inverse((double)pt->x, (double)pt->y,

                                   &state->scale_mat, &p);

                        gs_point_transform_inverse((double)width, (double)height,

                                   &state->scale_mat, &q);

                        code = vdev_proc(vdev, dorect)(vdev, (fixed)p.x, (fixed)p.y,

                                       (fixed)p.x + (fixed)q.x, (fixed)p.y + (fixed)q.y, type);

                        if (code < 0)

                            return code;

                        seg_index = -1;

                    } else {

                        for (i=0;i<=seg_index;i++) {

                            gdev_vector_dopath_segment(state, segments[i].op, segments[i].vs);

                        }

                        buffering = 0;

                        seg_index = -1;

                    }

                }

                break;

            default:

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

                    gdev_vector_dopath_segment(state, segments[i].op, segments[i].vs);

                if (stored_moveto && ((type & gx_path_type_stroke) && !(type & gx_path_type_fill)))

                    gdev_vector_dopath_segment(state, gs_pe_moveto, &line_start);

                seg_index = -1;

                buffering = 0;

                break;

        }

        seg_index++;

        if (seg_index > 4) {

            for (i=0;i<seg_index;i++) {

                gdev_vector_dopath_segment(state, segments[i].op, segments[i].vs);

            }

            seg_index = 0;

            buffering = 0;

        }

    } while (pe_op > 0);

    if (pe_op < 0)

        return pe_op;

    code = vdev_proc(vdev, endpath)(vdev, type);

    return (code < 0 ? code : segs);

}

/* Put a single element of a clipping path list. */

static int

pdf_put_clip_path_list_elem(gx_device_pdf * pdev, gx_cpath_path_list *e,

        gs_path_enum *cenum, gdev_vector_dopath_state_t *state,

        gs_fixed_point vs[3])

{   /* This recursive function provides a reverse order of the list elements. */

    int segments = 0;

    if (e->next != NULL) {

        int code = pdf_put_clip_path_list_elem(pdev, e->next, cenum, state, vs);

        if (code != 0)

            return code;

    }

    segments = pdf_write_path(pdev, cenum, state, &e->path, 0, gx_path_type_clip | gx_path_type_optimize, NULL);

    if (segments < 0)

        return segments;

    if (segments)

        pprints1(pdev->strm, "%s n\n", (e->rule <= 0 ? "W" : "W*"));

    return 0;

}

/* Put a clipping path on the output file. */

int

pdf_put_clip_path(gx_device_pdf * pdev, const gx_clip_path * pcpath)

{

    int code;

    stream *s = pdev->strm;

    gs_id new_id;

    /* Check for no update needed. */

    if (pcpath == NULL) {

        if (pdev->clip_path_id == pdev->no_clip_path_id)

            return 0;

        new_id = pdev->no_clip_path_id;

    } else {

        if (pdev->clip_path_id == pcpath->id)

            return 0;

        new_id = pcpath->id;

        if (gx_cpath_includes_rectangle(pcpath, fixed_0, fixed_0,

                                        int2fixed(pdev->width),

                                        int2fixed(pdev->height))

            ) {

            if (pdev->clip_path_id == pdev->no_clip_path_id)

                return 0;

            new_id = pdev->no_clip_path_id;

        }

        code = pdf_is_same_clip_path(pdev, pcpath);

        if (code < 0)

            return code;

        if (code) {

            pdev->clip_path_id = new_id;

            return 0;

        }

    }

    /*

     * The contents must be open already, so the following will only exit

     * text or string context.

     */

    code = pdf_open_contents(pdev, PDF_IN_STREAM);

    if (code < 0)

        return code;

    /* Use Q to unwind the old clipping path. */

    if (pdev->vgstack_depth > pdev->vgstack_bottom) {

        code = pdf_restore_viewer_state(pdev, s);

        if (code < 0)

            return code;

    }

    if (new_id != pdev->no_clip_path_id) {

        gs_fixed_rect rect;

        /* Use q to allow the new clipping path to unwind.  */

        code = pdf_save_viewer_state(pdev, s);

        if (code < 0)

            return code;

        /* path_valid states that the clip path is a simple path. If the clip is an intersection of

         * two paths, then path_valid is false. The problem is that the rectangle list is the

         * scan-converted result of the clip, and ths is at the device resolution. Its possible

         * that the intersection of the clips, at device resolution, is rectangular but the

         * two paths are not, and that at a different resolution, nor is the intersection.

         * So we *only* want to write a rectangle, if the clip is rectangular, and its the

         * result of a simple rectangle. Otherwise we want to write the paths that create

         * the clip. However, see below about the path_list.

         */

        if (pcpath->path_valid && cpath_is_rectangle(pcpath, &rect)) {

            /* Use unrounded coordinates. */

            pprintg4(s, "%g %g %g %g re",

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

                fixed2float(rect.q.x - rect.p.x),

                fixed2float(rect.q.y - rect.p.y));

            pprints1(s, " %s n\n", (pcpath->rule <= 0 ? "W" : "W*"));

        } else {

            gdev_vector_dopath_state_t state;

            gs_fixed_point vs[3];

            /* the first comment below is (now) incorrect. Previously in gx_clip_to_rectangle()

             * we would create a rectangular clip, without using a path to do so. This results

             * in a rectangular clip, where path_valid is false. However, we did *not* clear

             * the path_list! So if there had previously been a clip path set, by setting paths,

             * we did not clear it. This is not sensible, and caused massive confusion for this code

             * so it has been altered to clear path_list, indicating that there is a clip,

             * the path is not valid, and that it was not created using arbitrary paths.

             * In this case we just emit the rectangle as well (there should be only one).

             */

            if (pcpath->path_list == NULL) {

                /*

                 * We think this should be never executed.

                 * This obsolete branch writes a clip path intersection

                 * as a set of rectangles computed by

                 * gx_cpath_intersect_path_slow.

                 * Those rectangles use coordinates rounded to pixels,

                 * therefore the precision may be unsatisfactory -

                 * see Bug 688407.

                 */

                gs_cpath_enum cenum;

                /*

                 * We have to break 'const' here because the clip path

                 * enumeration logic uses some internal mark bits.

                 * This is very unfortunate, but until we can come up with

                 * a better algorithm, it's necessary.

                 */

                code = pdf_write_path(pdev, (gs_path_enum *)&cenum, &state, (gx_path *)pcpath, 1, gx_path_type_clip | gx_path_type_optimize, NULL);

                if (code < 0)

                    return code;

                pprints1(s, "%s n\n", (pcpath->rule <= 0 ? "W" : "W*"));

            } else {

                gs_path_enum cenum;

                code = pdf_put_clip_path_list_elem(pdev, pcpath->path_list, &cenum, &state, vs);

                if (code < 0)

                    return code;

            }

        }

    }

    pdev->clip_path_id = new_id;

    return pdf_remember_clip_path(pdev,

            (pdev->clip_path_id == pdev->no_clip_path_id ? NULL : pcpath));

}

/*

 * Compute the scaling to ensure that user coordinates for a path are within

 * PDF/A-1 valid range.  Return true if scaling was needed.  In this case, the

 * CTM will be multiplied by *pscale, and all coordinates will be divided by

 * *pscale.

 */

static bool

make_rect_scaling(const gx_device_pdf *pdev, const gs_fixed_rect *bbox,

                  double prescale, double *pscale)

{

    double bmin, bmax;

    if (pdev->PDFA != 1) {

        *pscale = 1;

        return false;

    }

    bmin = min(bbox->p.x / pdev->scale.x, bbox->p.y / pdev->scale.y) * prescale;

    bmax = max(bbox->q.x / pdev->scale.x, bbox->q.y / pdev->scale.y) * prescale;

    if (bmin <= int2fixed(-MAX_USER_COORD) ||

        bmax > int2fixed(MAX_USER_COORD)

        ) {

        /* Rescale the path. */

        *pscale = max(bmin / int2fixed(-MAX_USER_COORD),

                      bmax / int2fixed(MAX_USER_COORD));

        return true;

    } else {

        *pscale = 1;

        return false;

    }

}

/*

 * Prepare a fill with a color anc a clipping path.

 * Return 1 if there is nothing to paint.

 * Changes *box to the clipping box.

 */

static int

prepare_fill_with_clip(gx_device_pdf *pdev, const gs_gstate * pgs,

              gs_fixed_rect *box, bool have_path,

              const gx_drawing_color * pdcolor, const gx_clip_path * pcpath)

{

    bool new_clip;

    int code;

    /*

     * Check for an empty clipping path.

     */

    if (pcpath) {

        gs_fixed_rect cbox;

        gx_cpath_outer_box(pcpath, &cbox);

        if (cbox.p.x >= cbox.q.x || cbox.p.y >= cbox.q.y)

            return 1;    /* empty clipping path */

        *box = cbox;

    }

    code = pdf_check_soft_mask(pdev, (gs_gstate *)pgs);

    if (code < 0)

        return code;

    new_clip = pdf_must_put_clip_path(pdev, pcpath);

    if (have_path || pdev->context == PDF_IN_NONE || new_clip) {

        if (new_clip)

            code = pdf_unclip(pdev);

        else

            code = pdf_open_page(pdev, PDF_IN_STREAM);

        if (code < 0)

            return code;

    }

    code = pdf_prepare_fill(pdev, pgs, false);

    if (code < 0)

        return code;

    return pdf_put_clip_path(pdev, pcpath);

}

/* -------------A local image converter device. -----------------------------*/

public_st_pdf_lcvd_t();

static int

lcvd_copy_color_shifted(gx_device * dev,

               const byte * base, int sourcex, int sraster, gx_bitmap_id id,

                      int x, int y, int w, int h)

{

    pdf_lcvd_t *cvd = (pdf_lcvd_t *)dev;

    int code;

    int dw = cvd->mdev.width;

    int dh = cvd->mdev.height;

    cvd->mdev.width -= cvd->mdev.mapped_x;

    cvd->mdev.height -= cvd->mdev.mapped_y;

    code = cvd->std_copy_color((gx_device *)&cvd->mdev, base, sourcex, sraster, id,

        x - cvd->mdev.mapped_x, y - cvd->mdev.mapped_y, w, h);

    cvd->mdev.width = dw;

    cvd->mdev.height = dh;

    return code;

}

static int

lcvd_copy_mono_shifted(gx_device * dev,

               const byte * base, int sourcex, int sraster, gx_bitmap_id id,

                      int x, int y, int w, int h, gx_color_index zero, gx_color_index one)

{

    pdf_lcvd_t *cvd = (pdf_lcvd_t *)dev;

    int code;

    int dw = cvd->mdev.width;

    int dh = cvd->mdev.height;

    cvd->mdev.width -= cvd->mdev.mapped_x;

    cvd->mdev.height -= cvd->mdev.mapped_y;

    code = cvd->std_copy_mono((gx_device *)&cvd->mdev, base, sourcex, sraster, id,

                              x - cvd->mdev.mapped_x, y - cvd->mdev.mapped_y, w, h,

                              zero, one);

    cvd->mdev.width = dw;

    cvd->mdev.height = dh;

    return code;

}

static int

lcvd_fill_rectangle_shifted(gx_device *dev, int x, int y, int width, int height, gx_color_index color)

{

    pdf_lcvd_t *cvd = (pdf_lcvd_t *)dev;

    int code;

    int w = cvd->mdev.width;

    int h = cvd->mdev.height;

    cvd->mdev.width -= cvd->mdev.mapped_x;

    cvd->mdev.height -= cvd->mdev.mapped_y;

    code = cvd->std_fill_rectangle((gx_device *)&cvd->mdev,

        x - cvd->mdev.mapped_x, y - cvd->mdev.mapped_y, width, height, color);

    cvd->mdev.width = w;

    cvd->mdev.height = h;

    return code;

}

static int

lcvd_fill_rectangle_shifted2(gx_device *dev, int x, int y, int width, int height, gx_color_index color)

{

    pdf_lcvd_t *cvd = (pdf_lcvd_t *)dev;

    int code;

    int w = cvd->mdev.width;

    int h = cvd->mdev.height;

    cvd->mdev.width -= cvd->mdev.mapped_x;

    cvd->mdev.height -= cvd->mdev.mapped_y;

    if (cvd->mask) {

        code = (*dev_proc(cvd->mask, fill_rectangle))((gx_device *)cvd->mask,

            x - cvd->mdev.mapped_x, y - cvd->mdev.mapped_y, width, height, (gx_color_index)1);

        if (code < 0)

            goto fail;

    }

    code = cvd->std_fill_rectangle((gx_device *)&cvd->mdev,

        x - cvd->mdev.mapped_x, y - cvd->mdev.mapped_y, width, height, color);

fail:

    cvd->mdev.width = w;

    cvd->mdev.height = h;

    return code;

}

static void

lcvd_get_clipping_box_shifted_from_mdev(gx_device *dev, gs_fixed_rect *pbox)

{

    fixed ofs;

    pdf_lcvd_t *cvd = (pdf_lcvd_t *)dev;

    int w = cvd->mdev.width;

    int h = cvd->mdev.height;

    cvd->mdev.width -= cvd->mdev.mapped_x;

    cvd->mdev.height -= cvd->mdev.mapped_y;

    cvd->std_get_clipping_box((gx_device *)&cvd->mdev, pbox);

    cvd->mdev.width = w;

    cvd->mdev.height = h;

    ofs = int2fixed(cvd->mdev.mapped_x);

    pbox->p.x += ofs;

    pbox->q.x += ofs;

    ofs = int2fixed(cvd->mdev.mapped_y);