/src/ghostpdl/base/gdevdsha.c

Source
/* Copyright (C) 2001-2025 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;
    for (i = n; i < GX_DEVICE_COLOR_MAX_COMPONENTS; i++)
         devc.colors.devn.values[i] = 0;

    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-12-31 07:31

Line	Count	Source
1		/* Copyright (C) 2001-2025 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	26.3M	{
27	26.3M	int k;
28
29	47.4M	for (k = 0; k < num; k++) {
30	46.0M	if (devn1[k] != devn2[k]) {
31	24.9M	return true;
32	24.9M	}
33	46.0M	}
34	1.41M	return false;
35	26.3M	}
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	15.0M	{
42	15.0M	frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
43	15.0M	frac31 curr[GX_DEVICE_COLOR_MAX_COMPONENTS];
44	15.0M	ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
45	15.0M	int i, i1 = i0 + w, bi = i0, k;
46	15.0M	const gx_device_color_info *cinfo = &dev->color_info;
47	15.0M	int n = cinfo->num_components;
48	15.0M	int si, ei, di, code;
49	15.0M	gs_fixed_rect rect;
50	15.0M	gx_device_color devc;
51
52		/* Note: All the stepping math is done with frac color values */
53
54	15.0M	devc.type = gx_dc_type_devn;
55	923M	for (i = n; i < GX_DEVICE_COLOR_MAX_COMPONENTS; i++)
56	908M	devc.colors.devn.values[i] = 0;
57
58	15.0M	if (j < fixed2int(fa->clip->p.y) \|\|
59	15.0M	j > fixed2int_ceiling(fa->clip->q.y)) /* Must be compatible to the clipping logic. */
60	0	return 0;
61	70.4M	for (k = 0; k < n; k++) {
62	55.3M	curr[k] = c[k] = c0[k];
63	55.3M	f[k] = c0f[k];
64	55.3M	}
65	41.4M	for (i = i0 + 1, di = 1; i < i1; i += di) {
66	26.3M	if (di == 1) {
67		/* Advance colors by 1 pixel. */
68	115M	for (k = 0; k < n; k++) {
69	88.7M	if (cg_num[k]) {
70	62.8M	int32_t m = f[k] + cg_num[k];
71
72	62.8M	c[k] += m / cg_den;
73	62.8M	m -= m / cg_den * cg_den;
74	62.8M	if (m < 0) {
75	28.5M	c[k]--;
76	28.5M	m += cg_den;
77	28.5M	}
78	62.8M	f[k] = m;
79	62.8M	}
80	88.7M	}
81	26.3M	} else {
82		/* Advance colors by di pixels. */
83	0	for (k = 0; k < n; k++) {
84	0	if (cg_num[k]) {
85	0	int64_t M = f[k] + (int64_t)cg_num[k] * di;
86	0	int32_t m;
87
88	0	c[k] += (frac31)(M / cg_den);
89	0	m = (int32_t)(M - M / cg_den * cg_den);
90	0	if (m < 0) {
91	0	c[k]--;
92	0	m += cg_den;
93	0	}
94	0	f[k] = m;
95	0	}
96	0	}
97	0	}
98	26.3M	if (gx_devn_diff(c, curr, n)) {
99	24.9M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
100	24.9M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
101	24.9M	if (si < ei) {
102	23.4M	if (fa->swap_axes) {
103	0	rect.p.x = int2fixed(j);
104	0	rect.p.y = int2fixed(si);
105	0	rect.q.x = int2fixed(j + 1);
106	0	rect.q.y = int2fixed(ei);
107	23.4M	} else {
108	23.4M	rect.p.x = int2fixed(si);
109	23.4M	rect.p.y = int2fixed(j);
110	23.4M	rect.q.x = int2fixed(ei);
111	23.4M	rect.q.y = int2fixed(j + 1);
112	23.4M	}
113	102M	for (k = 0; k < n; k++) {
114	78.8M	devc.colors.devn.values[k] = frac312cv(curr[k]);
115	78.8M	}
116	23.4M	devc.tag = device_current_tag(dev);
117	23.4M	code = dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
118	23.4M	if (code < 0)
119	0	return code;
120	23.4M	}
121	24.9M	bi = i;
122	109M	for (k = 0; k < n; k++) {
123	84.2M	curr[k] = c[k];
124	84.2M	}
125	24.9M	di = 1;
126	24.9M	} else if (i == i1) {
127	0	i++;
128	0	break;
129	1.41M	} else {
130		/* Compute a color change pixel analytically. */
131	1.41M	di = i1 - i;
132	5.91M	for (k = 0; k < n; k++) {
133	4.50M	int32_t a;
134	4.50M	int64_t x;
135	4.50M	frac31 v = 1 << (31 - cinfo->comp_bits[k]); /* Color index precision in frac31. */
136	4.50M	frac31 u = c[k] & (v - 1);
137
138	4.50M	if (cg_num[k] == 0) {
139		/* No change. */
140	4.50M	continue;
141	4.50M	} if (cg_num[k] > 0) {
142		/* Solve[(f[k] + cg_num[k]x)/cg_den == v - u, x] /
143	0	a = v - u;
144	0	} else {
145		/* Solve[(f[k] + cg_num[k]x)/cg_den == - u - 1, x] /
146	0	a = -u - 1;
147	0	}
148	0	x = ((int64_t)a * cg_den - f[k]) / cg_num[k];
149	0	if (i + x >= i1)
150	0	continue;
151	0	else if (x < 0)
152	0	return_error(gs_error_unregistered); /* Must not happen. */
153	0	else if (di > (int)x) {
154	0	di = (int)x;
155	0	if (di <= 1) {
156	0	di = 1;
157	0	break;
158	0	}
159	0	}
160	0	}
161	1.41M	}
162	26.3M	}
163	15.0M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
164	15.0M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
165	15.0M	if (si < ei) {
166	13.7M	if (fa->swap_axes) {
167	3.83M	rect.p.x = int2fixed(j);
168	3.83M	rect.p.y = int2fixed(si);
169	3.83M	rect.q.x = int2fixed(j + 1);
170	3.83M	rect.q.y = int2fixed(ei);
171	9.89M	} else {
172	9.89M	rect.p.x = int2fixed(si);
173	9.89M	rect.p.y = int2fixed(j);
174	9.89M	rect.q.x = int2fixed(ei);
175	9.89M	rect.q.y = int2fixed(j + 1);
176	9.89M	}
177	64.3M	for (k = 0; k < n; k++) {
178	50.5M	devc.colors.devn.values[k] = frac312cv(curr[k]);
179	50.5M	}
180	13.7M	devc.tag = device_current_tag(dev);
181	13.7M	return dev_proc(dev, fill_rectangle_hl_color) (dev, &rect, NULL, &devc, NULL);
182	13.7M	}
183	1.33M	return 0;
184	15.0M	}
185
186		int
187		gx_default_fill_linear_color_scanline(gx_device dev, const gs_fill_attributes fa,
188		int i0, int j, int w,
189		const frac31 c0, const int32_t c0f, const int32_t *cg_num, int32_t cg_den)
190	153M	{
191		/* This default implementation decomposes the area into constant color rectangles.
192		Devices may supply optimized implementations with
193		the inversed nesting of the i,k cicles,
194		i.e. with enumerating planes first, with a direct writing to the raster,
195		and with a fixed bits per component.
196		*/
197		/* First determine if we are doing high level style colors or pure colors */
198	153M	bool devn = dev_proc(dev, dev_spec_op)(dev, gxdso_supports_devn, NULL, 0);
199	153M	frac31 c[GX_DEVICE_COLOR_MAX_COMPONENTS];
200	153M	ulong f[GX_DEVICE_COLOR_MAX_COMPONENTS];
201	153M	int i, i1 = i0 + w, bi = i0, k;
202	153M	gx_color_index ci0 = 0, ci1;
203	153M	const gx_device_color_info *cinfo = &dev->color_info;
204	153M	int n = cinfo->num_components;
205	153M	int si, ei, di, code;
206
207		/* Todo: set this up to vector earlier */
208	153M	if (devn) /* Note, PDF14 could be additive and doing devn */
209	15.0M	return gx_hl_fill_linear_color_scanline(dev, fa, i0, j, w, c0, c0f,
210	15.0M	cg_num, cg_den);
211	138M	if (j < fixed2int(fa->clip->p.y) \|\|
212	138M	j > fixed2int_ceiling(fa->clip->q.y)) /* Must be compatible to the clipping logic. */
213	0	return 0;
214	510M	for (k = 0; k < n; k++) {
215	372M	int shift = cinfo->comp_shift[k];
216	372M	int bits = cinfo->comp_bits[k];
217
218	372M	c[k] = c0[k];
219	372M	f[k] = c0f[k];
220	372M	ci0 \|= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
221	372M	}
222	3.02G	for (i = i0 + 1, di = 1; i < i1; i += di) {
223	2.89G	if (di == 1) {
224		/* Advance colors by 1 pixel. */
225	2.86G	ci1 = 0;
226	7.51G	for (k = 0; k < n; k++) {
227	4.65G	int shift = cinfo->comp_shift[k];
228	4.65G	int bits = cinfo->comp_bits[k];
229
230	4.65G	if (cg_num[k]) {
231	3.47G	int32_t m = f[k] + cg_num[k];
232
233	3.47G	c[k] += m / cg_den;
234	3.47G	m -= m / cg_den * cg_den;
235	3.47G	if (m < 0) {
236	2.86G	c[k]--;
237	2.86G	m += cg_den;
238	2.86G	}
239	3.47G	f[k] = m;
240	3.47G	}
241	4.65G	ci1 \|= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
242	4.65G	}
243	2.86G	} else {
244		/* Advance colors by di pixels. */
245	30.1M	ci1 = 0;
246	76.7M	for (k = 0; k < n; k++) {
247	46.5M	int shift = cinfo->comp_shift[k];
248	46.5M	int bits = cinfo->comp_bits[k];
249
250	46.5M	if (cg_num[k]) {
251	30.7M	int64_t M = f[k] + (int64_t)cg_num[k] * di;
252	30.7M	int32_t m;
253
254	30.7M	c[k] += (frac31)(M / cg_den);
255	30.7M	m = (int32_t)(M - M / cg_den * cg_den);
256	30.7M	if (m < 0) {
257	0	c[k]--;
258	0	m += cg_den;
259	0	}
260	30.7M	f[k] = m;
261	30.7M	}
262	46.5M	ci1 \|= (gx_color_index)(c[k] >> (sizeof(c[k]) * 8 - 1 - bits)) << shift;
263	46.5M	}
264	30.1M	}
265	2.89G	if (ci1 != ci0) {
266	177M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
267	177M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
268	177M	if (si < ei) {
269	119M	if (fa->swap_axes) {
270	0	code = dev_proc(dev, fill_rectangle)(dev, j, si, 1, ei - si, ci0);
271	119M	} else {
272	119M	code = dev_proc(dev, fill_rectangle)(dev, si, j, ei - si, 1, ci0);
273	119M	}
274	119M	if (code < 0)
275	0	return code;
276	119M	}
277	177M	bi = i;
278	177M	ci0 = ci1;
279	177M	di = 1;
280	2.71G	} else if (i == i1) {
281	0	i++;
282	0	break;
283	2.71G	} else {
284		/* Compute a color change pixel analitically. */
285	2.71G	di = i1 - i;
286	3.50G	for (k = 0; k < n; k++) {
287	3.45G	int32_t a;
288	3.45G	int64_t x;
289	3.45G	frac31 v = 1 << (31 - cinfo->comp_bits[k]); /* Color index precision in frac31. */
290	3.45G	frac31 u = c[k] & (v - 1);
291
292	3.45G	if (cg_num[k] == 0) {
293		/* No change. */
294	570M	continue;
295	2.88G	} if (cg_num[k] > 0) {
296		/* Solve[(f[k] + cg_num[k]x)/cg_den == v - u, x] /
297	292M	a = v - u;
298	2.59G	} else {
299		/* Solve[(f[k] + cg_num[k]x)/cg_den == - u - 1, x] /
300	2.59G	a = -u - 1;
301	2.59G	}
302	2.88G	x = ((int64_t)a * cg_den - f[k]) / cg_num[k];
303	2.88G	if (i + x >= i1)
304	32.5M	continue;
305	2.85G	else if (x < 0)
306	0	return_error(gs_error_unregistered); /* Must not happen. */
307	2.85G	else if (di > (int)x) {
308	2.78G	di = (int)x;
309	2.78G	if (di <= 1) {
310	2.66G	di = 1;
311	2.66G	break;
312	2.66G	}
313	2.78G	}
314	2.88G	}
315	2.71G	}
316	2.89G	}
317	138M	si = max(bi, fixed2int(fa->clip->p.x)); /* Must be compatible to the clipping logic. */
318	138M	ei = min(i, fixed2int_ceiling(fa->clip->q.x)); /* Must be compatible to the clipping logic. */
319	138M	if (si < ei) {
320	110M	if (fa->swap_axes) {
321	37.1M	return dev_proc(dev, fill_rectangle)(dev, j, si, 1, ei - si, ci0);
322	73.6M	} else {
323	73.6M	return dev_proc(dev, fill_rectangle)(dev, si, j, ei - si, 1, ci0);
324	73.6M	}
325	110M	}
326	27.4M	return 0;
327	138M	}