/*
* Load uncompressed contents of a stream into buf.
*/
fz_error
pdf_load_stream(fz_buffer **bufp, pdf_xref *xref, int num, int gen)
{
fz_error error;
fz_stream *stm;
fz_obj *dict, *obj;
int i, len;
error = pdf_open_stream(&stm, xref, num, gen);
if (error)
return fz_rethrow(error, "cannot open stream (%d %d R)", num, gen);
error = pdf_load_object(&dict, xref, num, gen);
if (error)
return fz_rethrow(error, "cannot load stream dictionary (%d %d R)", num, gen);
len = fz_to_int(fz_dict_gets(dict, "Length"));
obj = fz_dict_gets(dict, "Filter");
len = pdf_guess_filter_length(len, fz_to_name(obj));
for (i = 0; i < fz_array_len(obj); i++)
len = pdf_guess_filter_length(len, fz_to_name(fz_array_get(obj, i)));
fz_drop_obj(dict);
error = fz_read_all(bufp, stm, len);
if (error)
{
fz_close(stm);
return fz_rethrow(error, "cannot read raw stream (%d %d R)", num, gen);
}
fz_close(stm);
return fz_okay;
}
static fz_stream *
pdf_open_object_array(fz_context *ctx, pdf_document *doc, pdf_obj *list)
{
fz_stream *stm;
int i, n;
n = pdf_array_len(ctx, list);
stm = fz_open_concat(ctx, n, 1);
fz_var(i); /* Workaround Mac compiler bug */
for (i = 0; i < n; i++)
{
pdf_obj *obj = pdf_array_get(ctx, list, i);
fz_try(ctx)
{
fz_concat_push(ctx, stm, pdf_open_stream(ctx, doc, pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)));
}
fz_catch(ctx)
{
fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
fz_warn(ctx, "cannot load content stream part %d/%d", i + 1, n);
continue;
}
}
return stm;
}
static fz_stream *
pdf_open_object_array(pdf_document *xref, pdf_obj *list)
{
int i, n;
fz_context *ctx = xref->ctx;
fz_stream *stm;
n = pdf_array_len(list);
stm = fz_open_concat(ctx, n, 1);
fz_var(i); /* Workaround Mac compiler bug */
for (i = 0; i < n; i++)
{
pdf_obj *obj = pdf_array_get(list, i);
fz_try(ctx)
{
fz_concat_push(stm, pdf_open_stream(xref, pdf_to_num(obj), pdf_to_gen(obj)));
}
fz_catch(ctx)
{
fz_warn(ctx, "cannot load content stream part %d/%d", i + 1, n);
continue;
}
}
return stm;
}
static fz_colorspace *
load_indexed(pdf_document *doc, pdf_obj *array)
{
fz_context *ctx = doc->ctx;
pdf_obj *baseobj = pdf_array_get(array, 1);
pdf_obj *highobj = pdf_array_get(array, 2);
pdf_obj *lookupobj = pdf_array_get(array, 3);
fz_colorspace *base = NULL;
fz_colorspace *cs;
int i, n, high;
unsigned char *lookup = NULL;
fz_var(base);
fz_var(lookup);
fz_try(ctx)
{
base = pdf_load_colorspace(doc, baseobj);
high = pdf_to_int(highobj);
high = fz_clampi(high, 0, 255);
n = base->n * (high + 1);
lookup = fz_malloc_array(ctx, 1, n);
if (pdf_is_string(lookupobj) && pdf_to_str_len(lookupobj) >= n)
{
unsigned char *buf = (unsigned char *) pdf_to_str_buf(lookupobj);
for (i = 0; i < n; i++)
lookup[i] = buf[i];
}
else if (pdf_is_indirect(lookupobj))
{
fz_stream *file = NULL;
fz_var(file);
fz_try(ctx)
{
file = pdf_open_stream(doc, pdf_to_num(lookupobj), pdf_to_gen(lookupobj));
i = fz_read(file, lookup, n);
if (i < n)
memset(lookup+i, 0, n-i);
}
fz_always(ctx)
{
fz_close(file);
}
fz_catch(ctx)
{
fz_rethrow_message(ctx, "cannot open colorspace lookup table (%d 0 R)", pdf_to_num(lookupobj));
}
}
else
{
fz_rethrow_message(ctx, "cannot parse colorspace lookup table");
}
cs = fz_new_indexed_colorspace(ctx, base, high, lookup);
}
void dump_stream(int i, FILE *fout)
{
fz_stream *stm = pdf_open_stream(doc, i, 0);
static unsigned char buf[8192];
while (1) {
int n = fz_read(stm, buf, sizeof buf);
if (n == 0) break;
fwrite(buf, 1, n, fout);
}
fz_close(stm);
}
static void
pdf_load_type5_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict,
int funcs, pdf_function **func)
{
fz_context *ctx = xref->ctx;
struct mesh_params p;
struct vertex *buf, *ref;
int first;
int ncomp;
int i, k;
fz_stream *stream;
pdf_load_mesh_params(xref, dict, &p);
if (funcs > 0)
{
ncomp = 1;
pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]);
}
else
ncomp = shade->colorspace->n;
ref = fz_malloc_array(ctx, p.vprow, sizeof(struct vertex));
buf = fz_malloc_array(ctx, p.vprow, sizeof(struct vertex));
first = 1;
stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
while (!fz_is_eof_bits(stream))
{
for (i = 0; i < p.vprow; i++)
{
buf[i].x = read_sample(stream, p.bpcoord, p.x0, p.x1);
buf[i].y = read_sample(stream, p.bpcoord, p.y0, p.y1);
for (k = 0; k < ncomp; k++)
buf[i].c[k] = read_sample(stream, p.bpcomp, p.c0[k], p.c1[k]);
}
if (!first)
for (i = 0; i < p.vprow - 1; i++)
pdf_add_quad(ctx, shade,
&ref[i], &ref[i+1], &buf[i+1], &buf[i]);
memcpy(ref, buf, p.vprow * sizeof(struct vertex));
first = 0;
}
fz_free(ctx, ref);
fz_free(ctx, buf);
fz_close(stream);
}
static pdf_image *
pdf_load_image_imp(pdf_document *xref, pdf_obj *rdb, pdf_obj *dict, fz_stream *cstm, int forcemask)
{
fz_stream *stm = NULL;
pdf_image *image = NULL;
pdf_obj *obj, *res;
int w, h, bpc, n;
int imagemask;
int interpolate;
int indexed;
fz_image *mask = NULL; /* explicit mask/soft mask image */
int usecolorkey;
int i;
fz_context *ctx = xref->ctx;
fz_var(stm);
fz_var(mask);
image = fz_malloc_struct(ctx, pdf_image);
fz_try(ctx)
{
/* special case for JPEG2000 images */
if (pdf_is_jpx_image(ctx, dict))
{
pdf_load_jpx(xref, dict, image, forcemask);
if (forcemask)
{
fz_pixmap *mask_pixmap;
if (image->n != 2)
fz_throw(ctx, "soft mask must be grayscale");
mask_pixmap = fz_alpha_from_gray(ctx, image->tile, 1);
fz_drop_pixmap(ctx, image->tile);
image->tile = mask_pixmap;
}
break; /* Out of fz_try */
}
w = pdf_to_int(pdf_dict_getsa(dict, "Width", "W"));
h = pdf_to_int(pdf_dict_getsa(dict, "Height", "H"));
bpc = pdf_to_int(pdf_dict_getsa(dict, "BitsPerComponent", "BPC"));
if (bpc == 0)
bpc = 8;
imagemask = pdf_to_bool(pdf_dict_getsa(dict, "ImageMask", "IM"));
interpolate = pdf_to_bool(pdf_dict_getsa(dict, "Interpolate", "I"));
indexed = 0;
usecolorkey = 0;
mask = NULL;
if (imagemask)
bpc = 1;
if (w <= 0)
fz_throw(ctx, "image width is zero (or less)");
if (h <= 0)
fz_throw(ctx, "image height is zero (or less)");
if (bpc <= 0)
fz_throw(ctx, "image depth is zero (or less)");
if (bpc > 16)
fz_throw(ctx, "image depth is too large: %d", bpc);
if (w > (1 << 16))
fz_throw(ctx, "image is too wide");
if (h > (1 << 16))
fz_throw(ctx, "image is too high");
obj = pdf_dict_getsa(dict, "ColorSpace", "CS");
if (obj && !imagemask && !forcemask)
{
/* colorspace resource lookup is only done for inline images */
if (pdf_is_name(obj))
{
res = pdf_dict_get(pdf_dict_gets(rdb, "ColorSpace"), obj);
if (res)
obj = res;
}
image->base.colorspace = pdf_load_colorspace(xref, obj);
if (!strcmp(image->base.colorspace->name, "Indexed"))
indexed = 1;
n = image->base.colorspace->n;
}
else
{
n = 1;
}
obj = pdf_dict_getsa(dict, "Decode", "D");
if (obj)
{
for (i = 0; i < n * 2; i++)
image->decode[i] = pdf_to_real(pdf_array_get(obj, i));
}
else
{
float maxval = indexed ? (1 << bpc) - 1 : 1;
for (i = 0; i < n * 2; i++)
image->decode[i] = i & 1 ? maxval : 0;
}
obj = pdf_dict_getsa(dict, "SMask", "Mask");
if (pdf_is_dict(obj))
{
/* Not allowed for inline images or soft masks */
if (cstm)
fz_warn(ctx, "Ignoring invalid inline image soft mask");
else if (forcemask)
fz_warn(ctx, "Ignoring recursive image soft mask");
else
mask = (fz_image *)pdf_load_image_imp(xref, rdb, obj, NULL, 1);
}
else if (pdf_is_array(obj))
{
usecolorkey = 1;
for (i = 0; i < n * 2; i++)
{
if (!pdf_is_int(pdf_array_get(obj, i)))
{
fz_warn(ctx, "invalid value in color key mask");
usecolorkey = 0;
}
image->colorkey[i] = pdf_to_int(pdf_array_get(obj, i));
}
}
/* Now, do we load a ref, or do we load the actual thing? */
FZ_INIT_STORABLE(&image->base, 1, pdf_free_image);
image->base.get_pixmap = pdf_image_get_pixmap;
image->base.w = w;
image->base.h = h;
image->base.bpc = bpc;
image->n = n;
image->interpolate = interpolate;
image->imagemask = imagemask;
image->usecolorkey = usecolorkey;
image->base.mask = mask;
if (!cstm)
{
/* Just load the compressed image data now and we can
* decode it on demand. */
int num = pdf_to_num(dict);
int gen = pdf_to_gen(dict);
image->buffer = pdf_load_compressed_stream(xref, num, gen);
break; /* Out of fz_try */
}
/* We need to decompress the image now */
if (cstm)
{
int stride = (w * image->n * image->base.bpc + 7) / 8;
stm = pdf_open_inline_stream(xref, dict, stride * h, cstm, NULL);
}
else
{
stm = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
}
image->tile = decomp_image_from_stream(ctx, stm, image, cstm != NULL, indexed, 0, 0, 0);
}
fz_catch(ctx)
{
pdf_free_image(ctx, (fz_storable *) image);
fz_rethrow(ctx);
}
return image;
}
static fz_colorspace *
load_indexed(pdf_document *xref, pdf_obj *array)
{
struct indexed *idx = NULL;
fz_context *ctx = xref->ctx;
pdf_obj *baseobj = pdf_array_get(array, 1);
pdf_obj *highobj = pdf_array_get(array, 2);
pdf_obj *lookup = pdf_array_get(array, 3);
fz_colorspace *base = NULL;
fz_colorspace *cs = NULL;
int i, n;
fz_var(idx);
fz_var(base);
fz_var(cs);
fz_try(ctx)
{
base = pdf_load_colorspace(xref, baseobj);
/* "cannot load base colorspace (%d %d R)", pdf_to_num(baseobj), pdf_to_gen(baseobj) */
idx = fz_malloc_struct(ctx, struct indexed);
idx->lookup = NULL;
idx->base = base;
idx->high = pdf_to_int(highobj);
idx->high = CLAMP(idx->high, 0, 255);
n = base->n * (idx->high + 1);
idx->lookup = fz_malloc_array(ctx, 1, n);
cs = fz_new_colorspace(ctx, "Indexed", 1);
cs->to_rgb = indexed_to_rgb;
cs->free_data = free_indexed;
cs->data = idx;
cs->size += sizeof(*idx) + n + (base ? base->size : 0);
if (pdf_is_string(lookup) && pdf_to_str_len(lookup) == n)
{
unsigned char *buf = (unsigned char *) pdf_to_str_buf(lookup);
for (i = 0; i < n; i++)
idx->lookup[i] = buf[i];
}
else if (pdf_is_indirect(lookup))
{
fz_stream *file = NULL;
fz_try(ctx)
{
file = pdf_open_stream(xref, pdf_to_num(lookup), pdf_to_gen(lookup));
}
fz_catch(ctx)
{
fz_throw(ctx, "cannot open colorspace lookup table (%d 0 R)", pdf_to_num(lookup));
}
i = fz_read(file, idx->lookup, n);
if (i < 0)
{
fz_close(file);
fz_throw(ctx, "cannot read colorspace lookup table (%d 0 R)", pdf_to_num(lookup));
}
fz_close(file);
}
else
{
fz_throw(ctx, "cannot parse colorspace lookup table");
}
}
/*
* Load CMap stream in PDF file
*/
fz_error
pdf_load_embedded_cmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *stmobj)
{
fz_error error = fz_okay;
fz_stream *file = NULL;
pdf_cmap *cmap = NULL;
pdf_cmap *usecmap;
fz_obj *wmode;
fz_obj *obj;
if ((*cmapp = pdf_find_item(xref->store, pdf_drop_cmap, stmobj)))
{
pdf_keep_cmap(*cmapp);
return fz_okay;
}
error = pdf_open_stream(&file, xref, fz_to_num(stmobj), fz_to_gen(stmobj));
if (error)
{
error = fz_rethrow(error, "cannot open cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
goto cleanup;
}
error = pdf_parse_cmap(&cmap, file);
if (error)
{
error = fz_rethrow(error, "cannot parse cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
goto cleanup;
}
fz_close(file);
wmode = fz_dict_gets(stmobj, "WMode");
if (fz_is_int(wmode))
pdf_set_wmode(cmap, fz_to_int(wmode));
obj = fz_dict_gets(stmobj, "UseCMap");
if (fz_is_name(obj))
{
error = pdf_load_system_cmap(&usecmap, fz_to_name(obj));
if (error)
{
error = fz_rethrow(error, "cannot load system usecmap '%s'", fz_to_name(obj));
goto cleanup;
}
pdf_set_usecmap(cmap, usecmap);
pdf_drop_cmap(usecmap);
}
else if (fz_is_indirect(obj))
{
error = pdf_load_embedded_cmap(&usecmap, xref, obj);
if (error)
{
error = fz_rethrow(error, "cannot load embedded usecmap (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
goto cleanup;
}
pdf_set_usecmap(cmap, usecmap);
pdf_drop_cmap(usecmap);
}
pdf_store_item(xref->store, pdf_keep_cmap, pdf_drop_cmap, stmobj, cmap);
*cmapp = cmap;
return fz_okay;
cleanup:
if (file)
fz_close(file);
if (cmap)
pdf_drop_cmap(cmap);
return error; /* already rethrown */
}
static fz_error
pdf_load_obj_stm(pdf_xref *xref, int num, int gen, char *buf, int cap)
{
fz_error error;
fz_stream *stm;
fz_obj *objstm;
int *numbuf;
int *ofsbuf;
fz_obj *obj;
int first;
int count;
int i, n;
int tok;
error = pdf_load_object(&objstm, xref, num, gen);
if (error)
return fz_rethrow(error, "cannot load object stream object (%d %d R)", num, gen);
count = fz_to_int(fz_dict_gets(objstm, "N"));
first = fz_to_int(fz_dict_gets(objstm, "First"));
numbuf = fz_calloc(count, sizeof(int));
ofsbuf = fz_calloc(count, sizeof(int));
error = pdf_open_stream(&stm, xref, num, gen);
if (error)
{
error = fz_rethrow(error, "cannot open object stream (%d %d R)", num, gen);
goto cleanupbuf;
}
for (i = 0; i < count; i++)
{
error = pdf_lex(&tok, stm, buf, cap, &n);
if (error || tok != PDF_TOK_INT)
{
error = fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
goto cleanupstm;
}
numbuf[i] = atoi(buf);
error = pdf_lex(&tok, stm, buf, cap, &n);
if (error || tok != PDF_TOK_INT)
{
error = fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
goto cleanupstm;
}
ofsbuf[i] = atoi(buf);
}
fz_seek(stm, first, 0);
for (i = 0; i < count; i++)
{
fz_seek(stm, first + ofsbuf[i], 0);
error = pdf_parse_stm_obj(&obj, xref, stm, buf, cap);
if (error)
{
error = fz_rethrow(error, "cannot parse object %d in stream (%d %d R)", i, num, gen);
goto cleanupstm;
}
if (numbuf[i] < 1 || numbuf[i] >= xref->len)
{
fz_drop_obj(obj);
error = fz_throw("object id (%d 0 R) out of range (0..%d)", numbuf[i], xref->len - 1);
goto cleanupstm;
}
if (xref->table[numbuf[i]].type == 'o' && xref->table[numbuf[i]].ofs == num)
{
if (xref->table[numbuf[i]].obj)
fz_drop_obj(xref->table[numbuf[i]].obj);
xref->table[numbuf[i]].obj = obj;
}
else
{
fz_drop_obj(obj);
}
}
fz_close(stm);
fz_free(ofsbuf);
fz_free(numbuf);
fz_drop_obj(objstm);
return fz_okay;
cleanupstm:
fz_close(stm);
cleanupbuf:
fz_free(ofsbuf);
fz_free(numbuf);
fz_drop_obj(objstm);
return error; /* already rethrown */
}
/*
* Load CMap stream in PDF file
*/
pdf_cmap *
pdf_load_embedded_cmap(pdf_document *doc, pdf_obj *stmobj)
{
fz_stream *file = NULL;
pdf_cmap *cmap = NULL;
pdf_cmap *usecmap;
pdf_obj *wmode;
pdf_obj *obj = NULL;
fz_context *ctx = doc->ctx;
int phase = 0;
fz_var(phase);
fz_var(obj);
fz_var(file);
fz_var(cmap);
if (pdf_obj_marked(stmobj))
fz_throw(ctx, FZ_ERROR_GENERIC, "Recursion in embedded cmap");
if ((cmap = pdf_find_item(ctx, pdf_free_cmap_imp, stmobj)) != NULL)
{
return cmap;
}
fz_try(ctx)
{
file = pdf_open_stream(doc, pdf_to_num(stmobj), pdf_to_gen(stmobj));
phase = 1;
cmap = pdf_load_cmap(ctx, file);
phase = 2;
fz_close(file);
file = NULL;
wmode = pdf_dict_gets(stmobj, "WMode");
if (pdf_is_int(wmode))
pdf_set_cmap_wmode(ctx, cmap, pdf_to_int(wmode));
obj = pdf_dict_gets(stmobj, "UseCMap");
if (pdf_is_name(obj))
{
usecmap = pdf_load_system_cmap(ctx, pdf_to_name(obj));
pdf_set_usecmap(ctx, cmap, usecmap);
pdf_drop_cmap(ctx, usecmap);
}
else if (pdf_is_indirect(obj))
{
phase = 3;
pdf_mark_obj(obj);
usecmap = pdf_load_embedded_cmap(doc, obj);
pdf_unmark_obj(obj);
phase = 4;
pdf_set_usecmap(ctx, cmap, usecmap);
pdf_drop_cmap(ctx, usecmap);
}
pdf_store_item(ctx, stmobj, cmap, pdf_cmap_size(ctx, cmap));
}
fz_catch(ctx)
{
if (file)
fz_close(file);
if (cmap)
pdf_drop_cmap(ctx, cmap);
if (phase < 1)
fz_rethrow_message(ctx, "cannot open cmap stream (%d %d R)", pdf_to_num(stmobj), pdf_to_gen(stmobj));
else if (phase < 2)
fz_rethrow_message(ctx, "cannot parse cmap stream (%d %d R)", pdf_to_num(stmobj), pdf_to_gen(stmobj));
else if (phase < 3)
fz_rethrow_message(ctx, "cannot load system usecmap '%s'", pdf_to_name(obj));
else
{
if (phase == 3)
pdf_unmark_obj(obj);
fz_rethrow_message(ctx, "cannot load embedded usecmap (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
}
}
return cmap;
}
static fz_error
load_indexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
{
fz_error error;
fz_colorspace *cs;
struct indexed *idx;
fz_obj *baseobj = fz_array_get(array, 1);
fz_obj *highobj = fz_array_get(array, 2);
fz_obj *lookup = fz_array_get(array, 3);
fz_colorspace *base;
int i, n;
error = pdf_load_colorspace(&base, xref, baseobj);
if (error)
return fz_rethrow(error, "cannot load base colorspace (%d %d R)", fz_to_num(baseobj), fz_to_gen(baseobj));
idx = fz_malloc(sizeof(struct indexed));
idx->base = base;
idx->high = fz_to_int(highobj);
idx->high = CLAMP(idx->high, 0, 255);
n = base->n * (idx->high + 1);
idx->lookup = fz_malloc(n);
memset(idx->lookup, 0, n);
cs = fz_new_colorspace("Indexed", 1);
cs->to_rgb = indexed_to_rgb;
cs->free_data = free_indexed;
cs->data = idx;
if (fz_is_string(lookup) && fz_to_str_len(lookup) == n)
{
unsigned char *buf = (unsigned char *) fz_to_str_buf(lookup);
for (i = 0; i < n; i++)
idx->lookup[i] = buf[i];
}
else if (fz_is_indirect(lookup))
{
fz_stream *file;
error = pdf_open_stream(&file, xref, fz_to_num(lookup), fz_to_gen(lookup));
if (error)
{
fz_drop_colorspace(cs);
return fz_rethrow(error, "cannot open colorspace lookup table (%d 0 R)", fz_to_num(lookup));
}
i = fz_read(file, idx->lookup, n);
if (i < 0)
{
fz_drop_colorspace(cs);
return fz_throw("cannot read colorspace lookup table (%d 0 R)", fz_to_num(lookup));
}
fz_close(file);
}
else
{
fz_drop_colorspace(cs);
return fz_throw("cannot parse colorspace lookup table");
}
*csp = cs;
return fz_okay;
}
static void
pdf_load_type7_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict,
int funcs, pdf_function **func)
{
fz_context *ctx = xref->ctx;
struct mesh_params p;
int haspatch, hasprevpatch;
float prevc[4][FZ_MAX_COLORS];
fz_point prevp[16];
int ncomp;
int i, k;
fz_stream *stream;
pdf_load_mesh_params(xref, dict, &p);
if (funcs > 0)
{
ncomp = 1;
pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]);
}
else
ncomp = shade->colorspace->n;
hasprevpatch = 0;
stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
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, p.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, p.bpcoord, p.x0, p.x1);
v[i].y = read_sample(stream, p.bpcoord, p.y0, p.y1);
}
for (i = startcolor; i < 4; i++)
{
for (k = 0; k < ncomp; k++)
c[i][k] = read_sample(stream, p.bpcomp, p.c0[k], p.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)
{
pdf_tensor_patch patch;
pdf_make_tensor_patch(&patch, 7, v);
for (i = 0; i < 4; i++)
memcpy(patch.color[i], c[i], ncomp * sizeof(float));
draw_patch(ctx, shade, &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_close(stream);
}
static void
pdf_load_type4_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict,
int funcs, pdf_function **func)
{
fz_context *ctx = xref->ctx;
struct mesh_params p;
struct vertex va, vb, vc, vd;
int ncomp;
int flag;
int i;
fz_stream *stream;
pdf_load_mesh_params(xref, dict, &p);
if (funcs > 0)
{
ncomp = 1;
pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]);
}
else
ncomp = shade->colorspace->n;
stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
while (!fz_is_eof_bits(stream))
{
flag = fz_read_bits(stream, p.bpflag);
vd.x = read_sample(stream, p.bpcoord, p.x0, p.x1);
vd.y = read_sample(stream, p.bpcoord, p.y0, p.y1);
for (i = 0; i < ncomp; i++)
vd.c[i] = read_sample(stream, p.bpcomp, p.c0[i], p.c1[i]);
switch (flag)
{
case 0: /* start new triangle */
va = vd;
fz_read_bits(stream, p.bpflag);
vb.x = read_sample(stream, p.bpcoord, p.x0, p.x1);
vb.y = read_sample(stream, p.bpcoord, p.y0, p.y1);
for (i = 0; i < ncomp; i++)
vb.c[i] = read_sample(stream, p.bpcomp, p.c0[i], p.c1[i]);
fz_read_bits(stream, p.bpflag);
vc.x = read_sample(stream, p.bpcoord, p.x0, p.x1);
vc.y = read_sample(stream, p.bpcoord, p.y0, p.y1);
for (i = 0; i < ncomp; i++)
vc.c[i] = read_sample(stream, p.bpcomp, p.c0[i], p.c1[i]);
pdf_add_triangle(ctx, shade, &va, &vb, &vc);
break;
case 1: /* Vb, Vc, Vd */
va = vb;
vb = vc;
vc = vd;
pdf_add_triangle(ctx, shade, &va, &vb, &vc);
break;
case 2: /* Va, Vc, Vd */
vb = vc;
vc = vd;
pdf_add_triangle(ctx, shade, &va, &vb, &vc);
break;
}
}
fz_close(stream);
}
static fz_error
pdf_load_shading_dict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix transform)
{
fz_error error;
fz_shade *shade;
pdf_function *func[FZ_MAX_COLORS] = { NULL };
fz_stream *stream = NULL;
fz_obj *obj;
int funcs;
int type;
int i;
shade = fz_malloc(sizeof(fz_shade));
shade->refs = 1;
shade->type = FZ_MESH;
shade->use_background = 0;
shade->use_function = 0;
shade->matrix = transform;
shade->bbox = fz_infinite_rect;
shade->extend[0] = 0;
shade->extend[1] = 0;
shade->mesh_len = 0;
shade->mesh_cap = 0;
shade->mesh = NULL;
shade->colorspace = NULL;
funcs = 0;
obj = fz_dict_gets(dict, "ShadingType");
type = fz_to_int(obj);
obj = fz_dict_gets(dict, "ColorSpace");
if (!obj)
{
fz_drop_shade(shade);
return fz_throw("shading colorspace is missing");
}
error = pdf_load_colorspace(&shade->colorspace, xref, obj);
if (error)
{
fz_drop_shade(shade);
return fz_rethrow(error, "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
}
obj = fz_dict_gets(dict, "Background");
if (obj)
{
shade->use_background = 1;
for (i = 0; i < shade->colorspace->n; i++)
shade->background[i] = fz_to_real(fz_array_get(obj, i));
}
obj = fz_dict_gets(dict, "BBox");
if (fz_is_array(obj))
{
shade->bbox = pdf_to_rect(obj);
}
obj = fz_dict_gets(dict, "Function");
if (fz_is_dict(obj))
{
funcs = 1;
error = pdf_load_function(&func[0], xref, obj);
if (error)
{
error = fz_rethrow(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
goto cleanup;
}
}
else if (fz_is_array(obj))
{
funcs = fz_array_len(obj);
if (funcs != 1 && funcs != shade->colorspace->n)
{
error = fz_throw("incorrect number of shading functions");
goto cleanup;
}
for (i = 0; i < funcs; i++)
{
error = pdf_load_function(&func[i], xref, fz_array_get(obj, i));
if (error)
{
error = fz_rethrow(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
goto cleanup;
}
}
}
if (type >= 4 && type <= 7)
{
error = pdf_open_stream(&stream, xref, fz_to_num(dict), fz_to_gen(dict));
if (error)
{
error = fz_rethrow(error, "cannot open shading stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
goto cleanup;
}
}
switch (type)
{
case 1: pdf_load_function_based_shading(shade, xref, dict, func[0]); break;
case 2: pdf_load_axial_shading(shade, xref, dict, funcs, func); break;
case 3: pdf_load_radial_shading(shade, xref, dict, funcs, func); break;
case 4: pdf_load_type4_shade(shade, xref, dict, funcs, func, stream); break;
case 5: pdf_load_type5_shade(shade, xref, dict, funcs, func, stream); break;
case 6: pdf_load_type6_shade(shade, xref, dict, funcs, func, stream); break;
case 7: pdf_load_type7_shade(shade, xref, dict, funcs, func, stream); break;
default:
error = fz_throw("unknown shading type: %d", type);
goto cleanup;
}
if (stream)
fz_close(stream);
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(func[i]);
*shadep = shade;
return fz_okay;
cleanup:
if (stream)
fz_close(stream);
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(func[i]);
fz_drop_shade(shade);
return fz_rethrow(error, "cannot load shading type %d (%d %d R)", type, fz_to_num(dict), fz_to_gen(dict));
}
static fz_image *
pdf_load_image_imp(pdf_document *xref, pdf_obj *rdb, pdf_obj *dict, fz_stream *cstm, int forcemask)
{
fz_stream *stm = NULL;
fz_image *image = NULL;
pdf_obj *obj, *res;
int w, h, bpc, n;
int imagemask;
int interpolate;
int indexed;
fz_image *mask = NULL; /* explicit mask/soft mask image */
int usecolorkey = 0;
fz_colorspace *colorspace = NULL;
float decode[FZ_MAX_COLORS * 2];
int colorkey[FZ_MAX_COLORS * 2];
int i;
fz_context *ctx = xref->ctx;
fz_var(stm);
fz_var(mask);
fz_var(image);
fz_var(colorspace);
fz_try(ctx)
{
/* special case for JPEG2000 images */
if (pdf_is_jpx_image(ctx, dict))
{
image = pdf_load_jpx(xref, dict, forcemask);
if (forcemask)
{
fz_pixmap *mask_pixmap;
if (image->n != 2)
{
/* SumatraPDF: ignore invalid JPX softmasks */
fz_warn(ctx, "soft mask must be grayscale");
mask_pixmap = fz_new_pixmap(ctx, NULL, image->tile->w, image->tile->h);
fz_clear_pixmap_with_value(ctx, mask_pixmap, 255);
}
else
mask_pixmap = fz_alpha_from_gray(ctx, image->tile, 1);
fz_drop_pixmap(ctx, image->tile);
image->tile = mask_pixmap;
}
break; /* Out of fz_try */
}
w = pdf_to_int(pdf_dict_getsa(dict, "Width", "W"));
h = pdf_to_int(pdf_dict_getsa(dict, "Height", "H"));
bpc = pdf_to_int(pdf_dict_getsa(dict, "BitsPerComponent", "BPC"));
if (bpc == 0)
bpc = 8;
imagemask = pdf_to_bool(pdf_dict_getsa(dict, "ImageMask", "IM"));
interpolate = pdf_to_bool(pdf_dict_getsa(dict, "Interpolate", "I"));
indexed = 0;
usecolorkey = 0;
mask = NULL;
if (imagemask)
bpc = 1;
if (w <= 0)
fz_throw(ctx, "image width is zero (or less)");
if (h <= 0)
fz_throw(ctx, "image height is zero (or less)");
if (bpc <= 0)
fz_throw(ctx, "image depth is zero (or less)");
if (bpc > 16)
fz_throw(ctx, "image depth is too large: %d", bpc);
if (w > (1 << 16))
fz_throw(ctx, "image is too wide");
if (h > (1 << 16))
fz_throw(ctx, "image is too high");
obj = pdf_dict_getsa(dict, "ColorSpace", "CS");
if (obj && !imagemask && !forcemask)
{
/* colorspace resource lookup is only done for inline images */
if (pdf_is_name(obj))
{
res = pdf_dict_get(pdf_dict_gets(rdb, "ColorSpace"), obj);
if (res)
obj = res;
}
colorspace = pdf_load_colorspace(xref, obj);
if (!strcmp(colorspace->name, "Indexed"))
indexed = 1;
n = colorspace->n;
}
else
{
n = 1;
}
obj = pdf_dict_getsa(dict, "Decode", "D");
if (obj)
{
for (i = 0; i < n * 2; i++)
decode[i] = pdf_to_real(pdf_array_get(obj, i));
}
else
{
float maxval = indexed ? (1 << bpc) - 1 : 1;
for (i = 0; i < n * 2; i++)
decode[i] = i & 1 ? maxval : 0;
}
obj = pdf_dict_getsa(dict, "SMask", "Mask");
if (pdf_is_dict(obj))
{
/* Not allowed for inline images or soft masks */
if (cstm)
fz_warn(ctx, "Ignoring invalid inline image soft mask");
else if (forcemask)
fz_warn(ctx, "Ignoring recursive image soft mask");
else
mask = pdf_load_image_imp(xref, rdb, obj, NULL, 1);
}
else if (pdf_is_array(obj))
{
usecolorkey = 1;
for (i = 0; i < n * 2; i++)
{
if (!pdf_is_int(pdf_array_get(obj, i)))
{
fz_warn(ctx, "invalid value in color key mask");
usecolorkey = 0;
}
colorkey[i] = pdf_to_int(pdf_array_get(obj, i));
}
}
/* Now, do we load a ref, or do we load the actual thing? */
if (!cstm)
{
/* Just load the compressed image data now and we can
* decode it on demand. */
int num = pdf_to_num(dict);
int gen = pdf_to_gen(dict);
fz_compressed_buffer *buffer = pdf_load_compressed_stream(xref, num, gen);
image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, buffer, mask);
break; /* Out of fz_try */
}
/* We need to decompress the image now */
if (cstm)
{
int stride = (w * n * bpc + 7) / 8;
stm = pdf_open_inline_stream(xref, dict, stride * h, cstm, NULL);
}
else
{
stm = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
}
image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, NULL, mask);
image->tile = fz_decomp_image_from_stream(ctx, stm, image, cstm != NULL, indexed, 0, 0);
}
fz_catch(ctx)
{
/* SumatraPDF: fix memory leak */
if (!image)
fz_drop_colorspace(ctx, colorspace);
else
fz_drop_image(ctx, image);
fz_rethrow(ctx);
}
/* cf. http://bugs.ghostscript.com/show_bug.cgi?id=693517 */
fz_try(ctx)
{
obj = pdf_dict_getp(dict, "SMask/Matte");
if (pdf_is_array(obj) && image->mask)
{
assert(!image->usecolorkey);
image->usecolorkey = 2;
for (i = 0; i < n; i++)
image->colorkey[i] = pdf_to_int(pdf_array_get(obj, i));
}
}
fz_catch(ctx)
{
fz_drop_image(ctx, image);
fz_rethrow(ctx);
}
return image;
}
/* dest points to the new pages content-streams-dict, src is a reference to
one source content-stream */
int copy_content_stream_of_page(fz_context *dest_ctx, pdf_obj *dest,
fz_context *src_ctx, pdf_obj *src,
struct put_info *info, struct pos_info *pos)
{
if(!pdf_is_array(dest_ctx, dest) && !pdf_is_indirect(src_ctx, src))
return(-1);
/*
translation: 1 0 0 1 diff_x diff_y
scale: scale 0 0 scale 0 0
rotation: cos sin -sin cos 0 0
-------------------------------------------------
rotation 0: 1 0 0 1 0 0
rotation 90: 0 1 -1 0 0 0
rotation 180: -1 0 0 -1 0 0
rotation 270: 0 -1 1 0 0 0
*/
fz_buffer *buffer = fz_new_buffer(dest_ctx, 1024);
fz_output *output = fz_new_output_with_buffer(dest_ctx, buffer);
fz_printf(dest_ctx, output, "q\n");
/* set the outer clip region */
fz_printf(dest_ctx, output, "%f %f %f %f re W n\n",
pos->outer_clip_x, pos->outer_clip_y,
pos->outer_clip_width, pos->outer_clip_height);
/* position the page correctly */
if(pos->rotate == 0) {
fz_printf(dest_ctx, output, "1 0 0 1 %f %f cm\n",
pos->x + pos->content_translate_x, pos->y + pos->content_translate_y);
} else if(pos->rotate == 90) {
fz_printf(dest_ctx, output, "0 1 -1 0 %f %f cm\n", pos->x + pos->width, pos->y);
} else if(pos->rotate == 180) {
fz_printf(dest_ctx, output, "-1 0 0 -1 %f %f cm\n",
pos->width + pos->x - pos->content_translate_x,
pos->height + pos->y - pos->content_translate_y);
} else if(pos->rotate == 270) {
fz_printf(dest_ctx, output, "0 -1 1 0 %f %f cm\n", pos->x, pos->y + pos->height);
}
if(pos->bleed_clip_x != 0.0 || pos->bleed_clip_y != 0.0 ||
pos->bleed_clip_width != 0.0 || pos->bleed_clip_height != 0.0)
{
fz_printf(dest_ctx, output, "%f %f %f %f re W n\n",
pos->bleed_clip_x, pos->bleed_clip_y, pos->bleed_clip_width, pos->bleed_clip_height);
}
int src_num = pdf_to_num(src_ctx, src);
int src_gen = pdf_to_gen(src_ctx, src);
fz_stream *input = pdf_open_stream(src_ctx, info->src_doc, src_num, src_gen);
rename_res_in_content_stream(src_ctx, input, dest_ctx, output, info->rename_dict);
fz_printf(dest_ctx, output, "Q");
fz_drop_output(dest_ctx, output);
fz_drop_stream(dest_ctx, input);
int new_num = pdf_create_object(dest_ctx, info->dest_doc);
pdf_obj *new_ref = pdf_new_indirect(dest_ctx, info->dest_doc, new_num, 0);
/* each stream has a dict containing at least its length... */
pdf_obj *stream_info_dict = pdf_new_dict(dest_ctx, info->dest_doc, 1);
pdf_dict_puts_drop(dest_ctx, stream_info_dict, "Length", pdf_new_int(dest_ctx, info->dest_doc, buffer->len));
pdf_update_object(dest_ctx, info->dest_doc, new_num, stream_info_dict);
pdf_drop_obj(dest_ctx, stream_info_dict);
pdf_update_stream(dest_ctx, info->dest_doc, new_ref, buffer, 0);
fz_drop_buffer(dest_ctx, buffer);
pdf_array_push(dest_ctx, dest, new_ref);
pdf_drop_obj(dest_ctx, new_ref);
return(0);
}
/*
* Load CMap stream in PDF file
*/
pdf_cmap *
pdf_load_embedded_cmap(fz_context *ctx, pdf_document *doc, pdf_obj *stmobj)
{
fz_stream *file = NULL;
pdf_cmap *cmap = NULL;
pdf_cmap *usecmap = NULL;
pdf_obj *obj;
fz_var(file);
fz_var(cmap);
fz_var(usecmap);
if (pdf_obj_marked(ctx, stmobj))
fz_throw(ctx, FZ_ERROR_GENERIC, "Recursion in embedded cmap");
if ((cmap = pdf_find_item(ctx, pdf_drop_cmap_imp, stmobj)) != NULL)
return cmap;
fz_try(ctx)
{
file = pdf_open_stream(ctx, stmobj);
cmap = pdf_load_cmap(ctx, file);
obj = pdf_dict_get(ctx, stmobj, PDF_NAME_WMode);
if (pdf_is_int(ctx, obj))
pdf_set_cmap_wmode(ctx, cmap, pdf_to_int(ctx, obj));
obj = pdf_dict_get(ctx, stmobj, PDF_NAME_UseCMap);
if (pdf_is_name(ctx, obj))
{
usecmap = pdf_load_system_cmap(ctx, pdf_to_name(ctx, obj));
pdf_set_usecmap(ctx, cmap, usecmap);
}
else if (pdf_is_indirect(ctx, obj))
{
if (pdf_mark_obj(ctx, obj))
fz_throw(ctx, FZ_ERROR_GENERIC, "recursive CMap");
fz_try(ctx)
usecmap = pdf_load_embedded_cmap(ctx, doc, obj);
fz_always(ctx)
pdf_unmark_obj(ctx, obj);
fz_catch(ctx)
fz_rethrow(ctx);
pdf_set_usecmap(ctx, cmap, usecmap);
}
pdf_store_item(ctx, stmobj, cmap, pdf_cmap_size(ctx, cmap));
}
fz_always(ctx)
{
fz_drop_stream(ctx, file);
pdf_drop_cmap(ctx, usecmap);
}
fz_catch(ctx)
{
pdf_drop_cmap(ctx, cmap);
fz_rethrow(ctx);
}
return cmap;
}
static fz_error
pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cstm, int forcemask)
{
fz_stream *stm;
fz_pixmap *tile;
fz_obj *obj, *res;
fz_error error;
int w, h, bpc, n;
int imagemask;
int interpolate;
int indexed;
fz_colorspace *colorspace;
fz_pixmap *mask; /* explicit mask/softmask image */
int usecolorkey;
int colorkey[FZ_MAX_COLORS * 2];
float decode[FZ_MAX_COLORS * 2];
int stride;
unsigned char *samples;
int i, len;
/* special case for JPEG2000 images */
if (pdf_is_jpx_image(dict))
{
tile = NULL;
error = pdf_load_jpx_image(&tile, xref, dict);
if (error)
return fz_rethrow(error, "cannot load jpx image");
if (forcemask)
{
if (tile->n != 2)
{
fz_drop_pixmap(tile);
return fz_throw("softmask must be grayscale");
}
mask = fz_alpha_from_gray(tile, 1);
fz_drop_pixmap(tile);
*imgp = mask;
return fz_okay;
}
*imgp = tile;
return fz_okay;
}
w = fz_to_int(fz_dict_getsa(dict, "Width", "W"));
h = fz_to_int(fz_dict_getsa(dict, "Height", "H"));
bpc = fz_to_int(fz_dict_getsa(dict, "BitsPerComponent", "BPC"));
imagemask = fz_to_bool(fz_dict_getsa(dict, "ImageMask", "IM"));
interpolate = fz_to_bool(fz_dict_getsa(dict, "Interpolate", "I"));
indexed = 0;
usecolorkey = 0;
colorspace = NULL;
mask = NULL;
if (imagemask)
bpc = 1;
if (w == 0)
return fz_throw("image width is zero");
if (h == 0)
return fz_throw("image height is zero");
if (bpc == 0)
return fz_throw("image depth is zero");
if (w > (1 << 16))
return fz_throw("image is too wide");
if (h > (1 << 16))
return fz_throw("image is too high");
obj = fz_dict_getsa(dict, "ColorSpace", "CS");
if (obj && !imagemask && !forcemask)
{
/* colorspace resource lookup is only done for inline images */
if (fz_is_name(obj))
{
res = fz_dict_get(fz_dict_gets(rdb, "ColorSpace"), obj);
if (res)
obj = res;
}
error = pdf_load_colorspace(&colorspace, xref, obj);
if (error)
return fz_rethrow(error, "cannot load image colorspace");
if (!strcmp(colorspace->name, "Indexed"))
indexed = 1;
n = colorspace->n;
}
else
{
n = 1;
}
obj = fz_dict_getsa(dict, "Decode", "D");
if (obj)
{
for (i = 0; i < n * 2; i++)
decode[i] = fz_to_real(fz_array_get(obj, i));
}
else
{
float maxval = indexed ? (1 << bpc) - 1 : 1;
for (i = 0; i < n * 2; i++)
decode[i] = i & 1 ? maxval : 0;
}
obj = fz_dict_getsa(dict, "SMask", "Mask");
if (fz_is_dict(obj))
{
/* Not allowed for inline images */
if (!cstm)
{
error = pdf_load_image_imp(&mask, xref, rdb, obj, NULL, 1);
if (error)
{
if (colorspace)
fz_drop_colorspace(colorspace);
return fz_rethrow(error, "cannot load image mask/softmask");
}
}
}
else if (fz_is_array(obj))
{
usecolorkey = 1;
for (i = 0; i < n * 2; i++)
colorkey[i] = fz_to_int(fz_array_get(obj, i));
}
/* Allocate now, to fail early if we run out of memory */
tile = fz_new_pixmap_with_limit(colorspace, w, h);
if (!tile)
{
if (colorspace)
fz_drop_colorspace(colorspace);
if (mask)
fz_drop_pixmap(mask);
return fz_throw("out of memory");
}
if (colorspace)
fz_drop_colorspace(colorspace);
tile->mask = mask;
tile->interpolate = interpolate;
stride = (w * n * bpc + 7) / 8;
if (cstm)
{
stm = pdf_open_inline_stream(cstm, xref, dict, stride * h);
}
else
{
error = pdf_open_stream(&stm, xref, fz_to_num(dict), fz_to_gen(dict));
if (error)
{
fz_drop_pixmap(tile);
return fz_rethrow(error, "cannot open image data stream (%d 0 R)", fz_to_num(dict));
}
}
samples = fz_calloc(h, stride);
len = fz_read(stm, samples, h * stride);
if (len < 0)
{
fz_close(stm);
fz_free(samples);
fz_drop_pixmap(tile);
return fz_rethrow(len, "cannot read image data");
}
/* Make sure we read the EOF marker (for inline images only) */
if (cstm)
{
unsigned char tbuf[512];
int tlen = fz_read(stm, tbuf, sizeof tbuf);
if (tlen < 0)
fz_catch(tlen, "ignoring error at end of image");
if (tlen > 0)
fz_warn("ignoring garbage at end of image");
}
fz_close(stm);
/* Pad truncated images */
if (len < stride * h)
{
fz_warn("padding truncated image (%d 0 R)", fz_to_num(dict));
memset(samples + len, 0, stride * h - len);
}
/* Invert 1-bit image masks */
if (imagemask)
{
/* 0=opaque and 1=transparent so we need to invert */
unsigned char *p = samples;
len = h * stride;
for (i = 0; i < len; i++)
p[i] = ~p[i];
}
fz_unpack_tile(tile, samples, n, bpc, stride, indexed);
fz_free(samples);
if (usecolorkey)
pdf_mask_color_key(tile, n, colorkey);
if (indexed)
{
fz_pixmap *conv;
fz_decode_indexed_tile(tile, decode, (1 << bpc) - 1);
conv = pdf_expand_indexed_pixmap(tile);
fz_drop_pixmap(tile);
tile = conv;
}
else
{
fz_decode_tile(tile, decode);
}
*imgp = tile;
return fz_okay;
}
