/src/ghostpdl/base/gdevdsha.c

Source (jump to first uncovered line)
/* Copyright (C) 2001-2024 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.
*/

/* Default shading drawing device procedures. */

#include "gx.h"
#include "gserrors.h"
#include "gxdevice.h"
#include "gxcindex.h"
#include "gxdevsop.h"

static bool
gx_devn_diff(frac31 devn1[], frac31 devn2[], int num)
{
    int k;

    for (k = 0; k < num; k++) {
        if (devn1[k] != devn2[k]) {
            return true;
        }
    }
    return false;
}

int
gx_hl_fill_linear_color_scanline(gx_device *dev, const gs_fill_attributes *fa,
        int i0, int j, int w, const frac31 *c0, const int32_t *c0f,
        const int32_t *cg_num, int32_t cg_den)
{
    frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
    frac31 curr[GX_DEVICE_COLOR_MAX_COMPONENTS];
    ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
    int i, i1 = i0 + w, bi = i0, k;
    const gx_device_color_info *cinfo = &dev->color_info;
    int n = cinfo->num_components;
    int si, ei, di, code;
    gs_fixed_rect rect;
    gx_device_color devc;

    /* Note: All the stepping math is done with frac color values */

    devc.type = gx_dc_type_devn;

    if (j < fixed2int(fa->clip->p.y) ||
            j > fixed2int_ceiling(fa->clip->q.y)) /* Must be compatible to the clipping logic. */
        return 0;
    for (k = 0; k < n; k++) {
        curr[k] = c[k] = c0[k];
        f[k] = c0f[k];
    }
    for (i = i0 + 1, di = 1; i < i1; i += di) {
        if (di == 1) {
            /* Advance colors by 1 pixel. */
            for (k = 0; k < n; k++) {
                if (cg_num[k]) {
                    int32_t m = f[k] + cg_num[k];

                    c[k] += m / cg_den;
                    m -= m / cg_den * cg_den;
                    if (m < 0) {
                        c[k]--;
                        m += cg_den;
                    }
                    f[k] = m;
                }
            }
        } else {
            /* Advance colors by di pixels. */
            for (k = 0; k < n; k++) {
                if (cg_num[k]) {
                    int64_t M = f[k] + (int64_t)cg_num[k] * di;
                    int32_t m;

                    c[k] += (frac31)(M / cg_den);
                    m = (int32_t)(M - M / cg_den * cg_den);
                    if (m < 0) {
                        c[k]--;
                        m += cg_den;
                    }
                    f[k] = m;
                }
            }
        }
        if (gx_devn_diff(c, curr, n)) {
            si = max(bi, fixed2int(fa->clip->p.x));     /* Must be compatible to the clipping logic. */
            ei = min(i, fixed2int_ceiling(fa->clip->q.x));  /* Must be compatible to the clipping logic. */
            if (si < ei) {
                if (fa->swap_axes) {
                    rect.p.x = int2fixed(j);
                    rect.p.y = int2fixed(si);
                    rect.q.x = int2fixed(j + 1);
                    rect.q.y = int2fixed(ei);
                } else {
                    rect.p.x = int2fixed(si);
                    rect.p.y = int2fixed(j);
                    rect.q.x = int2fixed(ei);
                    rect.q.y = int2fixed(j + 1);
                }
                for (k = 0; k < n; k++) {
                    devc.colors.devn.values[k] = frac312cv(curr[k]);
                }
                devc.tag = device_current_tag(dev);
                code = dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
                if (code < 0)
                    return code;
            }
            bi = i;
            for (k = 0; k < n; k++) {
                curr[k] = c[k];
            }
            di = 1;
        } else if (i == i1) {
            i++;
            break;
        } else {
            /* Compute a color change pixel analytically. */
            di = i1 - i;
            for (k = 0; k < n; k++) {
                int32_t a;
                int64_t x;
                frac31 v = 1 << (31 - cinfo->comp_bits[k]); /* Color index precision in frac31. */
                frac31 u = c[k] & (v - 1);

                if (cg_num[k] == 0) {
                    /* No change. */
                    continue;
                } if (cg_num[k] > 0) {
                    /* Solve[(f[k] + cg_num[k]*x)/cg_den == v - u, x]  */
                    a = v - u;
                } else {
                    /* Solve[(f[k] + cg_num[k]*x)/cg_den == - u - 1, x]  */
                    a = -u - 1;
                }
                x = ((int64_t)a * cg_den - f[k]) / cg_num[k];
                if (i + x >= i1)
                    continue;
                else if (x < 0)
                    return_error(gs_error_unregistered); /* Must not happen. */
                else if (di > (int)x) {
                    di = (int)x;
                    if (di <= 1) {
                        di = 1;
                        break;
                    }
                }
            }
        }
    }
    si = max(bi, fixed2int(fa->clip->p.x));     /* Must be compatible to the clipping logic. */
    ei = min(i, fixed2int_ceiling(fa->clip->q.x));  /* Must be compatible to the clipping logic. */
    if (si < ei) {
        if (fa->swap_axes) {
            rect.p.x = int2fixed(j);
            rect.p.y = int2fixed(si);
            rect.q.x = int2fixed(j + 1);
            rect.q.y = int2fixed(ei);
        } else {
            rect.p.x = int2fixed(si);
            rect.p.y = int2fixed(j);
            rect.q.x = int2fixed(ei);
            rect.q.y = int2fixed(j + 1);
        }
        for (k = 0; k < n; k++) {
            devc.colors.devn.values[k] = frac312cv(curr[k]);
        }
        devc.tag = device_current_tag(dev);
        return dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
    }
    return 0;
}

int
gx_default_fill_linear_color_scanline(gx_device *dev, const gs_fill_attributes *fa,
        int i0, int j, int w,
        const frac31 *c0, const int32_t *c0f, const int32_t *cg_num, int32_t cg_den)
{
    /* This default implementation decomposes the area into constant color rectangles.
       Devices may supply optimized implementations with
       the inversed nesting of the i,k cicles,
       i.e. with enumerating planes first, with a direct writing to the raster,
       and with a fixed bits per component.
     */
    /* First determine if we are doing high level style colors or pure colors */
    bool devn = dev_proc(dev, dev_spec_op)(dev, gxdso_supports_devn, NULL, 0);
    frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
    ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
    int i, i1 = i0 + w, bi = i0, k;
    gx_color_index ci0 = 0, ci1;
    const gx_device_color_info *cinfo = &dev->color_info;
    int n = cinfo->num_components;
    int si, ei, di, code;

    /* Todo: set this up to vector earlier */
    if (devn)  /* Note, PDF14 could be additive and doing devn */
        return gx_hl_fill_linear_color_scanline(dev, fa, i0, j, w, c0, c0f,
                                                cg_num, cg_den);
    if (j < fixed2int(fa->clip->p.y) ||
            j > fixed2int_ceiling(fa->clip->q.y)) /* Must be compatible to the clipping logic. */
        return 0;
    for (k = 0; k < n; k++) {
        int shift = cinfo->comp_shift[k];
        int bits = cinfo->comp_bits[k];

        c[k] = c0[k];
        f[k] = c0f[k];
        ci0 |= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
    }
    for (i = i0 + 1, di = 1; i < i1; i += di) {
        if (di == 1) {
            /* Advance colors by 1 pixel. */
            ci1 = 0;
            for (k = 0; k < n; k++) {
                int shift = cinfo->comp_shift[k];
                int bits = cinfo->comp_bits[k];

                if (cg_num[k]) {
                    int32_t m = f[k] + cg_num[k];

                    c[k] += m / cg_den;
                    m -= m / cg_den * cg_den;
                    if (m < 0) {
                        c[k]--;
                        m += cg_den;
                    }
                    f[k] = m;
                }
                ci1 |= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
            }
        } else {
            /* Advance colors by di pixels. */
            ci1 = 0;
            for (k = 0; k < n; k++) {
                int shift = cinfo->comp_shift[k];
                int bits = cinfo->comp_bits[k];

                if (cg_num[k]) {
                    int64_t M = f[k] + (int64_t)cg_num[k] * di;
                    int32_t m;

                    c[k] += (frac31)(M / cg_den);
                    m = (int32_t)(M - M / cg_den * cg_den);
                    if (m < 0) {
                        c[k]--;
                        m += cg_den;
                    }
                    f[k] = m;
                }
                ci1 |= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
            }
        }
        if (ci1 != ci0) {
            si = max(bi, fixed2int(fa->clip->p.x));     /* Must be compatible to the clipping logic. */
            ei = min(i, fixed2int_ceiling(fa->clip->q.x));  /* Must be compatible to the clipping logic. */
            if (si < ei) {
                if (fa->swap_axes) {
                    code = dev_proc(dev, fill_rectangle)(dev, j, si, 1, ei - si, ci0);
                } else {
                    code = dev_proc(dev, fill_rectangle)(dev, si, j, ei - si, 1, ci0);
                }
                if (code < 0)
                    return code;
            }
            bi = i;
            ci0 = ci1;
            di = 1;
        } else if (i == i1) {
            i++;
            break;
        } else {
            /* Compute a color change pixel analitically. */
            di = i1 - i;
            for (k = 0; k < n; k++) {
                int32_t a;
                int64_t x;
                frac31 v = 1 << (31 - cinfo->comp_bits[k]); /* Color index precision in frac31. */
                frac31 u = c[k] & (v - 1);

                if (cg_num[k] == 0) {
                    /* No change. */
                    continue;
                } if (cg_num[k] > 0) {
                    /* Solve[(f[k] + cg_num[k]*x)/cg_den == v - u, x]  */
                    a = v - u;
                } else {
                    /* Solve[(f[k] + cg_num[k]*x)/cg_den == - u - 1, x]  */
                    a = -u - 1;
                }
                x = ((int64_t)a * cg_den - f[k]) / cg_num[k];
                if (i + x >= i1)
                    continue;
                else if (x < 0)
                    return_error(gs_error_unregistered); /* Must not happen. */
                else if (di > (int)x) {
                    di = (int)x;
                    if (di <= 1) {
                        di = 1;
                        break;
                    }
                }
            }
        }
    }
    si = max(bi, fixed2int(fa->clip->p.x));     /* Must be compatible to the clipping logic. */
    ei = min(i, fixed2int_ceiling(fa->clip->q.x));  /* Must be compatible to the clipping logic. */
    if (si < ei) {
        if (fa->swap_axes) {
            return dev_proc(dev, fill_rectangle)(dev, j, si, 1, ei - si, ci0);
        } else {
            return dev_proc(dev, fill_rectangle)(dev, si, j, ei - si, 1, ci0);
        }
    }
    return 0;
}

Coverage Report

Created: 2025-06-10 07:06

Line	Count	Source (jump to first uncovered line)
1		/* Copyright (C) 2001-2024 Artifex Software, Inc.
2		All Rights Reserved.
3
4		This software is provided AS-IS with no warranty, either express or
5		implied.
6
7		This software is distributed under license and may not be copied,
8		modified or distributed except as expressly authorized under the terms
9		of the license contained in the file LICENSE in this distribution.
10
11		Refer to licensing information at http://www.artifex.com or contact
12		Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
13		CA 94129, USA, for further information.
14		*/
15
16		/* Default shading drawing device procedures. */
17
18		#include "gx.h"
19		#include "gserrors.h"
20		#include "gxdevice.h"
21		#include "gxcindex.h"
22		#include "gxdevsop.h"
23
24		static bool
25		gx_devn_diff(frac31 devn1[], frac31 devn2[], int num)
26	0	{
27	0	int k;
28
29	0	for (k = 0; k < num; k++) {
30	0	if (devn1[k] != devn2[k]) {
31	0	return true;
32	0	}
33	0	}
34	0	return false;
35	0	}
36
37		int
38		gx_hl_fill_linear_color_scanline(gx_device dev, const gs_fill_attributes fa,
39		int i0, int j, int w, const frac31 c0, const int32_t c0f,
40		const int32_t *cg_num, int32_t cg_den)
41	0	{
42	0	frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
43	0	frac31 curr[GX_DEVICE_COLOR_MAX_COMPONENTS];
44	0	ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
45	0	int i, i1 = i0 + w, bi = i0, k;
46	0	const gx_device_color_info *cinfo = &dev->color_info;
47	0	int n = cinfo->num_components;
48	0	int si, ei, di, code;
49	0	gs_fixed_rect rect;
50	0	gx_device_color devc;
51
52		/* Note: All the stepping math is done with frac color values */
53
54	0	devc.type = gx_dc_type_devn;
55
56	0	if (j < fixed2int(fa->clip->p.y) \|\|
57	0	j > fixed2int_ceiling(fa->clip->q.y)) /* Must be compatible to the clipping logic. */
58	0	return 0;
59	0	for (k = 0; k < n; k++) {
60	0	curr[k] = c[k] = c0[k];
61	0	f[k] = c0f[k];
62	0	}
63	0	for (i = i0 + 1, di = 1; i < i1; i += di) {
64	0	if (di == 1) {
65		/* Advance colors by 1 pixel. */
66	0	for (k = 0; k < n; k++) {
67	0	if (cg_num[k]) {
68	0	int32_t m = f[k] + cg_num[k];
69
70	0	c[k] += m / cg_den;
71	0	m -= m / cg_den * cg_den;
72	0	if (m < 0) {
73	0	c[k]--;
74	0	m += cg_den;
75	0	}
76	0	f[k] = m;
77	0	}
78	0	}
79	0	} else {
80		/* Advance colors by di pixels. */
81	0	for (k = 0; k < n; k++) {
82	0	if (cg_num[k]) {
83	0	int64_t M = f[k] + (int64_t)cg_num[k] * di;
84	0	int32_t m;
85
86	0	c[k] += (frac31)(M / cg_den);
87	0	m = (int32_t)(M - M / cg_den * cg_den);
88	0	if (m < 0) {
89	0	c[k]--;
90	0	m += cg_den;
91	0	}
92	0	f[k] = m;
93	0	}
94	0	}
95	0	}
96	0	if (gx_devn_diff(c, curr, n)) {
97	0	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
98	0	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
99	0	if (si < ei) {
100	0	if (fa->swap_axes) {
101	0	rect.p.x = int2fixed(j);
102	0	rect.p.y = int2fixed(si);
103	0	rect.q.x = int2fixed(j + 1);
104	0	rect.q.y = int2fixed(ei);
105	0	} else {
106	0	rect.p.x = int2fixed(si);
107	0	rect.p.y = int2fixed(j);
108	0	rect.q.x = int2fixed(ei);
109	0	rect.q.y = int2fixed(j + 1);
110	0	}
111	0	for (k = 0; k < n; k++) {
112	0	devc.colors.devn.values[k] = frac312cv(curr[k]);
113	0	}
114	0	devc.tag = device_current_tag(dev);
115	0	code = dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
116	0	if (code < 0)
117	0	return code;
118	0	}
119	0	bi = i;
120	0	for (k = 0; k < n; k++) {
121	0	curr[k] = c[k];
122	0	}
123	0	di = 1;
124	0	} else if (i == i1) {
125	0	i++;
126	0	break;
127	0	} else {
128		/* Compute a color change pixel analytically. */
129	0	di = i1 - i;
130	0	for (k = 0; k < n; k++) {
131	0	int32_t a;
132	0	int64_t x;
133	0	frac31 v = 1 << (31 - cinfo->comp_bits[k]); /* Color index precision in frac31. */
134	0	frac31 u = c[k] & (v - 1);
135
136	0	if (cg_num[k] == 0) {
137		/* No change. */
138	0	continue;
139	0	} if (cg_num[k] > 0) {
140		/* Solve[(f[k] + cg_num[k]x)/cg_den == v - u, x] /
141	0	a = v - u;
142	0	} else {
143		/* Solve[(f[k] + cg_num[k]x)/cg_den == - u - 1, x] /
144	0	a = -u - 1;
145	0	}
146	0	x = ((int64_t)a * cg_den - f[k]) / cg_num[k];
147	0	if (i + x >= i1)
148	0	continue;
149	0	else if (x < 0)
150	0	return_error(gs_error_unregistered); /* Must not happen. */
151	0	else if (di > (int)x) {
152	0	di = (int)x;
153	0	if (di <= 1) {
154	0	di = 1;
155	0	break;
156	0	}
157	0	}
158	0	}
159	0	}
160	0	}
161	0	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
162	0	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
163	0	if (si < ei) {
164	0	if (fa->swap_axes) {
165	0	rect.p.x = int2fixed(j);
166	0	rect.p.y = int2fixed(si);
167	0	rect.q.x = int2fixed(j + 1);
168	0	rect.q.y = int2fixed(ei);
169	0	} else {
170	0	rect.p.x = int2fixed(si);
171	0	rect.p.y = int2fixed(j);
172	0	rect.q.x = int2fixed(ei);
173	0	rect.q.y = int2fixed(j + 1);
174	0	}
175	0	for (k = 0; k < n; k++) {
176	0	devc.colors.devn.values[k] = frac312cv(curr[k]);
177	0	}
178	0	devc.tag = device_current_tag(dev);
179	0	return dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
180	0	}
181	0	return 0;
182	0	}
183
184		int
185		gx_default_fill_linear_color_scanline(gx_device dev, const gs_fill_attributes fa,
186		int i0, int j, int w,
187		const frac31 c0, const int32_t c0f, const int32_t *cg_num, int32_t cg_den)
188	6.24M	{
189		/* This default implementation decomposes the area into constant color rectangles.
190		Devices may supply optimized implementations with
191		the inversed nesting of the i,k cicles,
192		i.e. with enumerating planes first, with a direct writing to the raster,
193		and with a fixed bits per component.
194		*/
195		/* First determine if we are doing high level style colors or pure colors */
196	6.24M	bool devn = dev_proc(dev, dev_spec_op)(dev, gxdso_supports_devn, NULL, 0);
197	6.24M	frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
198	6.24M	ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
199	6.24M	int i, i1 = i0 + w, bi = i0, k;
200	6.24M	gx_color_index ci0 = 0, ci1;
201	6.24M	const gx_device_color_info *cinfo = &dev->color_info;
202	6.24M	int n = cinfo->num_components;
203	6.24M	int si, ei, di, code;
204
205		/* Todo: set this up to vector earlier */
206	6.24M	if (devn) /* Note, PDF14 could be additive and doing devn */
207	0	return gx_hl_fill_linear_color_scanline(dev, fa, i0, j, w, c0, c0f,
208	0	cg_num, cg_den);
209	6.24M	if (j < fixed2int(fa->clip->p.y) \|\|
210	6.24M	j > fixed2int_ceiling(fa->clip->q.y)) /* Must be compatible to the clipping logic. */
211	0	return 0;
212	26.2M	for (k = 0; k < n; k++) {
213	19.9M	int shift = cinfo->comp_shift[k];
214	19.9M	int bits = cinfo->comp_bits[k];
215
216	19.9M	c[k] = c0[k];
217	19.9M	f[k] = c0f[k];
218	19.9M	ci0 \|= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
219	19.9M	}
220	37.0M	for (i = i0 + 1, di = 1; i < i1; i += di) {
221	30.7M	if (di == 1) {
222		/* Advance colors by 1 pixel. */
223	30.7M	ci1 = 0;
224	119M	for (k = 0; k < n; k++) {
225	89.2M	int shift = cinfo->comp_shift[k];
226	89.2M	int bits = cinfo->comp_bits[k];
227
228	89.2M	if (cg_num[k]) {
229	73.9M	int32_t m = f[k] + cg_num[k];
230
231	73.9M	c[k] += m / cg_den;
232	73.9M	m -= m / cg_den * cg_den;
233	73.9M	if (m < 0) {
234	39.3M	c[k]--;
235	39.3M	m += cg_den;
236	39.3M	}
237	73.9M	f[k] = m;
238	73.9M	}
239	89.2M	ci1 \|= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
240	89.2M	}
241	30.7M	} else {
242		/* Advance colors by di pixels. */
243	69.4k	ci1 = 0;
244	247k	for (k = 0; k < n; k++) {
245	177k	int shift = cinfo->comp_shift[k];
246	177k	int bits = cinfo->comp_bits[k];
247
248	177k	if (cg_num[k]) {
249	123k	int64_t M = f[k] + (int64_t)cg_num[k] * di;
250	123k	int32_t m;
251
252	123k	c[k] += (frac31)(M / cg_den);
253	123k	m = (int32_t)(M - M / cg_den * cg_den);
254	123k	if (m < 0) {
255	0	c[k]--;
256	0	m += cg_den;
257	0	}
258	123k	f[k] = m;
259	123k	}
260	177k	ci1 \|= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
261	177k	}
262	69.4k	}
263	30.7M	if (ci1 != ci0) {
264	9.33M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
265	9.33M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
266	9.33M	if (si < ei) {
267	9.05M	if (fa->swap_axes) {
268	0	code = dev_proc(dev, fill_rectangle)(dev, j, si, 1, ei - si, ci0);
269	9.05M	} else {
270	9.05M	code = dev_proc(dev, fill_rectangle)(dev, si, j, ei - si, 1, ci0);
271	9.05M	}
272	9.05M	if (code < 0)
273	0	return code;
274	9.05M	}
275	9.33M	bi = i;
276	9.33M	ci0 = ci1;
277	9.33M	di = 1;
278	21.4M	} else if (i == i1) {
279	0	i++;
280	0	break;
281	21.4M	} else {
282		/* Compute a color change pixel analitically. */
283	21.4M	di = i1 - i;
284	38.5M	for (k = 0; k < n; k++) {
285	37.8M	int32_t a;
286	37.8M	int64_t x;
287	37.8M	frac31 v = 1 << (31 - cinfo->comp_bits[k]); /* Color index precision in frac31. */
288	37.8M	frac31 u = c[k] & (v - 1);
289
290	37.8M	if (cg_num[k] == 0) {
291		/* No change. */
292	7.99M	continue;
293	29.8M	} if (cg_num[k] > 0) {
294		/* Solve[(f[k] + cg_num[k]x)/cg_den == v - u, x] /
295	12.0M	a = v - u;
296	17.7M	} else {
297		/* Solve[(f[k] + cg_num[k]x)/cg_den == - u - 1, x] /
298	17.7M	a = -u - 1;
299	17.7M	}
300	29.8M	x = ((int64_t)a * cg_den - f[k]) / cg_num[k];
301	29.8M	if (i + x >= i1)
302	2.39M	continue;
303	27.4M	else if (x < 0)
304	0	return_error(gs_error_unregistered); /* Must not happen. */
305	27.4M	else if (di > (int)x) {
306	25.9M	di = (int)x;
307	25.9M	if (di <= 1) {
308	20.7M	di = 1;
309	20.7M	break;
310	20.7M	}
311	25.9M	}
312	29.8M	}
313	21.4M	}
314	30.7M	}
315	6.24M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
316	6.24M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
317	6.24M	if (si < ei) {
318	5.90M	if (fa->swap_axes) {
319	3.05M	return dev_proc(dev, fill_rectangle)(dev, j, si, 1, ei - si, ci0);
320	3.05M	} else {
321	2.85M	return dev_proc(dev, fill_rectangle)(dev, si, j, ei - si, 1, ci0);
322	2.85M	}
323	5.90M	}
324	338k	return 0;
325	6.24M	}