int
gx_san_generate_stems(gx_device_spot_analyzer *padev,
bool overall_hints, void *client_data,
int (*handler)(void *client_data, gx_san_sect *ss))
{
int code;
bool got_dc = false;
vd_save;
if (vd_allowed('F') || vd_allowed('f')) {
if (!vd_enabled) {
vd_get_dc('f');
got_dc = vd_enabled;
}
if (vd_enabled) {
vd_set_shift(0, 0);
vd_set_scale(VD_SCALE);
vd_set_origin(0, 0);
}
} else
vd_disable;
code = gx_san_generate_stems_aux(padev, overall_hints, client_data, handler);
if (got_dc)
vd_release_dc;
vd_restore;
return code;
}
int
gs_image_next_planes(gs_image_enum * penum,
gs_const_string *plane_data /*[num_planes]*/,
uint *used /*[num_planes]*/)
{
const int num_planes = penum->num_planes;
int i;
int code = 0;
#ifdef DEBUG
vd_get_dc('i');
vd_set_shift(0, 0);
vd_set_scale(0.01);
vd_set_origin(0, 0);
if (gs_debug_c('b')) {
int pi;
for (pi = 0; pi < num_planes; ++pi)
dprintf6("[b]plane %d source=0x%lx,%u pos=%u data=0x%lx,%u\n",
pi, (ulong)penum->planes[pi].source.data,
penum->planes[pi].source.size, penum->planes[pi].pos,
(ulong)plane_data[pi].data, plane_data[pi].size);
}
#endif
for (i = 0; i < num_planes; ++i) {
used[i] = 0;
if (penum->wanted[i] && plane_data[i].size != 0) {
penum->planes[i].source.size = plane_data[i].size;
penum->planes[i].source.data = plane_data[i].data;
}
}
for (;;) {
/* If wanted can vary, only transfer 1 row at a time. */
int h = (penum->wanted_varies ? 1 : max_int);
/* Move partial rows from source[] to row[]. */
for (i = 0; i < num_planes; ++i) {
int pos, size;
uint raster;
if (!penum->wanted[i])
continue; /* skip unwanted planes */
pos = penum->planes[i].pos;
size = penum->planes[i].source.size;
raster = penum->image_planes[i].raster;
if (size > 0) {
if (pos < raster && (pos != 0 || size < raster)) {
/* Buffer a partial row. */
int copy = min(size, raster - pos);
uint old_size = penum->planes[i].row.size;
/* Make sure the row buffer is fully allocated. */
if (raster > old_size) {
gs_memory_t *mem = gs_image_row_memory(penum);
byte *old_data = penum->planes[i].row.data;
byte *row =
(old_data == 0 ?
gs_alloc_string(mem, raster,
"gs_image_next(row)") :
gs_resize_string(mem, old_data, old_size, raster,
"gs_image_next(row)"));
if_debug5('b', "[b]plane %d row (0x%lx,%u) => (0x%lx,%u)\n",
i, (ulong)old_data, old_size,
(ulong)row, raster);
if (row == 0) {
code = gs_note_error(gs_error_VMerror);
free_row_buffers(penum, i, "gs_image_next(row)");
break;
}
penum->planes[i].row.data = row;
penum->planes[i].row.size = raster;
}
memcpy(penum->planes[i].row.data + pos,
penum->planes[i].source.data, copy);
penum->planes[i].source.data += copy;
penum->planes[i].source.size = size -= copy;
penum->planes[i].pos = pos += copy;
used[i] += copy;
}
}
if (h == 0)
continue; /* can't transfer any data this cycle */
if (pos == raster) {
/*
* This plane will be transferred from the row buffer,
* so we can only transfer one row.
*/
h = min(h, 1);
penum->image_planes[i].data = penum->planes[i].row.data;
} else if (pos == 0 && size >= raster) {
/* We can transfer 1 or more planes from the source. */
h = min(h, size / raster);
penum->image_planes[i].data = penum->planes[i].source.data;
} else
h = 0; /* not enough data in this plane */
}
if (h == 0 || code != 0)
break;
/* Pass rows to the device. */
if (penum->dev == 0) {
/*
* ****** NOTE: THE FOLLOWING IS NOT CORRECT FOR ImageType 3
* ****** InterleaveType 2, SINCE MASK HEIGHT AND IMAGE HEIGHT
* ****** MAY DIFFER (BY AN INTEGER FACTOR). ALSO, plane_depths[0]
* ****** AND plane_widths[0] ARE NOT UPDATED.
*/
if (penum->y + h < penum->height)
code = 0;
else
h = penum->height - penum->y, code = 1;
} else {
code = gx_image_plane_data_rows(penum->info, penum->image_planes,
h, &h);
if_debug2('b', "[b]used %d, code=%d\n", h, code);
penum->error = code < 0;
}
penum->y += h;
/* Update positions and sizes. */
if (h == 0)
break;
for (i = 0; i < num_planes; ++i) {
int count;
if (!penum->wanted[i])
continue;
count = penum->image_planes[i].raster * h;
if (penum->planes[i].pos) {
/* We transferred the row from the row buffer. */
penum->planes[i].pos = 0;
} else {
/* We transferred the row(s) from the source. */
penum->planes[i].source.data += count;
penum->planes[i].source.size -= count;
used[i] += count;
}
}
cache_planes(penum);
if (code > 0)
break;
}
/* Return the retained data pointers. */
for (i = 0; i < num_planes; ++i)
plane_data[i] = penum->planes[i].source;
vd_release_dc;
return code;
}
int
gs_shading_FfGt_fill_rectangle(const gs_shading_t * psh0, const gs_rect * rect,
const gs_fixed_rect * rect_clip,
gx_device * dev, gs_imager_state * pis)
{
const gs_shading_FfGt_t * const psh = (const gs_shading_FfGt_t *)psh0;
patch_fill_state_t pfs;
const gs_shading_mesh_t *pshm = (const gs_shading_mesh_t *)psh;
shade_coord_stream_t cs;
int num_bits = psh->params.BitsPerFlag;
int flag;
shading_vertex_t va, vb, vc;
patch_color_t *c, *C[3], *ca, *cb, *cc; /* va.c == ca && vb.c == cb && vc.c == cc always,
provides a non-const access. */
int code;
if (VD_TRACE_TRIANGLE_PATCH && vd_allowed('s')) {
vd_get_dc('s');
vd_set_shift(0, 0);
vd_set_scale(0.01);
vd_set_origin(0, 0);
}
shade_init_fill_state((shading_fill_state_t *)&pfs,
(const gs_shading_t *)psh, dev, pis);
pfs.Function = pshm->params.Function;
pfs.rect = *rect_clip;
code = init_patch_fill_state(&pfs);
if (code < 0) {
if (pfs.icclink != NULL) gsicc_release_link(pfs.icclink);
return code;
}
reserve_colors(&pfs, C, 3); /* Can't fail */
va.c = ca = C[0];
vb.c = cb = C[1];
vc.c = cc = C[2];
shade_next_init(&cs, (const gs_shading_mesh_params_t *)&psh->params,
pis);
/* CET 09-47J.PS SpecialTestI04Test01 does not need the color data alignment. */
while ((flag = shade_next_flag(&cs, num_bits)) >= 0) {
switch (flag) {
default:
return_error(gs_error_rangecheck);
case 0:
if ((code = Gt_next_vertex(pshm, &cs, &va, ca)) < 0 ||
(code = shade_next_flag(&cs, num_bits)) < 0 ||
(code = Gt_next_vertex(pshm, &cs, &vb, cb)) < 0 ||
(code = shade_next_flag(&cs, num_bits)) < 0
)
break;
goto v2;
case 1:
c = ca;
va = vb;
ca = cb;
vb.c = cb = c;
case 2:
c = cb;
vb = vc;
cb = cc;
vc.c = cc = c;
v2: if ((code = Gt_next_vertex(pshm, &cs, &vc, cc)) < 0)
break;
if ((code = Gt_fill_triangle(&pfs, &va, &vb, &vc)) < 0)
break;
}
cs.align(&cs, 8); /* Debugged with 12-14O.PS page 2. */
}
if (VD_TRACE_TRIANGLE_PATCH && vd_allowed('s'))
vd_release_dc;
release_colors(&pfs, pfs.color_stack, 3);
if (term_patch_fill_state(&pfs))
return_error(gs_error_unregistered); /* Must not happen. */
if (!cs.is_eod(&cs))
return_error(gs_error_rangecheck);
if (pfs.icclink != NULL) gsicc_release_link(pfs.icclink);
return code;
}
int
gs_shading_LfGt_fill_rectangle(const gs_shading_t * psh0, const gs_rect * rect,
const gs_fixed_rect * rect_clip,
gx_device * dev, gs_imager_state * pis)
{
const gs_shading_LfGt_t * const psh = (const gs_shading_LfGt_t *)psh0;
patch_fill_state_t pfs;
const gs_shading_mesh_t *pshm = (const gs_shading_mesh_t *)psh;
shade_coord_stream_t cs;
shading_vertex_t *vertex = NULL;
byte *color_buffer = NULL;
patch_color_t **color_buffer_ptrs = NULL; /* non-const access to vertex[i].c */
shading_vertex_t next;
int per_row = psh->params.VerticesPerRow;
patch_color_t *c, *cn; /* cn == next.c always, provides a non-contst access. */
int i, code;
if (VD_TRACE_TRIANGLE_PATCH && vd_allowed('s')) {
vd_get_dc('s');
vd_set_shift(0, 0);
vd_set_scale(0.01);
vd_set_origin(0, 0);
}
shade_init_fill_state((shading_fill_state_t *)&pfs,
(const gs_shading_t *)psh, dev, pis);
pfs.Function = pshm->params.Function;
pfs.rect = *rect_clip;
code = init_patch_fill_state(&pfs);
if (code < 0)
goto out;
reserve_colors(&pfs, &cn, 1); /* Can't fail. */
next.c = cn;
shade_next_init(&cs, (const gs_shading_mesh_params_t *)&psh->params,
pis);
vertex = (shading_vertex_t *)
gs_alloc_byte_array(pis->memory, per_row, sizeof(*vertex),
"gs_shading_LfGt_render");
if (vertex == NULL) {
code = gs_note_error(gs_error_VMerror);
goto out;
}
color_buffer = gs_alloc_bytes(pis->memory, pfs.color_stack_step * per_row, "gs_shading_LfGt_fill_rectangle");
if (color_buffer == NULL) {
code = gs_note_error(gs_error_VMerror);
goto out;
}
color_buffer_ptrs = (patch_color_t **)gs_alloc_bytes(pis->memory,
sizeof(patch_color_t *) * per_row, "gs_shading_LfGt_fill_rectangle");
if (color_buffer_ptrs == NULL) {
code = gs_note_error(gs_error_VMerror);
goto out;
}
/* CET 09-47K.PS SpecialTestJ02Test05 needs the color data alignment. */
for (i = 0; i < per_row; ++i) {
color_buffer_ptrs[i] = (patch_color_t *)(color_buffer + pfs.color_stack_step * i);
vertex[i].c = color_buffer_ptrs[i];
if ((code = Gt_next_vertex(pshm, &cs, &vertex[i], color_buffer_ptrs[i])) < 0)
goto out;
}
while (!seofp(cs.s)) {
code = Gt_next_vertex(pshm, &cs, &next, cn);
if (code < 0)
goto out;
for (i = 1; i < per_row; ++i) {
code = Gt_fill_triangle(&pfs, &vertex[i - 1], &vertex[i], &next);
if (code < 0)
goto out;
c = color_buffer_ptrs[i - 1];
vertex[i - 1] = next;
color_buffer_ptrs[i - 1] = cn;
next.c = cn = c;
code = Gt_next_vertex(pshm, &cs, &next, cn);
if (code < 0)
goto out;
code = Gt_fill_triangle(&pfs, &vertex[i], &vertex[i - 1], &next);
if (code < 0)
goto out;
}
c = color_buffer_ptrs[per_row - 1];
vertex[per_row - 1] = next;
color_buffer_ptrs[per_row - 1] = cn;
next.c = cn = c;
}
out:
if (VD_TRACE_TRIANGLE_PATCH && vd_allowed('s'))
vd_release_dc;
gs_free_object(pis->memory, vertex, "gs_shading_LfGt_render");
gs_free_object(pis->memory, color_buffer, "gs_shading_LfGt_render");
gs_free_object(pis->memory, color_buffer_ptrs, "gs_shading_LfGt_render");
release_colors(&pfs, pfs.color_stack, 1);
if (term_patch_fill_state(&pfs))
return_error(gs_error_unregistered); /* Must not happen. */
if (pfs.icclink != NULL) gsicc_release_link(pfs.icclink);
return code;
}