/*
* Scan stream dictionary for an explicit /Crypt filter
*/
static int
pdf_stream_has_crypt(fz_context *ctx, pdf_obj *stm)
{
pdf_obj *filters;
pdf_obj *obj;
int i;
filters = pdf_dict_getsa(stm, "Filter", "F");
if (filters)
{
if (!strcmp(pdf_to_name(filters), "Crypt"))
return 1;
if (pdf_is_array(filters))
{
int n = pdf_array_len(filters);
for (i = 0; i < n; i++)
{
obj = pdf_array_get(filters, i);
if (!strcmp(pdf_to_name(obj), "Crypt"))
return 1;
}
}
}
return 0;
}
/*
* Construct a filter to decode a stream, constraining
* to stream length and decrypting.
*/
static fz_stream *
pdf_open_filter(fz_stream *chain, pdf_document *xref, pdf_obj *stmobj, int num, int gen, int offset, pdf_image_params *imparams)
{
pdf_obj *filters;
pdf_obj *params;
filters = pdf_dict_getsa(stmobj, "Filter", "F");
params = pdf_dict_getsa(stmobj, "DecodeParms", "DP");
chain = pdf_open_raw_filter(chain, xref, stmobj, num, gen, offset);
if (pdf_is_name(filters))
chain = build_filter(chain, xref, filters, params, num, gen, imparams);
else if (pdf_array_len(filters) > 0)
chain = build_filter_chain(chain, xref, filters, params, num, gen, imparams);
return chain;
}
/*
* Construct a filter to decode a stream, without
* constraining to stream length, and without decryption.
*/
fz_stream *
pdf_open_inline_stream(pdf_document *xref, pdf_obj *stmobj, int length, fz_stream *chain, pdf_image_params *imparams)
{
pdf_obj *filters;
pdf_obj *params;
filters = pdf_dict_getsa(stmobj, "Filter", "F");
params = pdf_dict_getsa(stmobj, "DecodeParms", "DP");
/* don't close chain when we close this filter */
fz_keep_stream(chain);
if (pdf_is_name(filters))
return build_filter(chain, xref, filters, params, 0, 0, imparams);
if (pdf_array_len(filters) > 0)
return build_filter_chain(chain, xref, filters, params, 0, 0, imparams);
return fz_open_null(chain, length);
}
static fz_link *
pdf_load_link(pdf_document *xref, pdf_obj *dict, fz_matrix page_ctm)
{
pdf_obj *dest = NULL;
pdf_obj *action;
pdf_obj *obj;
fz_rect bbox;
fz_context *ctx = xref->ctx;
fz_link_dest ld;
dest = NULL;
obj = pdf_dict_gets(dict, "Rect");
if (obj)
bbox = pdf_to_rect(ctx, obj);
else
bbox = fz_empty_rect;
bbox = fz_transform_rect(page_ctm, bbox);
obj = pdf_dict_gets(dict, "Dest");
if (obj)
{
dest = resolve_dest(xref, obj);
ld = pdf_parse_link_dest(xref, dest);
}
else
{
action = pdf_dict_gets(dict, "A");
/* fall back to additional action button's down/up action */
if (!action)
action = pdf_dict_getsa(pdf_dict_gets(dict, "AA"), "U", "D");
ld = pdf_parse_action(xref, action);
}
if (ld.kind == FZ_LINK_NONE)
return NULL;
return fz_new_link(ctx, bbox, ld);
}
static int
pdf_extgstate_uses_blending(pdf_document *doc, pdf_obj *dict)
{
pdf_obj *obj = pdf_dict_gets(dict, "BM");
/* SumatraPDF: properly support /BM arrays */
if (pdf_is_array(obj))
{
int k;
for (k = 0; k < pdf_array_len(obj); k++)
{
char *bm = pdf_to_name(pdf_array_get(obj, k));
if (!strcmp(bm, "Normal") || fz_lookup_blendmode(bm) > 0)
break;
}
obj = pdf_array_get(obj, k);
}
if (pdf_is_name(obj) && strcmp(pdf_to_name(obj), "Normal"))
return 1;
/* SumatraPDF: support transfer functions */
obj = pdf_dict_getsa(dict, "TR", "TR2");
if (obj && !pdf_is_name(obj))
return 1;
return 0;
}
static void
pdf_load_jpx(pdf_document *xref, pdf_obj *dict, pdf_image *image, int forcemask)
{
fz_buffer *buf = NULL;
fz_colorspace *colorspace = NULL;
fz_pixmap *img = NULL;
pdf_obj *obj;
fz_context *ctx = xref->ctx;
int indexed = 0;
fz_var(img);
fz_var(buf);
fz_var(colorspace);
buf = pdf_load_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
/* FIXME: We can't handle decode arrays for indexed images currently */
fz_try(ctx)
{
obj = pdf_dict_gets(dict, "ColorSpace");
if (obj)
{
colorspace = pdf_load_colorspace(xref, obj);
indexed = !strcmp(colorspace->name, "Indexed");
}
img = fz_load_jpx(ctx, buf->data, buf->len, colorspace, indexed);
if (img && colorspace == NULL)
colorspace = fz_keep_colorspace(ctx, img->colorspace);
fz_drop_buffer(ctx, buf);
buf = NULL;
obj = pdf_dict_getsa(dict, "SMask", "Mask");
if (pdf_is_dict(obj))
{
if (forcemask)
fz_warn(ctx, "Ignoring recursive JPX soft mask");
else
image->base.mask = (fz_image *)pdf_load_image_imp(xref, NULL, obj, NULL, 1);
}
obj = pdf_dict_getsa(dict, "Decode", "D");
if (obj && !indexed)
{
float decode[FZ_MAX_COLORS * 2];
int i;
for (i = 0; i < img->n * 2; i++)
decode[i] = pdf_to_real(pdf_array_get(obj, i));
fz_decode_tile(img, decode);
}
}
fz_catch(ctx)
{
if (colorspace)
fz_drop_colorspace(ctx, colorspace);
fz_drop_buffer(ctx, buf);
fz_drop_pixmap(ctx, img);
fz_rethrow(ctx);
}
FZ_INIT_STORABLE(&image->base, 1, pdf_free_image);
image->base.get_pixmap = pdf_image_get_pixmap;
image->base.w = img->w;
image->base.h = img->h;
image->base.bpc = 8;
image->base.colorspace = colorspace;
image->buffer = NULL;
image->tile = img;
image->n = img->n;
image->interpolate = 0;
image->imagemask = 0;
image->usecolorkey = 0;
}
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_image *
pdf_load_image_imp(pdf_document *doc, 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 stride;
int i;
fz_context *ctx = doc->ctx;
fz_compressed_buffer *buffer;
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(doc, dict, forcemask);
//
// if (forcemask)
// {
// fz_pixmap *mask_pixmap;
// if (image->n != 2)
// {
// fz_pixmap *gray;
// fz_irect bbox;
// fz_warn(ctx, "soft mask should be grayscale");
// gray = fz_new_pixmap_with_bbox(ctx, fz_device_gray(ctx), fz_pixmap_bbox(ctx, image->tile, &bbox));
// fz_convert_pixmap(ctx, gray, image->tile);
// fz_drop_pixmap(ctx, image->tile);
// image->tile = gray;
// }
// 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;
if (imagemask)
bpc = 1;
if (w <= 0)
fz_throw(ctx, FZ_ERROR_GENERIC, "image width is zero (or less)");
if (h <= 0)
fz_throw(ctx, FZ_ERROR_GENERIC, "image height is zero (or less)");
if (bpc <= 0)
fz_throw(ctx, FZ_ERROR_GENERIC, "image depth is zero (or less)");
if (bpc > 16)
fz_throw(ctx, FZ_ERROR_GENERIC, "image depth is too large: %d", bpc);
if (w > (1 << 16))
fz_throw(ctx, FZ_ERROR_GENERIC, "image is too wide");
if (h > (1 << 16))
fz_throw(ctx, FZ_ERROR_GENERIC, "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(doc, obj);
indexed = fz_colorspace_is_indexed(colorspace);
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(doc, rdb, obj, NULL, 1);
obj = pdf_dict_gets(obj, "Matte");
if (pdf_is_array(obj))
{
usecolorkey = 1;
for (i = 0; i < n; i++)
colorkey[i] = pdf_to_real(pdf_array_get(obj, i)) * 255;
}
}
}
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));
}
}
/* Do we load from a ref, or do we load an inline stream? */
if (cstm == NULL)
{
/* 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);
buffer = pdf_load_compressed_stream(doc, num, gen);
image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, buffer, mask);
}
else
{
/* Inline stream */
stride = (w * n * bpc + 7) / 8;
image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, NULL, mask);
pdf_load_compressed_inline_image(doc, dict, stride * h, cstm, indexed, image);
}
}
fz_catch(ctx)
{
fz_drop_colorspace(ctx, colorspace);
fz_drop_image(ctx, mask);
fz_drop_image(ctx, image);
fz_rethrow(ctx);
}
return image;
}
static fz_image *
pdf_load_jpx(pdf_document *doc, pdf_obj *dict, int forcemask)
{
fz_buffer *buf = NULL;
fz_colorspace *colorspace = NULL;
fz_pixmap *img = NULL;
pdf_obj *obj;
fz_context *ctx = doc->ctx;
int indexed = 0;
fz_image *mask = NULL;
fz_var(img);
fz_var(buf);
fz_var(colorspace);
fz_var(mask);
buf = pdf_load_stream(doc, pdf_to_num(dict), pdf_to_gen(dict));
/* FIXME: We can't handle decode arrays for indexed images currently */
fz_try(ctx)
{
obj = pdf_dict_gets(dict, "ColorSpace");
if (obj)
{
colorspace = pdf_load_colorspace(doc, obj);
indexed = fz_colorspace_is_indexed(colorspace);
}
img = fz_load_jpx(ctx, buf->data, buf->len, colorspace, indexed);
obj = pdf_dict_getsa(dict, "SMask", "Mask");
if (pdf_is_dict(obj))
{
if (forcemask)
fz_warn(ctx, "Ignoring recursive JPX soft mask");
else
mask = pdf_load_image_imp(doc, NULL, obj, NULL, 1);
}
obj = pdf_dict_getsa(dict, "Decode", "D");
if (obj && !indexed)
{
float decode[FZ_MAX_COLORS * 2];
int i;
for (i = 0; i < img->n * 2; i++)
decode[i] = pdf_to_real(pdf_array_get(obj, i));
fz_decode_tile(img, decode);
}
}
fz_always(ctx)
{
fz_drop_colorspace(ctx, colorspace);
fz_drop_buffer(ctx, buf);
}
fz_catch(ctx)
{
fz_drop_pixmap(ctx, img);
fz_rethrow(ctx);
}
return fz_new_image_from_pixmap(ctx, img, mask);
}
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;
}
