/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:56

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	9.25M	{
27	9.25M	int k;
28
29	16.9M	for (k = 0; k < num; k++) {
30	16.3M	if (devn1[k] != devn2[k]) {
31	8.69M	return true;
32	8.69M	}
33	16.3M	}
34	552k	return false;
35	9.25M	}
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	5.87M	{
42	5.87M	frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
43	5.87M	frac31 curr[GX_DEVICE_COLOR_MAX_COMPONENTS];
44	5.87M	ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
45	5.87M	int i, i1 = i0 + w, bi = i0, k;
46	5.87M	const gx_device_color_info *cinfo = &dev->color_info;
47	5.87M	int n = cinfo->num_components;
48	5.87M	int si, ei, di, code;
49	5.87M	gs_fixed_rect rect;
50	5.87M	gx_device_color devc;
51
52		/* Note: All the stepping math is done with frac color values */
53
54	5.87M	devc.type = gx_dc_type_devn;
55
56	5.87M	if (j < fixed2int(fa->clip->p.y) \|\|
57	5.87M	j > fixed2int_ceiling(fa->clip->q.y)) /* Must be compatible to the clipping logic. */
58	0	return 0;
59	27.8M	for (k = 0; k < n; k++) {
60	22.0M	curr[k] = c[k] = c0[k];
61	22.0M	f[k] = c0f[k];
62	22.0M	}
63	15.1M	for (i = i0 + 1, di = 1; i < i1; i += di) {
64	9.25M	if (di == 1) {
65		/* Advance colors by 1 pixel. */
66	44.1M	for (k = 0; k < n; k++) {
67	34.9M	if (cg_num[k]) {
68	24.5M	int32_t m = f[k] + cg_num[k];
69
70	24.5M	c[k] += m / cg_den;
71	24.5M	m -= m / cg_den * cg_den;
72	24.5M	if (m < 0) {
73	10.9M	c[k]--;
74	10.9M	m += cg_den;
75	10.9M	}
76	24.5M	f[k] = m;
77	24.5M	}
78	34.9M	}
79	9.25M	} 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	9.25M	if (gx_devn_diff(c, curr, n)) {
97	8.69M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
98	8.69M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
99	8.69M	if (si < ei) {
100	8.01M	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	8.01M	} else {
106	8.01M	rect.p.x = int2fixed(si);
107	8.01M	rect.p.y = int2fixed(j);
108	8.01M	rect.q.x = int2fixed(ei);
109	8.01M	rect.q.y = int2fixed(j + 1);
110	8.01M	}
111	38.6M	for (k = 0; k < n; k++) {
112	30.6M	devc.colors.devn.values[k] = frac312cv(curr[k]);
113	30.6M	}
114	8.01M	devc.tag = device_current_tag(dev);
115	8.01M	code = dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
116	8.01M	if (code < 0)
117	0	return code;
118	8.01M	}
119	8.69M	bi = i;
120	41.7M	for (k = 0; k < n; k++) {
121	33.0M	curr[k] = c[k];
122	33.0M	}
123	8.69M	di = 1;
124	8.69M	} else if (i == i1) {
125	0	i++;
126	0	break;
127	552k	} else {
128		/* Compute a color change pixel analytically. */
129	552k	di = i1 - i;
130	2.39M	for (k = 0; k < n; k++) {
131	1.84M	int32_t a;
132	1.84M	int64_t x;
133	1.84M	frac31 v = 1 << (31 - cinfo->comp_bits[k]); /* Color index precision in frac31. */
134	1.84M	frac31 u = c[k] & (v - 1);
135
136	1.84M	if (cg_num[k] == 0) {
137		/* No change. */
138	1.84M	continue;
139	1.84M	} 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	552k	}
160	9.25M	}
161	5.87M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
162	5.87M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
163	5.87M	if (si < ei) {
164	5.37M	if (fa->swap_axes) {
165	1.43M	rect.p.x = int2fixed(j);
166	1.43M	rect.p.y = int2fixed(si);
167	1.43M	rect.q.x = int2fixed(j + 1);
168	1.43M	rect.q.y = int2fixed(ei);
169	3.93M	} else {
170	3.93M	rect.p.x = int2fixed(si);
171	3.93M	rect.p.y = int2fixed(j);
172	3.93M	rect.q.x = int2fixed(ei);
173	3.93M	rect.q.y = int2fixed(j + 1);
174	3.93M	}
175	25.5M	for (k = 0; k < n; k++) {
176	20.1M	devc.colors.devn.values[k] = frac312cv(curr[k]);
177	20.1M	}
178	5.37M	devc.tag = device_current_tag(dev);
179	5.37M	return dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
180	5.37M	}
181	498k	return 0;
182	5.87M	}
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	5.87M	{
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	5.87M	bool devn = dev_proc(dev, dev_spec_op)(dev, gxdso_supports_devn, NULL, 0);
197	5.87M	frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
198	5.87M	ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
199	5.87M	int i, i1 = i0 + w, bi = i0, k;
200	5.87M	gx_color_index ci0 = 0, ci1;
201	5.87M	const gx_device_color_info *cinfo = &dev->color_info;
202	5.87M	int n = cinfo->num_components;
203	5.87M	int si, ei, di, code;
204
205		/* Todo: set this up to vector earlier */
206	5.87M	if (devn) /* Note, PDF14 could be additive and doing devn */
207	5.87M	return gx_hl_fill_linear_color_scanline(dev, fa, i0, j, w, c0, c0f,
208	5.87M	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	}