int
gx_image_plane_data(gx_image_enum_common_t * info,
const gx_image_plane_t * planes, int height)
{
int ignore_rows_used;
return gx_image_plane_data_rows(info, planes, height, &ignore_rows_used);
}
static int
bbox_image_plane_data(gx_image_enum_common_t * info,
const gx_image_plane_t * planes, int height,
int *rows_used)
{
gx_device *dev = info->dev;
gx_device_bbox *const bdev = (gx_device_bbox *)dev;
gx_device *tdev = bdev->target;
bbox_image_enum *pbe = (bbox_image_enum *) info;
const gx_clip_path *pcpath = pbe->pcpath;
gs_rect sbox, dbox;
gs_point corners[4];
gs_fixed_rect ibox;
int code;
code = gx_image_plane_data_rows(pbe->target_info, planes, height,
rows_used);
if (code != 1 && !pbe->params_are_const)
bbox_image_copy_target_info(pbe);
sbox.p.x = pbe->x0;
sbox.p.y = pbe->y;
sbox.q.x = pbe->x1;
sbox.q.y = pbe->y = min(pbe->y + height, pbe->height);
gs_bbox_transform_only(&sbox, &pbe->matrix, corners);
gs_points_bbox(corners, &dbox);
ibox.p.x = float2fixed(dbox.p.x);
ibox.p.y = float2fixed(dbox.p.y);
ibox.q.x = float2fixed(dbox.q.x);
ibox.q.y = float2fixed(dbox.q.y);
if (pcpath != NULL &&
!gx_cpath_includes_rectangle(pcpath, ibox.p.x, ibox.p.y,
ibox.q.x, ibox.q.y)
) {
/* Let the target do the drawing, but drive two triangles */
/* through the clipping path to get an accurate bounding box. */
gx_device_clip cdev;
gx_drawing_color devc;
fixed x0 = float2fixed(corners[0].x), y0 = float2fixed(corners[0].y);
fixed bx2 = float2fixed(corners[2].x) - x0, by2 = float2fixed(corners[2].y) - y0;
gx_make_clip_device_on_stack(&cdev, pcpath, dev);
set_nonclient_dev_color(&devc, bdev->black); /* any non-white color will do */
bdev->target = NULL;
gx_default_fill_triangle((gx_device *) & cdev, x0, y0,
float2fixed(corners[1].x) - x0,
float2fixed(corners[1].y) - y0,
bx2, by2, &devc, lop_default);
gx_default_fill_triangle((gx_device *) & cdev, x0, y0,
float2fixed(corners[3].x) - x0,
float2fixed(corners[3].y) - y0,
bx2, by2, &devc, lop_default);
bdev->target = tdev;
} else {
/* Just use the bounding box. */
BBOX_ADD_RECT(bdev, ibox.p.x, ibox.p.y, ibox.q.x, ibox.q.y);
}
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;
}
