/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 06:58

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	4.39M	{
27	4.39M	int k;
28
29	7.79M	for (k = 0; k < num; k++) {
30	7.64M	if (devn1[k] != devn2[k]) {
31	4.25M	return true;
32	4.25M	}
33	7.64M	}
34	146k	return false;
35	4.39M	}
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	1.53M	{
42	1.53M	frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
43	1.53M	frac31 curr[GX_DEVICE_COLOR_MAX_COMPONENTS];
44	1.53M	ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
45	1.53M	int i, i1 = i0 + w, bi = i0, k;
46	1.53M	const gx_device_color_info *cinfo = &dev->color_info;
47	1.53M	int n = cinfo->num_components;
48	1.53M	int si, ei, di, code;
49	1.53M	gs_fixed_rect rect;
50	1.53M	gx_device_color devc;
51
52		/* Note: All the stepping math is done with frac color values */
53
54	1.53M	devc.type = gx_dc_type_devn;
55
56	1.53M	if (j < fixed2int(fa->clip->p.y) \|\|
57	1.53M	j > fixed2int_ceiling(fa->clip->q.y)) /* Must be compatible to the clipping logic. */
58	0	return 0;
59	6.68M	for (k = 0; k < n; k++) {
60	5.15M	curr[k] = c[k] = c0[k];
61	5.15M	f[k] = c0f[k];
62	5.15M	}
63	5.93M	for (i = i0 + 1, di = 1; i < i1; i += di) {
64	4.39M	if (di == 1) {
65		/* Advance colors by 1 pixel. */
66	13.9M	for (k = 0; k < n; k++) {
67	9.51M	if (cg_num[k]) {
68	5.64M	int32_t m = f[k] + cg_num[k];
69
70	5.64M	c[k] += m / cg_den;
71	5.64M	m -= m / cg_den * cg_den;
72	5.64M	if (m < 0) {
73	2.23M	c[k]--;
74	2.23M	m += cg_den;
75	2.23M	}
76	5.64M	f[k] = m;
77	5.64M	}
78	9.51M	}
79	4.39M	} 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	4.39M	if (gx_devn_diff(c, curr, n)) {
97	4.25M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
98	4.25M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
99	4.25M	if (si < ei) {
100	4.02M	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	4.02M	} else {
106	4.02M	rect.p.x = int2fixed(si);
107	4.02M	rect.p.y = int2fixed(j);
108	4.02M	rect.q.x = int2fixed(ei);
109	4.02M	rect.q.y = int2fixed(j + 1);
110	4.02M	}
111	12.2M	for (k = 0; k < n; k++) {
112	8.26M	devc.colors.devn.values[k] = frac312cv(curr[k]);
113	8.26M	}
114	4.02M	devc.tag = device_current_tag(dev);
115	4.02M	code = dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
116	4.02M	if (code < 0)
117	0	return code;
118	4.02M	}
119	4.25M	bi = i;
120	13.2M	for (k = 0; k < n; k++) {
121	9.04M	curr[k] = c[k];
122	9.04M	}
123	4.25M	di = 1;
124	4.25M	} else if (i == i1) {
125	0	i++;
126	0	break;
127	146k	} else {
128		/* Compute a color change pixel analytically. */
129	146k	di = i1 - i;
130	618k	for (k = 0; k < n; k++) {
131	472k	int32_t a;
132	472k	int64_t x;
133	472k	frac31 v = 1 << (31 - cinfo->comp_bits[k]); /* Color index precision in frac31. */
134	472k	frac31 u = c[k] & (v - 1);
135
136	472k	if (cg_num[k] == 0) {
137		/* No change. */
138	472k	continue;
139	472k	} 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	146k	}
160	4.39M	}
161	1.53M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
162	1.53M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
163	1.53M	if (si < ei) {
164	1.33M	if (fa->swap_axes) {
165	339k	rect.p.x = int2fixed(j);
166	339k	rect.p.y = int2fixed(si);
167	339k	rect.q.x = int2fixed(j + 1);
168	339k	rect.q.y = int2fixed(ei);
169	995k	} else {
170	995k	rect.p.x = int2fixed(si);
171	995k	rect.p.y = int2fixed(j);
172	995k	rect.q.x = int2fixed(ei);
173	995k	rect.q.y = int2fixed(j + 1);
174	995k	}
175	5.76M	for (k = 0; k < n; k++) {
176	4.42M	devc.colors.devn.values[k] = frac312cv(curr[k]);
177	4.42M	}
178	1.33M	devc.tag = device_current_tag(dev);
179	1.33M	return dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
180	1.33M	}
181	198k	return 0;
182	1.53M	}
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	1.53M	{
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	1.53M	bool devn = dev_proc(dev, dev_spec_op)(dev, gxdso_supports_devn, NULL, 0);
197	1.53M	frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
198	1.53M	ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
199	1.53M	int i, i1 = i0 + w, bi = i0, k;
200	1.53M	gx_color_index ci0 = 0, ci1;
201	1.53M	const gx_device_color_info *cinfo = &dev->color_info;
202	1.53M	int n = cinfo->num_components;
203	1.53M	int si, ei, di, code;
204
205		/* Todo: set this up to vector earlier */
206	1.53M	if (devn) /* Note, PDF14 could be additive and doing devn */
207	1.53M	return gx_hl_fill_linear_color_scanline(dev, fa, i0, j, w, c0, c0f,
208	1.53M	cg_num, cg_den);
209	0	if (j < fixed2int(fa->clip->p.y) \|\|
210	0	j > fixed2int_ceiling(fa->clip->q.y)) /* Must be compatible to the clipping logic. */
211	0	return 0;
212	0	for (k = 0; k < n; k++) {
213	0	int shift = cinfo->comp_shift[k];
214	0	int bits = cinfo->comp_bits[k];
215
216	0	c[k] = c0[k];
217	0	f[k] = c0f[k];
218	0	ci0 \|= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
219	0	}
220	0	for (i = i0 + 1, di = 1; i < i1; i += di) {
221	0	if (di == 1) {
222		/* Advance colors by 1 pixel. */
223	0	ci1 = 0;
224	0	for (k = 0; k < n; k++) {
225	0	int shift = cinfo->comp_shift[k];
226	0	int bits = cinfo->comp_bits[k];
227
228	0	if (cg_num[k]) {
229	0	int32_t m = f[k] + cg_num[k];
230
231	0	c[k] += m / cg_den;
232	0	m -= m / cg_den * cg_den;
233	0	if (m < 0) {
234	0	c[k]--;
235	0	m += cg_den;
236	0	}
237	0	f[k] = m;
238	0	}
239	0	ci1 \|= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
240	0	}
241	0	} else {
242		/* Advance colors by di pixels. */
243	0	ci1 = 0;
244	0	for (k = 0; k < n; k++) {
245	0	int shift = cinfo->comp_shift[k];
246	0	int bits = cinfo->comp_bits[k];
247
248	0	if (cg_num[k]) {
249	0	int64_t M = f[k] + (int64_t)cg_num[k] * di;
250	0	int32_t m;
251
252	0	c[k] += (frac31)(M / cg_den);
253	0	m = (int32_t)(M - M / cg_den * cg_den);
254	0	if (m < 0) {
255	0	c[k]--;
256	0	m += cg_den;
257	0	}
258	0	f[k] = m;
259	0	}
260	0	ci1 \|= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
261	0	}
262	0	}
263	0	if (ci1 != ci0) {
264	0	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
265	0	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
266	0	if (si < ei) {
267	0	if (fa->swap_axes) {
268	0	code = dev_proc(dev, fill_rectangle)(dev, j, si, 1, ei - si, ci0);
269	0	} else {
270	0	code = dev_proc(dev, fill_rectangle)(dev, si, j, ei - si, 1, ci0);
271	0	}
272	0	if (code < 0)
273	0	return code;
274	0	}
275	0	bi = i;
276	0	ci0 = ci1;
277	0	di = 1;
278	0	} else if (i == i1) {
279	0	i++;
280	0	break;
281	0	} else {
282		/* Compute a color change pixel analitically. */
283	0	di = i1 - i;
284	0	for (k = 0; k < n; k++) {
285	0	int32_t a;
286	0	int64_t x;
287	0	frac31 v = 1 << (31 - cinfo->comp_bits[k]); /* Color index precision in frac31. */
288	0	frac31 u = c[k] & (v - 1);
289
290	0	if (cg_num[k] == 0) {
291		/* No change. */
292	0	continue;
293	0	} if (cg_num[k] > 0) {
294		/* Solve[(f[k] + cg_num[k]x)/cg_den == v - u, x] /
295	0	a = v - u;
296	0	} else {
297		/* Solve[(f[k] + cg_num[k]x)/cg_den == - u - 1, x] /
298	0	a = -u - 1;
299	0	}
300	0	x = ((int64_t)a * cg_den - f[k]) / cg_num[k];
301	0	if (i + x >= i1)
302	0	continue;
303	0	else if (x < 0)
304	0	return_error(gs_error_unregistered); /* Must not happen. */
305	0	else if (di > (int)x) {
306	0	di = (int)x;
307	0	if (di <= 1) {
308	0	di = 1;
309	0	break;
310	0	}
311	0	}
312	0	}
313	0	}
314	0	}
315	0	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
316	0	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
317	0	if (si < ei) {
318	0	if (fa->swap_axes) {
319	0	return dev_proc(dev, fill_rectangle)(dev, j, si, 1, ei - si, ci0);
320	0	} else {
321	0	return dev_proc(dev, fill_rectangle)(dev, si, j, ei - si, 1, ci0);
322	0	}
323	0	}
324	0	return 0;
325	0	}