static void
pdf_load_function_based_shading(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, fz_function *func)
{
pdf_obj *obj;
float x0, y0, x1, y1;
float fv[2];
fz_matrix matrix;
int xx, yy;
float *p;
x0 = y0 = 0;
x1 = y1 = 1;
obj = pdf_dict_get(ctx, dict, PDF_NAME_Domain);
if (obj)
{
x0 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0));
x1 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1));
y0 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 2));
y1 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 3));
}
obj = pdf_dict_get(ctx, dict, PDF_NAME_Matrix);
if (obj)
pdf_to_matrix(ctx, obj, &matrix);
else
matrix = fz_identity;
shade->u.f.matrix = matrix;
shade->u.f.xdivs = FUNSEGS;
shade->u.f.ydivs = FUNSEGS;
shade->u.f.fn_vals = fz_malloc(ctx, (FUNSEGS+1)*(FUNSEGS+1)*shade->colorspace->n*sizeof(float));
shade->u.f.domain[0][0] = x0;
shade->u.f.domain[0][1] = y0;
shade->u.f.domain[1][0] = x1;
shade->u.f.domain[1][1] = y1;
p = shade->u.f.fn_vals;
for (yy = 0; yy <= FUNSEGS; yy++)
{
fv[1] = y0 + (y1 - y0) * yy / FUNSEGS;
for (xx = 0; xx <= FUNSEGS; xx++)
{
fv[0] = x0 + (x1 - x0) * xx / FUNSEGS;
fz_eval_function(ctx, func, fv, 2, p, shade->colorspace->n);
p += shade->colorspace->n;
}
}
}
fz_text *
fz_newtext(fz_font *font, fz_matrix trm, int wmode)
{
fz_text *text;
text = fz_malloc(sizeof(fz_text));
text->font = fz_keepfont(font);
text->trm = trm;
text->wmode = wmode;
text->len = 0;
text->cap = 0;
text->els = nil;
return text;
}
pdf_obj *
pdf_new_string(fz_context *ctx, pdf_document *doc, const char *str, int len)
{
pdf_obj *obj;
obj = Memento_label(fz_malloc(ctx, offsetof(pdf_obj, u.s.buf) + len + 1), "pdf_obj(string)");
obj->doc = doc;
obj->refs = 1;
obj->kind = PDF_STRING;
obj->flags = 0;
obj->parent_num = 0;
obj->u.s.len = len;
memcpy(obj->u.s.buf, str, len);
obj->u.s.buf[len] = '\0';
return obj;
}
pdfout_data *
pdfout_data_scalar_new (fz_context *ctx, const char *value, int len)
{
data_scalar *result = fz_malloc_struct (ctx, data_scalar);
result->super.type = SCALAR;
result->len = len;
result->value = fz_malloc (ctx, len + 1);
memcpy (result->value, value, len);
result->value[len] = 0;
return (pdfout_data *) result;
}
fz_error
fz_newimagenode(fz_node **nodep, fz_image *image)
{
fz_imagenode *node;
node = fz_malloc(sizeof (fz_imagenode));
if (!node)
return fz_rethrow(-1, "out of memory");
*nodep = (fz_node*)node;
fz_initnode((fz_node*)node, FZ_NIMAGE);
node->image = fz_keepimage(image);
return fz_okay;
}
fz_error
fz_newshadenode(fz_node **nodep, fz_shade *shade)
{
fz_shadenode *node;
node = fz_malloc(sizeof (fz_shadenode));
if (!node)
return fz_rethrow(-1, "out of memory");
*nodep = (fz_node*)node;
fz_initnode((fz_node*)node, FZ_NSHADE);
node->shade = fz_keepshade(shade);
return fz_okay;
}
fz_text_span *
fz_new_text_span(void)
{
fz_text_span *span;
span = fz_malloc(sizeof(fz_text_span));
span->font = NULL;
span->wmode = 0;
span->size = 0;
span->len = 0;
span->cap = 0;
span->text = NULL;
span->next = NULL;
span->eol = 0;
return span;
}
fz_error
fz_newlinknode(fz_node **nodep, fz_tree *subtree)
{
fz_linknode *node;
node = fz_malloc(sizeof (fz_linknode));
if (!node)
return fz_rethrow(-1, "out of memory");
*nodep = (fz_node*)node;
fz_initnode((fz_node*)node, FZ_NLINK);
node->tree = fz_keeptree(subtree);
return fz_okay;
}
fz_error *
fz_newtree(fz_tree **treep)
{
fz_tree *tree;
tree = *treep = fz_malloc(sizeof (fz_tree));
if (!tree)
return fz_outofmem;
tree->refs = 1;
tree->root = nil;
tree->head = nil;
return fz_okay;
}
fz_error *
fz_newtransformnode(fz_node **nodep, fz_matrix m)
{
fz_transformnode *node;
node = fz_malloc(sizeof (fz_transformnode));
if (!node)
return fz_outofmem;
*nodep = (fz_node*)node;
fz_initnode((fz_node*)node, FZ_NTRANSFORM);
node->m = m;
return fz_okay;
}
ptrdiff_t pdf_lexbuf_grow(pdf_lexbuf *lb)
{
char *old = lb->scratch;
int newsize = lb->size * 2;
if (lb->size == lb->base_size)
{
lb->scratch = fz_malloc(lb->ctx, newsize);
memcpy(lb->scratch, lb->buffer, lb->size);
}
else
{
lb->scratch = fz_resize_array(lb->ctx, lb->scratch, newsize, 1);
}
lb->size = newsize;
return lb->scratch - old;
}
fz_error
fz_newtransformnode(fz_node **nodep, fz_matrix m)
{
fz_transformnode *node;
node = fz_malloc(sizeof (fz_transformnode));
if (!node)
return fz_rethrow(-1, "out of memory");
*nodep = (fz_node*)node;
fz_initnode((fz_node*)node, FZ_NTRANSFORM);
node->m = m;
node->container = 0; /* cf. http://bugs.ghostscript.com/show_bug.cgi?id=690643 */
return fz_okay;
}
fz_text *
fz_clonetext(fz_text *old)
{
fz_text *text;
text = fz_malloc(sizeof(fz_text));
text->font = fz_keepfont(old->font);
text->trm = old->trm;
text->wmode = old->wmode;
text->len = old->len;
text->cap = text->len;
text->els = fz_calloc(text->len, sizeof(fz_textel));
memcpy(text->els, old->els, text->len * sizeof(fz_textel));
return text;
}
static void
fz_expand_tiff_colormap(struct tiff *tiff)
{
int maxval = 1 << tiff->bitspersample;
unsigned char *samples;
unsigned char *src, *dst;
unsigned int x, y;
unsigned int stride;
/* colormap has first all red, then all green, then all blue values */
/* colormap values are 0..65535, bits is 4 or 8 */
/* image can be with or without extrasamples: comps is 1 or 2 */
if (tiff->samplesperpixel != 1 && tiff->samplesperpixel != 2)
fz_throw(tiff->ctx, "invalid number of samples for RGBPal");
if (tiff->bitspersample != 4 && tiff->bitspersample != 8)
fz_throw(tiff->ctx, "invalid number of bits for RGBPal");
stride = tiff->imagewidth * (tiff->samplesperpixel + 2);
samples = fz_malloc(tiff->ctx, stride * tiff->imagelength);
for (y = 0; y < tiff->imagelength; y++)
{
src = tiff->samples + (unsigned int)(tiff->stride * y);
dst = samples + (unsigned int)(stride * y);
for (x = 0; x < tiff->imagewidth; x++)
{
if (tiff->extrasamples)
{
int c = getcomp(src, x * 2, tiff->bitspersample);
int a = getcomp(src, x * 2 + 1, tiff->bitspersample);
*dst++ = tiff->colormap[c + 0] >> 8;
*dst++ = tiff->colormap[c + maxval] >> 8;
*dst++ = tiff->colormap[c + maxval * 2] >> 8;
*dst++ = a << (8 - tiff->bitspersample);
}
else
{
int c = getcomp(src, x, tiff->bitspersample);
*dst++ = tiff->colormap[c + 0] >> 8;
*dst++ = tiff->colormap[c + maxval] >> 8;
*dst++ = tiff->colormap[c + maxval * 2] >> 8;
}
}
fz_error
fz_newblendnode(fz_node **nodep, fz_blendkind b, int i, int k)
{
fz_blendnode *node;
node = fz_malloc(sizeof (fz_blendnode));
if (!node)
return fz_rethrow(-1, "out of memory");
*nodep = (fz_node*)node;
fz_initnode((fz_node*)node, FZ_NBLEND);
node->mode = b;
node->isolated = i;
node->knockout = k;
return fz_okay;
}
fz_device *
fz_new_draw_device(fz_glyph_cache *cache, fz_pixmap *dest)
{
fz_device *dev;
fz_draw_device *ddev = fz_malloc(sizeof(fz_draw_device));
ddev->cache = cache;
ddev->gel = fz_new_gel();
ddev->dest = dest;
ddev->top = 0;
ddev->scissor.x0 = dest->x;
ddev->scissor.y0 = dest->y;
ddev->scissor.x1 = dest->x + dest->w;
ddev->scissor.y1 = dest->y + dest->h;
dev = fz_new_device(ddev);
dev->free_user = fz_draw_free_user;
dev->fill_path = fz_draw_fill_path;
dev->stroke_path = fz_draw_stroke_path;
dev->clip_path = fz_draw_clip_path;
dev->clip_stroke_path = fz_draw_clip_stroke_path;
dev->fill_text = fz_draw_fill_text;
dev->stroke_text = fz_draw_stroke_text;
dev->clip_text = fz_draw_clip_text;
dev->clip_stroke_text = fz_draw_clip_stroke_text;
dev->ignore_text = fz_draw_ignore_text;
dev->fill_image_mask = fz_draw_fill_image_mask;
dev->clip_image_mask = fz_draw_clip_image_mask;
dev->fill_image = fz_draw_fill_image;
dev->fill_shade = fz_draw_fill_shade;
dev->pop_clip = fz_draw_pop_clip;
dev->begin_mask = fz_draw_begin_mask;
dev->end_mask = fz_draw_end_mask;
dev->begin_group = fz_draw_begin_group;
dev->end_group = fz_draw_end_group;
dev->begin_tile = fz_draw_begin_tile;
dev->end_tile = fz_draw_end_tile;
return dev;
}
fz_error *
pdf_newlink(pdf_link **linkp, fz_rect bbox, fz_obj *dest, pdf_linkkind kind)
{
pdf_link *link;
link = fz_malloc(sizeof(pdf_link));
if (!link)
return fz_outofmem;
link->rect = bbox;
link->dest = fz_keepobj(dest);
link->kind = kind;
link->next = nil;
*linkp = link;
return nil;
}
pdf_obj *
pdf_new_name(fz_context *ctx, pdf_document *doc, const char *str)
{
pdf_obj_name *obj;
char **stdname;
stdname = bsearch(str, &PDF_NAMES[1], PDF_OBJ_ENUM_NAME__LIMIT-1, sizeof(char *), namecmp);
if (stdname != NULL)
return (pdf_obj *)(intptr_t)(stdname - &PDF_NAMES[0]);
obj = Memento_label(fz_malloc(ctx, offsetof(pdf_obj_name, n) + strlen(str) + 1), "pdf_obj(name)");
obj->super.refs = 1;
obj->super.kind = PDF_NAME;
obj->super.flags = 0;
strcpy(obj->n, str);
return &obj->super;
}
fz_error *
fz_newblendnode(fz_node **nodep, fz_blendkind b, int k, int i)
{
fz_blendnode *node;
node = fz_malloc(sizeof (fz_blendnode));
if (!node)
return fz_outofmem;
*nodep = (fz_node*)node;
fz_initnode((fz_node*)node, FZ_NBLEND);
node->mode = b;
node->knockout = k;
node->isolated = i;
return fz_okay;
}
fz_error
pdf_newlink(pdf_link **linkp, pdf_linkkind kind, fz_rect bbox, fz_obj *dest)
{
pdf_link *link;
link = fz_malloc(sizeof(pdf_link));
if (!link)
return fz_rethrow(-1, "out of memory");
link->kind = kind;
link->rect = bbox;
link->dest = fz_keepobj(dest);
link->next = nil;
*linkp = link;
return fz_okay;
}
fz_error *
fz_newrenderer(fz_renderer **gcp, fz_colorspace *pcm, int maskonly, int gcmem)
{
fz_error *error;
fz_renderer *gc;
gc = fz_malloc(sizeof(fz_renderer));
if (!gc)
return fz_outofmem;
gc->maskonly = maskonly;
gc->model = pcm;
gc->cache = nil;
gc->gel = nil;
gc->ael = nil;
error = fz_newglyphcache(&gc->cache, gcmem / 24, gcmem);
if (error)
goto cleanup;
error = fz_newgel(&gc->gel);
if (error)
goto cleanup;
error = fz_newael(&gc->ael);
if (error)
goto cleanup;
gc->dest = nil;
gc->over = nil;
gc->rgb[0] = 0;
gc->rgb[1] = 0;
gc->rgb[2] = 0;
gc->flag = 0;
*gcp = gc;
return nil;
cleanup:
if (gc->model) fz_dropcolorspace(gc->model);
if (gc->cache) fz_dropglyphcache(gc->cache);
if (gc->gel) fz_dropgel(gc->gel);
if (gc->ael) fz_dropael(gc->ael);
fz_free(gc);
return error;
}
static void fz_grow_stack(fz_draw_device *dev)
{
int max = dev->stack_max * 2;
fz_draw_stack *stack;
if (dev->stack == &dev->init_stack[0])
{
stack = fz_malloc(dev->ctx, sizeof(*stack) * max);
memcpy(stack, dev->stack, sizeof(*stack) * dev->stack_max);
}
else
{
stack = fz_realloc(dev->ctx, dev->stack, max * sizeof(*stack));
}
dev->stack = stack;
dev->stack_max = max;
}
fz_error *
fz_newdash(fz_dash **dashp, float phase, int len, float *array)
{
fz_dash *dash;
int i;
dash = *dashp = fz_malloc(sizeof(fz_dash) + sizeof(float) * len);
if (!dash)
return fz_outofmem;
dash->len = len;
dash->phase = phase;
for (i = 0; i < len; i++)
dash->array[i] = array[i];
return nil;
}
int
xps_parse_resource_dictionary(xps_context *ctx, xps_resource **dictp, char *base_uri, xml_element *root)
{
xps_resource *head;
xps_resource *entry;
xml_element *node;
char *source;
char *key;
int code;
source = xml_att(root, "Source");
if (source)
{
code = xps_parse_remote_resource_dictionary(ctx, dictp, base_uri, source);
if (code)
return fz_rethrow(code, "cannot parse remote resource dictionary");
return fz_okay;
}
head = NULL;
for (node = xml_down(root); node; node = xml_next(node))
{
key = xml_att(node, "x:Key");
if (key)
{
entry = fz_malloc(sizeof(xps_resource));
entry->name = key;
entry->base_uri = NULL;
entry->base_xml = NULL;
entry->data = node;
entry->next = head;
entry->parent = NULL;
head = entry;
}
}
if (head)
{
head->base_uri = fz_strdup(base_uri);
}
*dictp = head;
return fz_okay;
}
fz_gel *
fz_newgel(void)
{
fz_gel *gel;
gel = fz_malloc(sizeof(fz_gel));
gel->cap = 512;
gel->len = 0;
gel->edges = fz_calloc(gel->cap, sizeof(fz_edge));
gel->clip.x0 = gel->clip.y0 = BBOX_MAX;
gel->clip.x1 = gel->clip.y1 = BBOX_MIN;
gel->bbox.x0 = gel->bbox.y0 = BBOX_MAX;
gel->bbox.x1 = gel->bbox.y1 = BBOX_MIN;
return gel;
}
fz_stream *
fz_open_dctd(fz_stream *chain, fz_obj *params)
{
fz_dctd *state;
fz_obj *obj;
state = fz_malloc(chain->ctx, sizeof(fz_dctd));
memset(state, 0, sizeof(fz_dctd));
state->chain = chain;
state->color_transform = -1; /* unset */
state->init = 0;
obj = fz_dict_gets(chain->ctx, params, "ColorTransform");
if (obj)
state->color_transform = fz_to_int(chain->ctx, obj);
return fz_new_stream(chain->ctx, state, read_dctd, close_dctd);
}
fz_stream *
fz_opendctd(fz_stream *chain, fz_obj *params)
{
fz_dctd *state;
fz_obj *obj;
state = fz_malloc(sizeof(fz_dctd));
memset(state, 0, sizeof(fz_dctd));
state->chain = chain;
state->colortransform = -1; /* unset */
state->init = 0;
obj = fz_dictgets(params, "ColorTransform");
if (obj)
state->colortransform = fz_toint(obj);
return fz_newstream(state, readdctd, closedctd);
}
static unsigned char *
pnm_read_string(fz_context *ctx, unsigned char *p, unsigned char *e, char **out)
{
unsigned char *s;
if (e - p < 1)
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot parse string in pnm image");
s = p;
while (!iswhiteeol(*p))
p++;
*out = fz_malloc(ctx, p - s + 1);
memcpy(*out, s, p - s);
(*out)[p - s] = '\0';
return p;
}
pdf_obj *
pdf_new_string(fz_context *ctx, pdf_document *doc, const char *str, size_t len)
{
pdf_obj_string *obj;
unsigned int l = (unsigned int)len;
if ((size_t)l != len)
fz_throw(ctx, FZ_ERROR_GENERIC, "Overflow in pdf string");
obj = Memento_label(fz_malloc(ctx, offsetof(pdf_obj_string, buf) + len + 1), "pdf_obj(string)");
obj->super.refs = 1;
obj->super.kind = PDF_STRING;
obj->super.flags = 0;
obj->len = l;
memcpy(obj->buf, str, len);
obj->buf[len] = '\0';
return &obj->super;
}
fz_device *
fz_newdrawdevice(fz_glyphcache *cache, fz_pixmap *dest)
{
fz_device *dev;
fz_drawdevice *ddev = fz_malloc(sizeof(fz_drawdevice));
ddev->cache = cache;
ddev->gel = fz_newgel();
ddev->ael = fz_newael();
ddev->dest = dest;
ddev->top = 0;
ddev->scissor.x0 = dest->x;
ddev->scissor.y0 = dest->y;
ddev->scissor.x1 = dest->x + dest->w;
ddev->scissor.y1 = dest->y + dest->h;
dev = fz_newdevice(ddev);
dev->freeuser = fz_drawfreeuser;
dev->fillpath = fz_drawfillpath;
dev->strokepath = fz_drawstrokepath;
dev->clippath = fz_drawclippath;
dev->clipstrokepath = fz_drawclipstrokepath;
dev->filltext = fz_drawfilltext;
dev->stroketext = fz_drawstroketext;
dev->cliptext = fz_drawcliptext;
dev->clipstroketext = fz_drawclipstroketext;
dev->ignoretext = fz_drawignoretext;
dev->fillimagemask = fz_drawfillimagemask;
dev->clipimagemask = fz_drawclipimagemask;
dev->fillimage = fz_drawfillimage;
dev->fillshade = fz_drawfillshade;
dev->popclip = fz_drawpopclip;
dev->beginmask = fz_drawbeginmask;
dev->endmask = fz_drawendmask;
dev->begingroup = fz_drawbegingroup;
dev->endgroup = fz_drawendgroup;
return dev;
}
