static fz_image *
pdf_load_jpx_imp(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cstm, int forcemask)
{
fz_image *image = pdf_load_jpx(ctx, doc, dict, forcemask);
if (forcemask)
{
fz_pixmap_image *cimg = (fz_pixmap_image *)image;
fz_pixmap *mask_pixmap;
fz_pixmap *tile = fz_pixmap_image_tile(ctx, cimg);
if (tile->n != 1)
{
fz_pixmap *gray = fz_convert_pixmap(ctx, tile, fz_device_gray(ctx), NULL, NULL, fz_default_color_params(ctx), 0);
fz_drop_pixmap(ctx, tile);
tile = gray;
}
mask_pixmap = fz_alpha_from_gray(ctx, tile);
fz_drop_pixmap(ctx, tile);
fz_set_pixmap_image_tile(ctx, cimg, mask_pixmap);
}
return image;
}
static void
fz_draw_end_mask(fz_context *ctx, void *user)
{
fz_draw_device *dev = user;
fz_pixmap *mask = dev->dest;
fz_pixmap *maskshape = dev->shape;
fz_pixmap *temp, *dest;
fz_bbox bbox;
int luminosity;
if (dev->top == dev->stack_max)
fz_grow_stack(dev);
if (dev->top > 0)
{
/* pop soft mask buffer */
dev->top--;
luminosity = dev->stack[dev->top].luminosity;
dev->scissor = dev->stack[dev->top].scissor;
dev->dest = dev->stack[dev->top].dest;
dev->shape = dev->stack[dev->top].shape;
/* convert to alpha mask */
temp = fz_alpha_from_gray(ctx, mask, luminosity);
fz_drop_pixmap(ctx, mask);
fz_drop_pixmap(ctx, maskshape);
/* create new dest scratch buffer */
bbox = fz_bound_pixmap(temp);
dest = fz_new_pixmap_with_rect(ctx, dev->dest->colorspace, bbox);
/* FIXME: See note #1 */
fz_clear_pixmap(dest);
/* push soft mask as clip mask */
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = temp;
dev->stack[dev->top].dest = dev->dest;
/* FIXME: See note #1 */
dev->stack[dev->top].blendmode = dev->blendmode | FZ_BLEND_ISOLATED;
/* If we have a shape, then it'll need to be masked with the
* clip mask when we pop. So create a new shape now. */
if (dev->shape)
{
dev->stack[dev->top].shape = dev->shape;
dev->shape = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(dev->shape);
}
dev->scissor = bbox;
dev->dest = dest;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Mask -> Clip\n");
#endif
dev->top++;
}
}
static void
fz_draw_end_mask(fz_device *devp)
{
fz_draw_device *dev = devp->user;
fz_pixmap *temp, *dest;
fz_bbox bbox;
int luminosity;
fz_context *ctx = dev->ctx;
fz_draw_state *state;
if (dev->top == 0)
{
fz_warn(ctx, "Unexpected draw_end_mask");
return;
}
state = &dev->stack[dev->top-1];
/* pop soft mask buffer */
luminosity = state[1].luminosity;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Mask -> Clip\n");
#endif
/* convert to alpha mask */
temp = fz_alpha_from_gray(dev->ctx, state[1].dest, luminosity);
if (state[1].dest != state[0].dest)
fz_drop_pixmap(dev->ctx, state[1].dest);
state[1].dest = NULL;
if (state[1].shape != state[0].shape)
fz_drop_pixmap(dev->ctx, state[1].shape);
state[1].shape = NULL;
if (state[1].mask != state[0].mask)
fz_drop_pixmap(dev->ctx, state[1].mask);
state[1].mask = NULL;
/* create new dest scratch buffer */
bbox = fz_pixmap_bbox(ctx, temp);
dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, bbox);
fz_clear_pixmap(dev->ctx, dest);
/* push soft mask as clip mask */
state[1].mask = temp;
state[1].dest = dest;
state[1].blendmode |= FZ_BLEND_ISOLATED;
/* If we have a shape, then it'll need to be masked with the
* clip mask when we pop. So create a new shape now. */
if (state[0].shape)
{
state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, state[1].shape);
}
state[1].scissor = bbox;
}
static void
fz_draw_end_mask(void *user)
{
fz_draw_device *dev = user;
fz_pixmap *mask = dev->dest;
fz_pixmap *temp, *dest;
fz_bbox bbox;
int luminosity;
if (dev->top == STACK_SIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
if (dev->top > 0)
{
/* pop soft mask buffer */
dev->top--;
luminosity = dev->stack[dev->top].luminosity;
dev->scissor = dev->stack[dev->top].scissor;
dev->dest = dev->stack[dev->top].dest;
/* convert to alpha mask */
temp = fz_alpha_from_gray(mask, luminosity);
fz_drop_pixmap(mask);
/* create new dest scratch buffer */
bbox = fz_bound_pixmap(temp);
dest = fz_new_pixmap_with_rect(dev->dest->colorspace, bbox);
fz_clear_pixmap(dest);
/* push soft mask as clip mask */
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = temp;
dev->stack[dev->top].dest = dev->dest;
dev->scissor = bbox;
dev->dest = dest;
dev->top++;
}
}
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 void
fz_draw_fill_text(fz_context *ctx, void *user, fz_text *text, fz_matrix ctm,
fz_colorspace *colorspace, float *color, float alpha)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
unsigned char colorbv[FZ_MAX_COLORS + 1];
unsigned char shapebv;
float colorfv[FZ_MAX_COLORS];
fz_matrix tm, trm;
fz_pixmap *glyph;
int i, x, y, gid;
if (dev->blendmode & FZ_BLEND_KNOCKOUT)
fz_knockout_begin(ctx, dev);
fz_convert_color(ctx, colorspace, color, model, colorfv);
for (i = 0; i < model->n; i++)
colorbv[i] = colorfv[i] * 255;
colorbv[i] = alpha * 255;
shapebv = 255;
tm = text->trm;
for (i = 0; i < text->len; i++)
{
gid = text->items[i].gid;
if (gid < 0)
continue;
tm.e = text->items[i].x;
tm.f = text->items[i].y;
trm = fz_concat(tm, ctm);
x = floorf(trm.e);
y = floorf(trm.f);
trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
glyph = fz_render_glyph(ctx, dev->cache, text->font, gid, trm, model);
if (glyph)
{
/* cf. http://code.google.com/p/sumatrapdf/issues/detail?id=1746 */
if (glyph->n > 1 && text->font->t3procs)
{
float light;
fz_convert_color(ctx, colorspace, color, fz_device_gray, &light);
if (light != 0)
{
fz_pixmap *gray = fz_new_pixmap_with_rect(ctx, fz_device_gray, fz_bound_pixmap(glyph));
fz_convert_pixmap(ctx, glyph, gray);
fz_drop_pixmap(ctx, glyph);
glyph = fz_alpha_from_gray(ctx, gray, 0);
fz_drop_pixmap(ctx, gray);
}
}
if (glyph->n == 1)
{
draw_glyph(colorbv, dev->dest, glyph, x, y, dev->scissor);
if (dev->shape)
draw_glyph(&shapebv, dev->shape, glyph, x, y, dev->scissor);
}
else
{
fz_matrix ctm = {glyph->w, 0.0, 0.0, -glyph->h, x + glyph->x, y + glyph->y + glyph->h};
fz_paint_image(dev->dest, dev->scissor, dev->shape, glyph, ctm, alpha * 255);
}
fz_drop_pixmap(ctx, glyph);
}
}
if (dev->blendmode & FZ_BLEND_KNOCKOUT)
fz_knockout_end(ctx, dev);
}
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;
}
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;
}
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));
/* SumatraPDF: ignore invalid JPX softmasks */
fz_clear_pixmap_with_value(ctx, gray, 255);
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;
}
