void pdfapp_close(pdfapp_t *app) { if (app->cache) fz_free_glyph_cache(app->cache); app->cache = NULL; if (app->image) fz_drop_pixmap(app->image); app->image = NULL; if (app->outline) pdf_free_outline(app->outline); app->outline = NULL; if (app->xref) { if (app->xref->store) pdf_free_store(app->xref->store); app->xref->store = NULL; pdf_free_xref(app->xref); app->xref = NULL; } if (app->xps) { xps_free_context(app->xps); app->xps = NULL; } fz_flush_warnings(); }
static void _pdf_doc_clear(struct _pdf_doc *self) { int i, c = mume_docdoc_count_pages(self); if (self->pages) { for (i = 0; i < c; ++i) { if (self->pages[i]) pdf_free_page(self->pages[i]); } free(self->pages); } if (self->disps) { for (i = 0; i < c; ++i) { if (self->disps[i]) fz_free_display_list(self->disps[i]); } free(self->disps); } if (self->glyph_cache) fz_free_glyph_cache(self->glyph_cache); if (self->xref) pdf_free_xref(self->xref); free(self->media_boxes); free(self->page_rotates); _pdf_doc_reset(self); }
void die(fz_error error) { fz_error_handle(ctx, error, "aborting"); if (xref) pdf_free_xref(xref); exit(1); }
Pdf::~Pdf() { pdf_free_xref(xref); --references; if (references == 0) { fz_free_glyph_cache(ctx, cache); cache = 0; fz_free_context(ctx); ctx = 0; } }
bool Pdf::open(const QString& path) { char* name = path.toAscii().data(); fz_try(ctx) { xref = pdf_open_xref(ctx, name, 0); pdf_load_page_tree(xref); } fz_catch(ctx) { pdf_free_xref(xref); xref = 0; } return true; }
int main(int argc, char **argv) { fz_error error; char *infile; char *password = ""; int c, o; while ((c = fz_getopt(argc, argv, "p:r")) != -1) { switch (c) { case 'p': password = fz_optarg; break; case 'r': dorgb++; break; default: usage(); break; } } if (fz_optind == argc) usage(); infile = argv[fz_optind++]; ctx = fz_context_init(&fz_alloc_default); if (ctx == NULL) die(fz_error_note(ctx, 1, "failed to initialise context")); error = pdf_open_xref(ctx, &xref, infile, password); if (error) die(fz_error_note(ctx, error, "cannot open input file '%s'", infile)); if (fz_optind == argc) { for (o = 0; o < xref->len; o++) showobject(o); } else { while (fz_optind < argc) { showobject(atoi(argv[fz_optind])); fz_optind++; } } pdf_free_xref(xref); fz_flush_warnings(ctx); fz_context_fin(ctx); return 0; }
void pdfapp_close(pdfapp_t *app) { #if 0 if (app->page) pdf_droppage(app->page); app->page = nil; if (app->image) fz_droppixmap(app->image); app->image = nil; /* if (app->outline) pdf_dropoutline(app->outline); app->outline = nil;*/ if (app->xref->store) pdf_dropstore(app->xref->store); app->xref->store = nil; pdf_closexref(app->xref); app->xref = nil; #else if (app->cache) fz_free_glyph_cache(app->cache); app->cache = NULL; if (app->image) fz_drop_pixmap(app->image); app->image = NULL; if (app->outline) pdf_free_outline(app->outline); app->outline = NULL; if (app->xref) { if (app->xref->store) pdf_free_store(app->xref->store); app->xref->store = NULL; pdf_free_xref(app->xref); app->xref = NULL; } fz_flush_warnings(); #endif }
int main(int argc, char **argv) { fz_error error; char *infile; char *outfile = "out.pdf"; char *password = ""; int c, num; int subset; while ((c = fz_getopt(argc, argv, "adgp:")) != -1) { switch (c) { case 'p': password = fz_optarg; break; case 'g': dogarbage ++; break; case 'd': doexpand ++; break; case 'a': doascii ++; break; default: usage(); break; } } if (argc - fz_optind < 1) usage(); infile = argv[fz_optind++]; if (argc - fz_optind > 0 && (strstr(argv[fz_optind], ".pdf") || strstr(argv[fz_optind], ".PDF"))) { outfile = argv[fz_optind++]; } subset = 0; if (argc - fz_optind > 0) subset = 1; ctx = fz_context_init(&fz_alloc_default); if (ctx == NULL) die(fz_error_note(ctx, 1, "failed to initialise context")); error = pdf_open_xref(ctx, &xref, infile, password); if (error) die(fz_error_note(ctx, error, "cannot open input file '%s'", infile)); out = fopen(outfile, "wb"); if (!out) die(fz_error_make(ctx, "cannot open output file '%s'", outfile)); fprintf(out, "%%PDF-%d.%d\n", xref->version / 10, xref->version % 10); fprintf(out, "%%\316\274\341\277\246\n\n"); uselist = fz_calloc(ctx, xref->len + 1, sizeof(char)); ofslist = fz_calloc(ctx, xref->len + 1, sizeof(int)); genlist = fz_calloc(ctx, xref->len + 1, sizeof(int)); renumbermap = fz_calloc(ctx, xref->len + 1, sizeof(int)); for (num = 0; num < xref->len; num++) { uselist[num] = 0; ofslist[num] = 0; genlist[num] = 0; renumbermap[num] = num; } /* Make sure any objects hidden in compressed streams have been loaded */ preloadobjstms(); /* Only retain the specified subset of the pages */ if (subset) retainpages(argc, argv); /* Sweep & mark objects from the trailer */ if (dogarbage >= 1) sweepobj(xref->trailer); /* Coalesce and renumber duplicate objects */ if (dogarbage >= 3) removeduplicateobjs(); /* Compact xref by renumbering and removing unused objects */ if (dogarbage >= 2) compactxref(); /* Make renumbering affect all indirect references and update xref */ /* Do not renumber objects if encryption is in use, as the object * numbers are baked into the streams/strings, and we can't currently * cope with moving them. See bug 692627. */ if (dogarbage >= 2 && xref->crypt == NULL) renumberobjs(); writepdf(); if (fclose(out)) die(fz_error_make(ctx, "cannot close output file '%s'", outfile)); fz_free(xref->ctx, uselist); fz_free(xref->ctx, ofslist); fz_free(xref->ctx, genlist); fz_free(xref->ctx, renumbermap); pdf_free_xref(xref); fz_flush_warnings(ctx); fz_context_fin(ctx); return 0; }
fz_error pdf_open_xref_with_stream(pdf_xref **xrefp, fz_stream *file, char *password) { pdf_xref *xref; fz_error error; fz_obj *encrypt, *id; fz_obj *dict, *obj; int i, repaired = 0; /* install pdf specific callback */ fz_resolve_indirect = pdf_resolve_indirect; xref = fz_malloc(sizeof(pdf_xref)); memset(xref, 0, sizeof(pdf_xref)); xref->file = fz_keep_stream(file); error = pdf_load_xref(xref, xref->scratch, sizeof xref->scratch); if (error) { fz_catch(error, "trying to repair"); if (xref->table) { fz_free(xref->table); xref->table = NULL; xref->len = 0; } if (xref->trailer) { fz_drop_obj(xref->trailer); xref->trailer = NULL; } error = pdf_repair_xref(xref, xref->scratch, sizeof xref->scratch); if (error) { pdf_free_xref(xref); return fz_rethrow(error, "cannot repair document"); } repaired = 1; } encrypt = fz_dict_gets(xref->trailer, "Encrypt"); id = fz_dict_gets(xref->trailer, "ID"); if (fz_is_dict(encrypt)) { error = pdf_new_crypt(&xref->crypt, encrypt, id); if (error) { pdf_free_xref(xref); return fz_rethrow(error, "cannot decrypt document"); } } if (pdf_needs_password(xref)) { /* Only care if we have a password */ if (password) { int okay = pdf_authenticate_password(xref, password); if (!okay) { pdf_free_xref(xref); return fz_throw("invalid password"); } } } if (repaired) { int hasroot, hasinfo; error = pdf_repair_obj_stms(xref); if (error) { pdf_free_xref(xref); return fz_rethrow(error, "cannot repair document"); } hasroot = fz_dict_gets(xref->trailer, "Root") != NULL; hasinfo = fz_dict_gets(xref->trailer, "Info") != NULL; for (i = 1; i < xref->len; i++) { if (xref->table[i].type == 0 || xref->table[i].type == 'f') continue; error = pdf_load_object(&dict, xref, i, 0); if (error) { fz_catch(error, "ignoring broken object (%d 0 R)", i); continue; } if (!hasroot) { obj = fz_dict_gets(dict, "Type"); if (fz_is_name(obj) && !strcmp(fz_to_name(obj), "Catalog")) { obj = fz_new_indirect(i, 0, xref); fz_dict_puts(xref->trailer, "Root", obj); fz_drop_obj(obj); } } if (!hasinfo) { if (fz_dict_gets(dict, "Creator") || fz_dict_gets(dict, "Producer")) { obj = fz_new_indirect(i, 0, xref); fz_dict_puts(xref->trailer, "Info", obj); fz_drop_obj(obj); } } fz_drop_obj(dict); } } error = pdf_read_ocg(xref); if (error) { pdf_free_xref(xref); return fz_rethrow(error, "Broken Optional Content"); } *xrefp = xref; return fz_okay; }