static void
intersect_box(fz_context *ctx, pdf_document *doc, pdf_obj *page, pdf_obj *box_name, const fz_rect *mb)
{
pdf_obj *box = pdf_dict_get(ctx, page, box_name);
pdf_obj *newbox;
fz_rect old_rect;
if (box == NULL)
return;
old_rect.x0 = pdf_to_real(ctx, pdf_array_get(ctx, box, 0));
old_rect.y0 = pdf_to_real(ctx, pdf_array_get(ctx, box, 1));
old_rect.x1 = pdf_to_real(ctx, pdf_array_get(ctx, box, 2));
old_rect.y1 = pdf_to_real(ctx, pdf_array_get(ctx, box, 3));
if (old_rect.x0 < mb->x0)
old_rect.x0 = mb->x0;
if (old_rect.y0 < mb->y0)
old_rect.y0 = mb->y0;
if (old_rect.x1 > mb->x1)
old_rect.x1 = mb->x1;
if (old_rect.y1 > mb->y1)
old_rect.y1 = mb->y1;
newbox = pdf_new_array(ctx, doc, 4);
pdf_array_push(ctx, newbox, pdf_new_real(ctx, doc, old_rect.x0));
pdf_array_push(ctx, newbox, pdf_new_real(ctx, doc, old_rect.y0));
pdf_array_push(ctx, newbox, pdf_new_real(ctx, doc, old_rect.x1));
pdf_array_push(ctx, newbox, pdf_new_real(ctx, doc, old_rect.y1));
pdf_dict_put(ctx, page, box_name, newbox);
}
void
pdf_annot_ink_list_stroke_vertex(fz_context *ctx, pdf_annot *annot, int i, int k, float v[2])
{
pdf_obj *ink_list;
pdf_obj *stroke;
fz_matrix page_ctm;
fz_point point = { 0, 0 };
check_allowed_subtypes(ctx, annot, PDF_NAME_InkList, ink_list_subtypes);
ink_list = pdf_dict_get(ctx, annot->obj, PDF_NAME_InkList);
stroke = pdf_array_get(ctx, ink_list, i);
if (v)
{
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
point.x = pdf_to_real(ctx, pdf_array_get(ctx, stroke, k * 2 + 0));
point.y = pdf_to_real(ctx, pdf_array_get(ctx, stroke, k * 2 + 1));
fz_transform_point(&point, &page_ctm);
v[0] = point.x;
v[1] = point.y;
}
}
/*
* Build a chain of filters given filter names and param dicts.
* If head is given, start filter chain with it.
* Assume ownership of head.
*/
static fz_stream *
build_filter_chain(fz_context *ctx, fz_stream *chain, pdf_document *doc, pdf_obj *fs, pdf_obj *ps, int num, int gen, fz_compression_params *params)
{
pdf_obj *f;
pdf_obj *p;
int i, n;
fz_try(ctx)
{
n = pdf_array_len(ctx, fs);
for (i = 0; i < n; i++)
{
fz_stream *chain2;
f = pdf_array_get(ctx, fs, i);
p = pdf_array_get(ctx, ps, i);
chain2 = chain;
chain = NULL;
chain = build_filter(ctx, chain2, doc, f, p, num, gen, (i == n-1 ? params : NULL));
}
}
fz_catch(ctx)
{
fz_drop_stream(ctx, chain);
fz_rethrow(ctx);
}
return chain;
}
static void
pdf_load_name_tree_imp(pdf_obj *dict, pdf_document *xref, pdf_obj *node)
{
fz_context *ctx = xref->ctx;
pdf_obj *kids = pdf_dict_gets(node, "Kids");
pdf_obj *names = pdf_dict_gets(node, "Names");
int i;
if (kids && !pdf_dict_mark(node))
{
for (i = 0; i < pdf_array_len(kids); i++)
pdf_load_name_tree_imp(dict, xref, pdf_array_get(kids, i));
pdf_dict_unmark(node);
}
if (names)
{
for (i = 0; i + 1 < pdf_array_len(names); i += 2)
{
pdf_obj *key = pdf_array_get(names, i);
pdf_obj *val = pdf_array_get(names, i + 1);
if (pdf_is_string(key))
{
key = pdf_to_utf8_name(ctx, key);
pdf_dict_put(dict, key, val);
pdf_drop_obj(key);
}
else if (pdf_is_name(key))
{
pdf_dict_put(dict, key, val);
}
}
}
}
void
pdf_annot_quad_point(fz_context *ctx, pdf_annot *annot, int idx, float v[8])
{
pdf_obj *quad_points;
pdf_obj *quad_point;
fz_matrix page_ctm;
int i;
check_allowed_subtypes(ctx, annot, PDF_NAME_QuadPoints, quad_point_subtypes);
quad_points = pdf_dict_get(ctx, annot->obj, PDF_NAME_QuadPoints);
quad_point = pdf_array_get(ctx, quad_points, idx);
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
for (i = 0; i < 8; i += 2)
{
fz_point point;
point.x = pdf_to_real(ctx, pdf_array_get(ctx, quad_point, i+0));
point.y = pdf_to_real(ctx, pdf_array_get(ctx, quad_point, i+1));
fz_transform_point(&point, &page_ctm);
v[i+0] = point.x;
v[i+1] = point.y;
}
}
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
pdf_annot_line_ending_styles(fz_context *ctx, pdf_annot *annot, int *start_style, int *end_style)
{
pdf_obj *style;
check_allowed_subtypes(ctx, annot, PDF_NAME_LE, line_ending_subtypes);
style = pdf_dict_get(ctx, annot->obj, PDF_NAME_LE);
*start_style = line_ending_value(ctx, pdf_array_get(ctx, style, 0));
*end_style = line_ending_value(ctx, pdf_array_get(ctx, style, 1));
}
void
pdf_annot_line_ending_styles(fz_context *ctx, pdf_annot *annot,
enum pdf_line_ending *start_style,
enum pdf_line_ending *end_style)
{
pdf_obj *style;
check_allowed_subtypes(ctx, annot, PDF_NAME(LE), line_ending_subtypes);
style = pdf_dict_get(ctx, annot->obj, PDF_NAME(LE));
*start_style = pdf_line_ending_from_name(ctx, pdf_array_get(ctx, style, 0));
*end_style = pdf_line_ending_from_name(ctx, pdf_array_get(ctx, style, 1));
}
static fz_colorspace *
load_separation(pdf_document *xref, pdf_obj *array)
{
fz_colorspace *cs;
struct separation *sep = NULL;
fz_context *ctx = xref->ctx;
pdf_obj *nameobj = pdf_array_get(array, 1);
pdf_obj *baseobj = pdf_array_get(array, 2);
pdf_obj *tintobj = pdf_array_get(array, 3);
fz_colorspace *base;
pdf_function *tint = NULL;
int n;
fz_var(tint);
fz_var(sep);
if (pdf_is_array(nameobj))
n = pdf_array_len(nameobj);
else
n = 1;
if (n > FZ_MAX_COLORS)
fz_throw(ctx, "too many components in colorspace");
base = pdf_load_colorspace(xref, baseobj);
/* RJW: "cannot load base colorspace (%d %d R)", pdf_to_num(baseobj), pdf_to_gen(baseobj) */
fz_try(ctx)
{
tint = pdf_load_function(xref, tintobj);
/* RJW: fz_drop_colorspace(ctx, base);
* "cannot load tint function (%d %d R)", pdf_to_num(tintobj), pdf_to_gen(tintobj) */
sep = fz_malloc_struct(ctx, struct separation);
sep->base = base;
sep->tint = tint;
cs = fz_new_colorspace(ctx, n == 1 ? "Separation" : "DeviceN", n);
cs->to_rgb = separation_to_rgb;
cs->free_data = free_separation;
cs->data = sep;
cs->size += sizeof(struct separation) + (base ? base->size : 0) + pdf_function_size(tint);
}
fz_catch(ctx)
{
fz_drop_colorspace(ctx, base);
pdf_drop_function(ctx, tint);
fz_free(ctx, sep);
fz_rethrow(ctx);
}
return cs;
}
static int
do_name_tree_map(fz_context *ctx, pdf_obj *tree, pdf_name_tree_map_fn *fn, void *arg)
{
int i;
int n = 0;
int m = 0;
fz_var(n);
fz_var(m);
if (pdf_mark_obj(ctx, tree))
fz_throw(ctx, FZ_ERROR_GENERIC, "Recursive name tree!");
fz_try(ctx)
{
pdf_obj *arr = pdf_dict_get(ctx, tree, PDF_NAME_Kids);
n = pdf_array_len(ctx, arr);
for (i = n; i > 0;)
{
i--;
if (do_name_tree_map(ctx, pdf_array_get(ctx, arr, i), fn, arg))
{
pdf_array_delete(ctx, arr, i);
n--;
}
}
arr = pdf_dict_get(ctx, tree, PDF_NAME_Names);
m = pdf_array_len(ctx, arr);
if (m & 1)
fz_throw(ctx, FZ_ERROR_GENERIC, "Malformed Names array");
for (i = m; i > 0;)
{
i -= 2;
if (fn(ctx, tree, pdf_array_get(ctx, arr, i), pdf_array_get(ctx, arr, i+1), arg))
{
pdf_array_delete(ctx, arr, i+1);
pdf_array_delete(ctx, arr, i);
m -= 2;
}
}
}
fz_always(ctx)
pdf_unmark_obj(ctx, tree);
fz_catch(ctx)
fz_rethrow(ctx);
return n == 0 && m == 0;
}
static void
pdf_load_radial_shading(fz_shade *shade, pdf_document *xref, pdf_obj *dict, int funcs, pdf_function **func)
{
pdf_obj *obj;
float d0, d1;
int e0, e1;
float x0, y0, r0, x1, y1, r1;
struct vertex p1, p2;
fz_context *ctx = xref->ctx;
obj = pdf_dict_gets(dict, "Coords");
x0 = pdf_to_real(pdf_array_get(obj, 0));
y0 = pdf_to_real(pdf_array_get(obj, 1));
r0 = pdf_to_real(pdf_array_get(obj, 2));
x1 = pdf_to_real(pdf_array_get(obj, 3));
y1 = pdf_to_real(pdf_array_get(obj, 4));
r1 = pdf_to_real(pdf_array_get(obj, 5));
d0 = 0;
d1 = 1;
obj = pdf_dict_gets(dict, "Domain");
if (pdf_array_len(obj) == 2)
{
d0 = pdf_to_real(pdf_array_get(obj, 0));
d1 = pdf_to_real(pdf_array_get(obj, 1));
}
e0 = e1 = 0;
obj = pdf_dict_gets(dict, "Extend");
if (pdf_array_len(obj) == 2)
{
e0 = pdf_to_bool(pdf_array_get(obj, 0));
e1 = pdf_to_bool(pdf_array_get(obj, 1));
}
pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1);
shade->type = FZ_RADIAL;
shade->extend[0] = e0;
shade->extend[1] = e1;
p1.x = x0;
p1.y = y0;
p1.c[0] = r0;
pdf_add_vertex(ctx, shade, &p1);
p2.x = x1;
p2.y = y1;
p2.c[0] = r1;
pdf_add_vertex(ctx, shade, &p2);
}
fz_rect *
pdf_to_rect(fz_context *ctx, pdf_obj *array, fz_rect *r)
{
float a = pdf_to_real(pdf_array_get(array, 0));
float b = pdf_to_real(pdf_array_get(array, 1));
float c = pdf_to_real(pdf_array_get(array, 2));
float d = pdf_to_real(pdf_array_get(array, 3));
r->x0 = fz_min(a, c);
r->y0 = fz_min(b, d);
r->x1 = fz_max(a, c);
r->y1 = fz_max(b, d);
return r;
}
/*
** Merge items in src array into dst array (do not duplicate items).
*/
static void wmupdf_array_merge(fz_context *ctx,char *arrayname,pdf_obj *dstarray,pdf_obj *srcarray)
{
int i,len;
/*
printf(" Merging %s arrays: %d <-- %d\n",arrayname,pdf_to_num(dstarray),pdf_to_num(srcarray));
*/
len=pdf_array_len(srcarray);
for (i=0;i<len;i++)
if (!pdf_array_contains(dstarray,pdf_array_get(srcarray,i)))
pdf_array_push(dstarray,pdf_array_get(srcarray,i));
}
static void
pdf_load_linear_shading(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, int funcs, fz_function **func)
{
pdf_obj *obj;
float d0, d1;
int e0, e1;
obj = pdf_dict_gets(ctx, dict, "Coords");
shade->u.l_or_r.coords[0][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0));
shade->u.l_or_r.coords[0][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1));
shade->u.l_or_r.coords[1][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 2));
shade->u.l_or_r.coords[1][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 3));
d0 = 0;
d1 = 1;
obj = pdf_dict_gets(ctx, dict, "Domain");
if (obj)
{
d0 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0));
d1 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1));
}
e0 = e1 = 0;
obj = pdf_dict_gets(ctx, dict, "Extend");
if (obj)
{
e0 = pdf_to_bool(ctx, pdf_array_get(ctx, obj, 0));
e1 = pdf_to_bool(ctx, pdf_array_get(ctx, obj, 1));
}
pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1);
shade->u.l_or_r.extend[0] = e0;
shade->u.l_or_r.extend[1] = e1;
}
static void
pdf_annot_color_imp(fz_context *ctx, pdf_annot *annot, pdf_obj *key, int *n, float color[4])
{
pdf_obj *obj = pdf_dict_get(ctx, annot->obj, key);
*n = 0;
if (pdf_is_array(ctx, obj))
{
switch (pdf_array_len(ctx, obj))
{
case 1:
*n = 1;
color[0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0));
break;
case 3:
*n = 3;
color[0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0));
color[1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1));
color[2] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 2));
break;
case 4:
*n = 4;
color[0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0));
color[1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1));
color[2] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 2));
color[3] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 3));
break;
}
}
}
static void
pdf_load_function_based_shading(fz_shade *shade, pdf_document *xref, pdf_obj *dict, pdf_function *func)
{
pdf_obj *obj;
float x0, y0, x1, y1;
float fv[2];
fz_matrix matrix;
int xx, yy;
fz_context *ctx = xref->ctx;
float *p;
x0 = y0 = 0;
x1 = y1 = 1;
obj = pdf_dict_gets(dict, "Domain");
if (obj)
{
x0 = pdf_to_real(pdf_array_get(obj, 0));
x1 = pdf_to_real(pdf_array_get(obj, 1));
y0 = pdf_to_real(pdf_array_get(obj, 2));
y1 = pdf_to_real(pdf_array_get(obj, 3));
}
obj = pdf_dict_gets(dict, "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;
pdf_eval_function(ctx, func, fv, 2, p, shade->colorspace->n);
p += shade->colorspace->n;
}
}
}
fz_rect
pdf_to_rect(fz_context *ctx, pdf_obj *array)
{
fz_rect r;
float a = pdf_to_real(pdf_array_get(array, 0));
float b = pdf_to_real(pdf_array_get(array, 1));
float c = pdf_to_real(pdf_array_get(array, 2));
float d = pdf_to_real(pdf_array_get(array, 3));
r.x0 = MIN(a, c);
r.y0 = MIN(b, d);
r.x1 = MAX(a, c);
r.y1 = MAX(b, d);
return r;
}
pdf_obj *
pdf_copy_array(fz_context *ctx, pdf_obj *obj)
{
pdf_document *doc;
pdf_obj *arr;
int i;
int n;
RESOLVE(obj);
if (!OBJ_IS_ARRAY(obj))
fz_throw(ctx, FZ_ERROR_GENERIC, "not an array (%s)", pdf_objkindstr(obj));
doc = ARRAY(obj)->doc;
n = pdf_array_len(ctx, obj);
arr = pdf_new_array(ctx, doc, n);
fz_try(ctx)
for (i = 0; i < n; i++)
pdf_array_push(ctx, arr, pdf_array_get(ctx, obj, i));
fz_catch(ctx)
{
pdf_drop_obj(ctx, arr);
fz_rethrow(ctx);
}
return arr;
}
/*
* 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;
}
/*
* 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_geta(ctx, stm, PDF_NAME_Filter, PDF_NAME_F);
if (filters)
{
if (pdf_name_eq(ctx, filters, PDF_NAME_Crypt))
return 1;
if (pdf_is_array(ctx, filters))
{
int n = pdf_array_len(ctx, filters);
for (i = 0; i < n; i++)
{
obj = pdf_array_get(ctx, filters, i);
if (pdf_name_eq(ctx, obj, PDF_NAME_Crypt))
return 1;
}
}
}
return 0;
}
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 int find_destination_pages(fz_context *ctx, pdf_obj *current, int page_num, pdf_obj **dest_pages, int *index)
{
if(!strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, current, "Type")), "Page")) {
return(--page_num);
} if(!strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, current, "Type")), "Pages")) {
pdf_obj *kids = pdf_dict_gets(ctx, current, "Kids");
pdf_obj *count_obj = pdf_dict_gets(ctx, current, "Count");
if(!pdf_is_array(ctx, kids) || !pdf_is_int(ctx, count_obj))
return(-2);
int count = pdf_to_int(ctx, count_obj);
int i;
for(i = 0; i < count; i++) {
pdf_obj *current_kid = pdf_array_get(ctx, kids, i);
page_num = find_destination_pages(ctx, current_kid, page_num, dest_pages, index);
if(page_num == -1) {
*index = i;
*dest_pages = current;
return(-2);
} else if(page_num == -2) {
return(-2); // just return, preserve index and dest_pages
}
}
return(page_num);
}
return(page_num);
}
static pdf_font_desc *
pdf_load_type0_font(pdf_document *xref, pdf_obj *dict)
{
pdf_obj *dfonts;
pdf_obj *dfont;
pdf_obj *subtype;
pdf_obj *encoding;
pdf_obj *to_unicode;
dfonts = pdf_dict_gets(dict, "DescendantFonts");
if (!dfonts)
fz_throw(xref->ctx, "cid font is missing descendant fonts");
dfont = pdf_array_get(dfonts, 0);
subtype = pdf_dict_gets(dfont, "Subtype");
encoding = pdf_dict_gets(dict, "Encoding");
to_unicode = pdf_dict_gets(dict, "ToUnicode");
if (pdf_is_name(subtype) && !strcmp(pdf_to_name(subtype), "CIDFontType0"))
return load_cid_font(xref, dfont, encoding, to_unicode);
else if (pdf_is_name(subtype) && !strcmp(pdf_to_name(subtype), "CIDFontType2"))
return load_cid_font(xref, dfont, encoding, to_unicode);
else
fz_throw(xref->ctx, "syntaxerror: unknown cid font type");
return NULL; /* Stupid MSVC */
}
fz_link *
pdf_load_link_annots(pdf_document *xref, pdf_obj *annots, fz_matrix page_ctm)
{
fz_link *link, *head, *tail;
pdf_obj *obj;
int i, n;
head = tail = NULL;
link = NULL;
n = pdf_array_len(annots);
for (i = 0; i < n; i++)
{
obj = pdf_array_get(annots, i);
link = pdf_load_link(xref, obj, page_ctm);
if (link)
{
if (!head)
head = tail = link;
else
{
tail->next = link;
tail = link;
}
}
}
return head;
}
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 int
pdf_name_tree_insert(fz_context *ctx, pdf_document *doc, pdf_obj *tree, pdf_obj *key, pdf_obj *val)
{
find_data data;
pdf_obj *names, *limits, *limit0, *limit1;
data.key = key;
data.found = NULL;
data.found_index = 0;
data.last = NULL;
data.last_index = 0;
data.entry = 0;
pdf_name_tree_map(ctx, tree, find_position, &data);
if (!data.found)
{
data.found = data.last;
data.found_index = data.last_index;
}
if (!data.found)
{
/* Completely empty name tree! */
pdf_dict_put_drop(ctx, tree, PDF_NAME_Names, pdf_new_array(ctx, doc, 2));
pdf_dict_put_drop(ctx, tree, PDF_NAME_Limits, pdf_new_array(ctx, doc, 2));
data.found = tree;
data.found_index = 0;
}
names = pdf_dict_get(ctx, data.found, PDF_NAME_Names);
if (names == NULL)
pdf_dict_put_drop(ctx, data.found, PDF_NAME_Names, (names = pdf_new_array(ctx, doc, 2)));
pdf_array_insert(ctx, names, key, 2*data.found_index);
pdf_array_insert(ctx, names, val, 2*data.found_index+1);
limits = pdf_dict_get(ctx, data.found, PDF_NAME_Limits);
if (limits == NULL)
pdf_dict_put_drop(ctx, data.found, PDF_NAME_Limits, (limits = pdf_new_array(ctx, doc, 2)));
limit0 = pdf_array_get(ctx, limits, 0);
limit1 = pdf_array_get(ctx, limits, 1);
if (!pdf_is_string(ctx, limit0) || data.found_index == 0)
pdf_array_put(ctx, limits, 0, key);
if (!pdf_is_string(ctx, limit1) || 2 * (data.found_index+1) == pdf_array_len(ctx, limits))
pdf_array_put(ctx, limits, 1, key);
return data.entry;
}
/*
* Build a chain of filters given filter names and param dicts.
* If head is given, start filter chain with it.
* Assume ownership of head.
*/
static fz_stream *
build_filter_chain(fz_stream *chain, pdf_document *xref, pdf_obj *fs, pdf_obj *ps, int num, int gen, pdf_image_params *params)
{
pdf_obj *f;
pdf_obj *p;
int i, n;
n = pdf_array_len(fs);
for (i = 0; i < n; i++)
{
f = pdf_array_get(fs, i);
p = pdf_array_get(ps, i);
chain = build_filter(chain, xref, f, p, num, gen, (i == n-1 ? params : NULL));
}
return chain;
}
float
pdf_annot_border(fz_context *ctx, pdf_annot *annot)
{
pdf_obj *border = pdf_dict_get(ctx, annot->obj, PDF_NAME_Border);
if (pdf_is_array(ctx, border))
return pdf_to_real(ctx, pdf_array_get(ctx, border, 2));
return 1;
}
void
pdf_annot_vertex(fz_context *ctx, pdf_annot *annot, int i, float v[2])
{
pdf_obj *vertices;
fz_matrix page_ctm;
fz_point point;
check_allowed_subtypes(ctx, annot, PDF_NAME_Vertices, vertices_subtypes);
vertices = pdf_dict_get(ctx, annot->obj, PDF_NAME_Vertices);
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
point.x = pdf_to_real(ctx, pdf_array_get(ctx, vertices, i * 2));
point.y = pdf_to_real(ctx, pdf_array_get(ctx, vertices, i * 2 + 1));
fz_transform_point(&point, &page_ctm);
v[0] = point.x;
v[1] = point.y;
}
int
pdf_annot_ink_list_stroke_count(fz_context *ctx, pdf_annot *annot, int i)
{
pdf_obj *ink_list;
pdf_obj *stroke;
check_allowed_subtypes(ctx, annot, PDF_NAME_InkList, ink_list_subtypes);
ink_list = pdf_dict_get(ctx, annot->obj, PDF_NAME_InkList);
stroke = pdf_array_get(ctx, ink_list, i);
return pdf_array_len(ctx, stroke);
}
