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

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