static void
fz_mesh_type5_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
{
fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
fz_vertex *buf = NULL;
fz_vertex *ref = NULL;
int first;
int ncomp;
int i, k;
int vprow = shade->u.m.vprow;
int bpcoord = shade->u.m.bpcoord;
int bpcomp = shade->u.m.bpcomp;
float x0 = shade->u.m.x0;
float x1 = shade->u.m.x1;
float y0 = shade->u.m.y0;
float y1 = shade->u.m.y1;
float *c0 = shade->u.m.c0;
float *c1 = shade->u.m.c1;
fz_var(buf);
fz_var(ref);
fz_try(ctx)
{
ref = fz_malloc_array(ctx, vprow, sizeof(fz_vertex));
buf = fz_malloc_array(ctx, vprow, sizeof(fz_vertex));
first = 1;
ncomp = (shade->use_function > 0 ? 1 : shade->colorspace->n);
while (!fz_is_eof_bits(stream))
{
for (i = 0; i < vprow; i++)
{
buf[i].p.x = read_sample(stream, bpcoord, x0, x1);
buf[i].p.y = read_sample(stream, bpcoord, y0, y1);
fz_transform_point(&buf[i].p, ctm);
for (k = 0; k < ncomp; k++)
buf[i].c[k] = read_sample(stream, bpcomp, c0[k], c1[k]);
}
if (!first)
for (i = 0; i < vprow - 1; i++)
paint_quad(painter, &ref[i], &ref[i+1], &buf[i+1], &buf[i]);
SWAP(ref,buf);
first = 0;
}
}
fz_always(ctx)
{
fz_free(ctx, ref);
fz_free(ctx, buf);
fz_close(stream);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
static void
fz_process_mesh_type5(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
{
fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
fz_vertex *buf = NULL;
fz_vertex *ref = NULL;
int first;
int ncomp = painter->ncomp;
int i, k;
int vprow = shade->u.m.vprow;
int bpcoord = shade->u.m.bpcoord;
int bpcomp = shade->u.m.bpcomp;
float x0 = shade->u.m.x0;
float x1 = shade->u.m.x1;
float y0 = shade->u.m.y0;
float y1 = shade->u.m.y1;
float *c0 = shade->u.m.c0;
float *c1 = shade->u.m.c1;
float x, y, c[FZ_MAX_COLORS];
fz_var(buf);
fz_var(ref);
fz_try(ctx)
{
ref = fz_malloc_array(ctx, vprow, sizeof(fz_vertex));
buf = fz_malloc_array(ctx, vprow, sizeof(fz_vertex));
first = 1;
while (!fz_is_eof_bits(ctx, stream))
{
for (i = 0; i < vprow; i++)
{
x = read_sample(ctx, stream, bpcoord, x0, x1);
y = read_sample(ctx, stream, bpcoord, y0, y1);
for (k = 0; k < ncomp; k++)
c[k] = read_sample(ctx, stream, bpcomp, c0[k], c1[k]);
fz_prepare_vertex(ctx, painter, &buf[i], ctm, x, y, c);
}
if (!first)
for (i = 0; i < vprow - 1; i++)
paint_quad(ctx, painter, &ref[i], &ref[i+1], &buf[i+1], &buf[i]);
SWAP(ref,buf);
first = 0;
}
}
fz_always(ctx)
{
fz_free(ctx, ref);
fz_free(ctx, buf);
fz_drop_stream(ctx, stream);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
static void
fz_test_fill_image(fz_context *ctx, fz_device *dev_, fz_image *image, fz_matrix ctm, float alpha, const fz_color_params *color_params)
{
fz_test_device *dev = (fz_test_device*)dev_;
while (dev->resolved == 0) /* So we can break out */
{
fz_compressed_buffer *buffer;
if (*dev->is_color || !image->colorspace || fz_colorspace_is_gray(ctx, image->colorspace))
break;
if ((dev->options & FZ_TEST_OPT_IMAGES) == 0)
{
/* Don't test every pixel. Upgrade us from "black and white" to "probably color" */
if (*dev->is_color == 0)
*dev->is_color = 1;
dev->resolved = 1;
if (dev->passthrough == NULL)
fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation");
break;
}
buffer = fz_compressed_image_buffer(ctx, image);
if (buffer && image->bpc == 8)
{
fz_stream *stream = fz_open_compressed_buffer(ctx, buffer);
fz_try(ctx)
fz_test_fill_compressed_8bpc_image(ctx, dev, image, stream, color_params);
fz_always(ctx)
fz_drop_stream(ctx, stream);
fz_catch(ctx)
fz_rethrow(ctx);
}
else
{
fz_pixmap *pix = fz_get_pixmap_from_image(ctx, image, NULL, NULL, 0, 0);
if (pix == NULL) /* Should never happen really, but... */
break;
fz_try(ctx)
fz_test_fill_other_image(ctx, dev, pix, color_params);
fz_always(ctx)
fz_drop_pixmap(ctx, pix);
fz_catch(ctx)
fz_rethrow(ctx);
}
break;
}
if (dev->passthrough)
fz_fill_image(ctx, dev->passthrough, image, ctm, alpha, color_params);
}
static void
fz_test_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha)
{
fz_test_device *t = (fz_test_device*)dev;
fz_pixmap *pix;
unsigned int count, i, k;
unsigned char *s;
if (*t->is_color || !image->colorspace || image->colorspace == fz_device_gray(ctx))
return;
if (image->buffer && image->bpc == 8)
{
fz_stream *stream = fz_open_compressed_buffer(ctx, image->buffer);
count = (unsigned int)image->w * (unsigned int)image->h;
if (image->colorspace == fz_device_rgb(ctx))
{
int threshold_u8 = t->threshold * 255;
for (i = 0; i < count; i++)
{
int r = fz_read_byte(ctx, stream);
int g = fz_read_byte(ctx, stream);
int b = fz_read_byte(ctx, stream);
if (is_rgb_color_u8(threshold_u8, r, g, b))
{
*t->is_color = 1;
dev->hints |= FZ_IGNORE_IMAGE;
fz_drop_stream(ctx, stream);
fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation");
break;
}
}
}
else
{
fz_color_converter cc;
unsigned int n = (unsigned int)image->n;
fz_init_cached_color_converter(ctx, &cc, fz_device_rgb(ctx), image->colorspace);
for (i = 0; i < count; i++)
{
float cs[FZ_MAX_COLORS];
float ds[FZ_MAX_COLORS];
for (k = 0; k < n; k++)
cs[k] = fz_read_byte(ctx, stream) / 255.0f;
cc.convert(ctx, &cc, ds, cs);
if (is_rgb_color(t->threshold, ds[0], ds[1], ds[2]))
{
*t->is_color = 1;
dev->hints |= FZ_IGNORE_IMAGE;
break;
}
}
fz_fin_cached_color_converter(ctx, &cc);
}
fz_drop_stream(ctx, stream);
return;
}
pix = fz_new_pixmap_from_image(ctx, image, 0, 0);
if (pix == NULL) /* Should never happen really, but... */
return;
count = (unsigned int)pix->w * (unsigned int)pix->h;
s = pix->samples;
if (pix->colorspace == fz_device_rgb(ctx))
{
int threshold_u8 = t->threshold * 255;
for (i = 0; i < count; i++)
{
if (s[3] != 0 && is_rgb_color_u8(threshold_u8, s[0], s[1], s[2]))
{
*t->is_color = 1;
dev->hints |= FZ_IGNORE_IMAGE;
fz_drop_pixmap(ctx, pix);
fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation");
break;
}
s += 4;
}
}
else
{
fz_color_converter cc;
unsigned int n = (unsigned int)pix->n-1;
fz_init_cached_color_converter(ctx, &cc, fz_device_rgb(ctx), pix->colorspace);
for (i = 0; i < count; i++)
{
float cs[FZ_MAX_COLORS];
float ds[FZ_MAX_COLORS];
for (k = 0; k < n; k++)
cs[k] = (*s++) / 255.0f;
if (*s++ == 0)
continue;
cc.convert(ctx, &cc, ds, cs);
if (is_rgb_color(t->threshold, ds[0], ds[1], ds[2]))
{
*t->is_color = 1;
dev->hints |= FZ_IGNORE_IMAGE;
fz_drop_pixmap(ctx, pix);
fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation");
break;
}
}
fz_fin_cached_color_converter(ctx, &cc);
}
fz_drop_pixmap(ctx, pix);
}
static void
fz_test_fill_image(fz_context *ctx, fz_device *dev_, fz_image *image, const fz_matrix *ctm, float alpha, const fz_color_params *color_params)
{
fz_test_device *dev = (fz_test_device*)dev_;
while (dev->resolved == 0) /* So we can break out */
{
fz_pixmap *pix;
unsigned int count, i, k, h, sa, ss;
unsigned char *s;
fz_compressed_buffer *buffer;
if (*dev->is_color || !image->colorspace || fz_colorspace_is_gray(ctx, image->colorspace))
break;
if ((dev->options & FZ_TEST_OPT_IMAGES) == 0)
{
/* Don't test every pixel. Upgrade us from "black and white" to "probably color" */
if (*dev->is_color == 0)
*dev->is_color = 1;
dev->resolved = 1;
if (dev->passthrough == NULL)
fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation");
break;
}
buffer = fz_compressed_image_buffer(ctx, image);
if (buffer && image->bpc == 8)
{
fz_stream *stream = fz_open_compressed_buffer(ctx, buffer);
count = (unsigned int)image->w * (unsigned int)image->h;
if (image->colorspace == fz_device_rgb(ctx))
{
int threshold_u8 = dev->threshold * 255;
for (i = 0; i < count; i++)
{
int r = fz_read_byte(ctx, stream);
int g = fz_read_byte(ctx, stream);
int b = fz_read_byte(ctx, stream);
if (is_rgb_color_u8(threshold_u8, r, g, b))
{
*dev->is_color = 1;
dev->resolved = 1;
fz_drop_stream(ctx, stream);
if (dev->passthrough == NULL)
fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation");
break;
}
}
}
else
{
fz_color_converter cc;
unsigned int n = (unsigned int)image->n;
fz_init_cached_color_converter(ctx, &cc, NULL, fz_device_rgb(ctx), image->colorspace, color_params);
fz_try(ctx)
{
for (i = 0; i < count; i++)
{
float cs[FZ_MAX_COLORS];
float ds[FZ_MAX_COLORS];
for (k = 0; k < n; k++)
cs[k] = fz_read_byte(ctx, stream) / 255.0f;
cc.convert(ctx, &cc, ds, cs);
if (is_rgb_color(dev->threshold, ds[0], ds[1], ds[2]))
{
*dev->is_color = 1;
dev->resolved = 1;
if (dev->passthrough == NULL)
{
fz_drop_stream(ctx, stream);
fz_fin_cached_color_converter(ctx, &cc);
fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation");
}
break;
}
}
}
fz_always(ctx)
fz_fin_cached_color_converter(ctx, &cc);
fz_catch(ctx)
fz_rethrow(ctx);
}
fz_drop_stream(ctx, stream);
break;
}
pix = fz_get_pixmap_from_image(ctx, image, NULL, NULL, 0, 0);
if (pix == NULL) /* Should never happen really, but... */
break;
count = pix->w;
h = pix->h;
s = pix->samples;
sa = pix->alpha;
ss = pix->stride - pix->w * pix->n;
if (pix->colorspace == fz_device_rgb(ctx))
{
int threshold_u8 = dev->threshold * 255;
while (h--)
{
for (i = 0; i < count; i++)
{
if ((!sa || s[3] != 0) && is_rgb_color_u8(threshold_u8, s[0], s[1], s[2]))
{
*dev->is_color = 1;
dev->resolved = 1;
if (dev->passthrough == NULL)
{
fz_drop_pixmap(ctx, pix);
fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation");
}
break;
}
s += 3 + sa;
}
s += ss;
}
}
else
{
fz_color_converter cc;
unsigned int n = (unsigned int)pix->n-1;
fz_init_cached_color_converter(ctx, &cc, NULL, fz_device_rgb(ctx), pix->colorspace, color_params);
fz_try(ctx)
{
while (h--)
{
for (i = 0; i < count; i++)
{
float cs[FZ_MAX_COLORS];
float ds[FZ_MAX_COLORS];
for (k = 0; k < n; k++)
cs[k] = (*s++) / 255.0f;
if (sa && *s++ == 0)
continue;
cc.convert(ctx, &cc, ds, cs);
if (is_rgb_color(dev->threshold, ds[0], ds[1], ds[2]))
{
*dev->is_color = 1;
dev->resolved = 1;
if (dev->passthrough == NULL)
{
fz_fin_cached_color_converter(ctx, &cc);
fz_drop_pixmap(ctx, pix);
fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation");
}
break;
}
}
s += ss;
}
}
fz_always(ctx)
fz_fin_cached_color_converter(ctx, &cc);
fz_catch(ctx)
fz_rethrow(ctx);
}
fz_drop_pixmap(ctx, pix);
break;
}
static void
fz_mesh_type7_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
{
fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
int bpflag = shade->u.m.bpflag;
int bpcoord = shade->u.m.bpcoord;
int bpcomp = shade->u.m.bpcomp;
float x0 = shade->u.m.x0;
float x1 = shade->u.m.x1;
float y0 = shade->u.m.y0;
float y1 = shade->u.m.y1;
float *c0 = shade->u.m.c0;
float *c1 = shade->u.m.c1;
float prevc[4][FZ_MAX_COLORS];
fz_point prevp[16];
int ncomp;
int i, k;
int haspatch, hasprevpatch;
fz_try(ctx)
{
hasprevpatch = 0;
ncomp = (shade->use_function > 0 ? 1 : shade->colorspace->n);
while (!fz_is_eof_bits(stream))
{
float c[4][FZ_MAX_COLORS];
fz_point v[16];
int startcolor;
int startpt;
int flag;
flag = fz_read_bits(stream, bpflag);
if (flag == 0)
{
startpt = 0;
startcolor = 0;
}
else
{
startpt = 4;
startcolor = 2;
}
for (i = startpt; i < 16; i++)
{
v[i].x = read_sample(stream, bpcoord, x0, x1);
v[i].y = read_sample(stream, bpcoord, y0, y1);
fz_transform_point(&v[i], ctm);
}
for (i = startcolor; i < 4; i++)
{
for (k = 0; k < ncomp; k++)
c[i][k] = read_sample(stream, bpcomp, c0[k], c1[k]);
}
haspatch = 0;
if (flag == 0)
{
haspatch = 1;
}
else if (flag == 1 && hasprevpatch)
{
v[0] = prevp[3];
v[1] = prevp[4];
v[2] = prevp[5];
v[3] = prevp[6];
memcpy(c[0], prevc[1], ncomp * sizeof(float));
memcpy(c[1], prevc[2], ncomp * sizeof(float));
haspatch = 1;
}
else if (flag == 2 && hasprevpatch)
{
v[0] = prevp[6];
v[1] = prevp[7];
v[2] = prevp[8];
v[3] = prevp[9];
memcpy(c[0], prevc[2], ncomp * sizeof(float));
memcpy(c[1], prevc[3], ncomp * sizeof(float));
haspatch = 1;
}
else if (flag == 3 && hasprevpatch)
{
v[0] = prevp[ 9];
v[1] = prevp[10];
v[2] = prevp[11];
v[3] = prevp[ 0];
memcpy(c[0], prevc[3], ncomp * sizeof(float));
memcpy(c[1], prevc[0], ncomp * sizeof(float));
haspatch = 1;
}
if (haspatch)
{
tensor_patch patch;
make_tensor_patch(&patch, 7, v);
for (i = 0; i < 4; i++)
memcpy(patch.color[i], c[i], ncomp * sizeof(float));
draw_patch(painter, &patch, SUBDIV, SUBDIV);
for (i = 0; i < 16; i++)
prevp[i] = v[i];
for (i = 0; i < 4; i++)
memcpy(prevc[i], c[i], FZ_MAX_COLORS * sizeof(float));
hasprevpatch = 1;
}
}
}
fz_always(ctx)
{
fz_close(stream);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
static void
fz_mesh_type4_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
{
fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
fz_vertex v[4];
fz_vertex *va = &v[0];
fz_vertex *vb = &v[1];
fz_vertex *vc = &v[2];
fz_vertex *vd = &v[3];
int flag, i, ncomp;
int bpflag = shade->u.m.bpflag;
int bpcoord = shade->u.m.bpcoord;
int bpcomp = shade->u.m.bpcomp;
float x0 = shade->u.m.x0;
float x1 = shade->u.m.x1;
float y0 = shade->u.m.y0;
float y1 = shade->u.m.y1;
float *c0 = shade->u.m.c0;
float *c1 = shade->u.m.c1;
fz_try(ctx)
{
ncomp = (shade->use_function > 0 ? 1 : shade->colorspace->n);
while (!fz_is_eof_bits(stream))
{
flag = fz_read_bits(stream, bpflag);
vd->p.x = read_sample(stream, bpcoord, x0, x1);
vd->p.y = read_sample(stream, bpcoord, y0, y1);
fz_transform_point(&vd->p, ctm);
for (i = 0; i < ncomp; i++)
vd->c[i] = read_sample(stream, bpcomp, c0[i], c1[i]);
switch (flag)
{
case 0: /* start new triangle */
SWAP(va, vd);
fz_read_bits(stream, bpflag);
vb->p.x = read_sample(stream, bpcoord, x0, x1);
vb->p.y = read_sample(stream, bpcoord, y0, y1);
fz_transform_point(&vb->p, ctm);
for (i = 0; i < ncomp; i++)
vb->c[i] = read_sample(stream, bpcomp, c0[i], c1[i]);
fz_read_bits(stream, bpflag);
vc->p.x = read_sample(stream, bpcoord, x0, x1);
vc->p.y = read_sample(stream, bpcoord, y0, y1);
fz_transform_point(&vc->p, ctm);
for (i = 0; i < ncomp; i++)
vc->c[i] = read_sample(stream, bpcomp, c0[i], c1[i]);
paint_tri(painter, va, vb, vc);
break;
case 1: /* Vb, Vc, Vd */
SWAP(va, vb);
SWAP(vb, vc);
SWAP(vc, vd);
paint_tri(painter, va, vb, vc);
break;
case 2: /* Va, Vc, Vd */
SWAP(vb, vc);
SWAP(vc, vd);
paint_tri(painter, va, vb, vc);
break;
}
}
}
fz_always(ctx)
{
fz_close(stream);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
static void
fz_process_mesh_type7(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
{
fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
int bpflag = shade->u.m.bpflag;
int bpcoord = shade->u.m.bpcoord;
int bpcomp = shade->u.m.bpcomp;
float x0 = shade->u.m.x0;
float x1 = shade->u.m.x1;
float y0 = shade->u.m.y0;
float y1 = shade->u.m.y1;
float *c0 = shade->u.m.c0;
float *c1 = shade->u.m.c1;
float color_storage[2][4][FZ_MAX_COLORS];
fz_point point_storage[2][16];
int store = 0;
int ncomp = painter->ncomp;
int i, k;
float (*prevc)[FZ_MAX_COLORS] = NULL;
fz_point (*prevp) = NULL;
fz_try(ctx)
{
while (!fz_is_eof_bits(ctx, stream))
{
float (*c)[FZ_MAX_COLORS] = color_storage[store];
fz_point *v = point_storage[store];
int startcolor;
int startpt;
int flag;
tensor_patch patch;
flag = fz_read_bits(ctx, stream, bpflag);
if (flag == 0)
{
startpt = 0;
startcolor = 0;
}
else
{
startpt = 4;
startcolor = 2;
}
for (i = startpt; i < 16; i++)
{
v[i].x = read_sample(ctx, stream, bpcoord, x0, x1);
v[i].y = read_sample(ctx, stream, bpcoord, y0, y1);
fz_transform_point(&v[i], ctm);
}
for (i = startcolor; i < 4; i++)
{
for (k = 0; k < ncomp; k++)
c[i][k] = read_sample(ctx, stream, bpcomp, c0[k], c1[k]);
}
if (flag == 0)
{
}
else if (flag == 1 && prevc)
{
v[0] = prevp[3];
v[1] = prevp[4];
v[2] = prevp[5];
v[3] = prevp[6];
memcpy(c[0], prevc[1], ncomp * sizeof(float));
memcpy(c[1], prevc[2], ncomp * sizeof(float));
}
else if (flag == 2 && prevc)
{
v[0] = prevp[6];
v[1] = prevp[7];
v[2] = prevp[8];
v[3] = prevp[9];
memcpy(c[0], prevc[2], ncomp * sizeof(float));
memcpy(c[1], prevc[3], ncomp * sizeof(float));
}
else if (flag == 3 && prevc)
{
v[0] = prevp[ 9];
v[1] = prevp[10];
v[2] = prevp[11];
v[3] = prevp[ 0];
memcpy(c[0], prevc[3], ncomp * sizeof(float));
memcpy(c[1], prevc[0], ncomp * sizeof(float));
}
else
continue; /* We have no patch! */
make_tensor_patch(&patch, 7, v);
for (i = 0; i < 4; i++)
memcpy(patch.color[i], c[i], ncomp * sizeof(float));
draw_patch(ctx, painter, &patch, SUBDIV, SUBDIV);
prevp = v;
prevc = c;
store ^= 1;
}
}
fz_always(ctx)
{
fz_drop_stream(ctx, stream);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
static void
fz_process_mesh_type4(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter)
{
fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer);
fz_vertex v[4];
fz_vertex *va = &v[0];
fz_vertex *vb = &v[1];
fz_vertex *vc = &v[2];
fz_vertex *vd = &v[3];
int flag, i, ncomp = painter->ncomp;
int bpflag = shade->u.m.bpflag;
int bpcoord = shade->u.m.bpcoord;
int bpcomp = shade->u.m.bpcomp;
float x0 = shade->u.m.x0;
float x1 = shade->u.m.x1;
float y0 = shade->u.m.y0;
float y1 = shade->u.m.y1;
float *c0 = shade->u.m.c0;
float *c1 = shade->u.m.c1;
float x, y, c[FZ_MAX_COLORS];
fz_try(ctx)
{
while (!fz_is_eof_bits(ctx, stream))
{
flag = fz_read_bits(ctx, stream, bpflag);
x = read_sample(ctx, stream, bpcoord, x0, x1);
y = read_sample(ctx, stream, bpcoord, y0, y1);
for (i = 0; i < ncomp; i++)
c[i] = read_sample(ctx, stream, bpcomp, c0[i], c1[i]);
fz_prepare_vertex(ctx, painter, vd, ctm, x, y, c);
switch (flag)
{
case 0: /* start new triangle */
SWAP(va, vd);
fz_read_bits(ctx, stream, bpflag);
x = read_sample(ctx, stream, bpcoord, x0, x1);
y = read_sample(ctx, stream, bpcoord, y0, y1);
for (i = 0; i < ncomp; i++)
c[i] = read_sample(ctx, stream, bpcomp, c0[i], c1[i]);
fz_prepare_vertex(ctx, painter, vb, ctm, x, y, c);
fz_read_bits(ctx, stream, bpflag);
x = read_sample(ctx, stream, bpcoord, x0, x1);
y = read_sample(ctx, stream, bpcoord, y0, y1);
for (i = 0; i < ncomp; i++)
c[i] = read_sample(ctx, stream, bpcomp, c0[i], c1[i]);
fz_prepare_vertex(ctx, painter, vc, ctm, x, y, c);
paint_tri(ctx, painter, va, vb, vc);
break;
case 1: /* Vb, Vc, Vd */
SWAP(va, vb);
SWAP(vb, vc);
SWAP(vc, vd);
paint_tri(ctx, painter, va, vb, vc);
break;
case 2: /* Va, Vc, Vd */
SWAP(vb, vc);
SWAP(vc, vd);
paint_tri(ctx, painter, va, vb, vc);
break;
}
}
}
fz_always(ctx)
{
fz_drop_stream(ctx, stream);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
