/* Check if an entry has a cached stream and return whether it is directly * reusable. A buffer is directly reusable only if the stream is * uncompressed, or if it is compressed purely a compression method we can * return details of in fz_compression_params. * * If the stream is reusable return 1, and set params as required, otherwise * return 0. */ static int can_reuse_buffer(fz_context *ctx, pdf_xref_entry *entry, fz_compression_params *params) { pdf_obj *f; pdf_obj *p; if (!entry || !entry->obj || !entry->stm_buf) return 0; if (params) params->type = FZ_IMAGE_RAW; f = pdf_dict_geta(ctx, entry->obj, PDF_NAME_Filter, PDF_NAME_F); /* If there are no filters, it's uncompressed, and we can use it */ if (!f) return 1; p = pdf_dict_geta(ctx, entry->obj, PDF_NAME_DecodeParms, PDF_NAME_DP); if (pdf_is_array(ctx, f)) { int len = pdf_array_len(ctx, f); /* Empty array of filters. It's uncompressed. We can cope. */ if (len == 0) return 1; /* 1 filter is the most we can hope to cope with - if more,*/ if (len != 1) return 0; p = pdf_array_get(ctx, p, 0); } if (pdf_is_null(ctx, f)) return 1; /* Null filter is uncompressed */ if (!pdf_is_name(ctx, f)) return 0; /* There are filters, so unless we have the option of shortstopping, * we can't use the existing buffer. */ if (!params) return 0; build_compression_params(ctx, f, p, params); return (params->type == FZ_IMAGE_RAW) ? 0 : 1; }
pdfout_data * pdfout_data_scalar_from_pdf (fz_context *ctx, pdf_obj *obj) { const char *s; if (pdf_is_null (ctx, obj)) return pdfout_data_scalar_new (ctx, "null", strlen ("null")); else if (pdf_is_bool (ctx, obj)) { if (pdf_to_bool (ctx, obj)) s = "true"; else s = "false"; return pdfout_data_scalar_new (ctx, s, strlen (s)); } else if (pdf_is_name (ctx, obj)) { s = pdf_to_name (ctx, obj); return pdfout_data_scalar_new (ctx, s, strlen (s)); } else if (pdf_is_string (ctx, obj)) { int len; char *str = pdfout_str_obj_to_utf8 (ctx, obj, &len); pdfout_data *result = pdfout_data_scalar_new (ctx, str, len); free (str); return result; } else if (pdf_is_int (ctx, obj)) { int n = pdf_to_int (ctx, obj); char buf[200]; int len = pdfout_snprintf (ctx, buf, "%d", n); return pdfout_data_scalar_new (ctx, buf, len); } else if (pdf_is_real (ctx, obj)) { float f = pdf_to_real (ctx, obj); char buf[200]; int len = pdfout_snprintf (ctx, buf, "%g", f); return pdfout_data_scalar_new (ctx, buf, len); } else abort(); }
static void gatherfonts(int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) { int i, n; n = pdf_dict_len(dict); for (i = 0; i < n; i++) { pdf_obj *fontdict = NULL; pdf_obj *subtype = NULL; pdf_obj *basefont = NULL; pdf_obj *name = NULL; int k; fontdict = pdf_dict_get_val(dict, i); if (!pdf_is_dict(fontdict)) { fz_warn(ctx, "not a font dict (%d %d R)", pdf_to_num(fontdict), pdf_to_gen(fontdict)); continue; } subtype = pdf_dict_gets(fontdict, "Subtype"); basefont = pdf_dict_gets(fontdict, "BaseFont"); if (!basefont || pdf_is_null(basefont)) name = pdf_dict_gets(fontdict, "Name"); for (k = 0; k < fonts; k++) if (!pdf_objcmp(font[k].u.font.obj, fontdict)) break; if (k < fonts) continue; font = fz_resize_array(ctx, font, fonts+1, sizeof(struct info)); fonts++; font[fonts - 1].page = page; font[fonts - 1].pageref = pageref; font[fonts - 1].pageobj = pageobj; font[fonts - 1].u.font.obj = fontdict; font[fonts - 1].u.font.subtype = subtype; font[fonts - 1].u.font.name = basefont ? basefont : name; } }