fz_error * pdf_loadfont(pdf_font **fontp, pdf_xref *xref, fz_obj *dict, fz_obj *ref) { fz_error *error; char *subtype; if ((*fontp = pdf_finditem(xref->store, PDF_KFONT, ref))) { fz_keepfont((fz_font*)*fontp); return fz_okay; } subtype = fz_toname(fz_dictgets(dict, "Subtype")); if (!strcmp(subtype, "Type0")) error = loadtype0(fontp, xref, dict, ref); else if (!strcmp(subtype, "Type1") || !strcmp(subtype, "MMType1")) error = loadsimplefont(fontp, xref, dict, ref); else if (!strcmp(subtype, "TrueType")) error = loadsimplefont(fontp, xref, dict, ref); else if (!strcmp(subtype, "Type3")) error = pdf_loadtype3font(fontp, xref, dict, ref); else return fz_throw("cannot recognize font format %s", subtype); if (error) return fz_rethrow(error, "cannot load font"); error = pdf_storeitem(xref->store, PDF_KFONT, ref, *fontp); if (error) return fz_rethrow(error, "cannot store font resource"); return fz_okay; }
static fz_obj * resolvedest(pdf_xref *xref, fz_obj *dest) { if (fz_isname(dest) || fz_isstring(dest)) { dest = pdf_lookupdest(xref, dest); return resolvedest(xref, dest); } else if (fz_isarray(dest)) { return fz_arrayget(dest, 0); } else if (fz_isdict(dest)) { dest = fz_dictgets(dest, "D"); return resolvedest(xref, dest); } else if (fz_isindirect(dest)) return dest; return nil; }
static fz_obj * resolvedest(pdf_xref *xref, fz_obj *dest) { if (fz_isname(dest)) { dest = fz_dictget(xref->dests, dest); if (dest) pdf_resolve(&dest, xref); /* XXX */ return resolvedest(xref, dest); } else if (fz_isstring(dest)) { dest = fz_dictget(xref->dests, dest); if (dest) pdf_resolve(&dest, xref); /* XXX */ return resolvedest(xref, dest); } else if (fz_isarray(dest)) { return fz_arrayget(dest, 0); } else if (fz_isdict(dest)) { dest = fz_dictgets(dest, "D"); return resolvedest(xref, dest); } else if (fz_isindirect(dest)) return dest; return nil; }
fz_error fz_newlzwe(fz_filter **fp, fz_obj *params) { FZ_NEWFILTER(fz_lzwe, lzw, lzwe); lzw->earlychange = 0; if (params) { fz_obj *obj; obj = fz_dictgets(params, "EarlyChange"); if (obj) lzw->earlychange = fz_toint(obj) != 0; } lzw->bidx = 0; lzw->bsave = 0; lzw->resume = 0; lzw->code = -1; lzw->hcode = -1; lzw->fcode = -1; lzw->codebits = MINBITS; lzw->nextcode = LZW_FIRST; lzw->oldcode = -1; /* generates LZW_CLEAR */ clearhash(lzw); return fz_okay; }
static void addhexfilter(fz_obj *dict) { fz_obj *f, *dp, *newf, *newdp; fz_obj *ahx, *nullobj; ahx = fz_newname("ASCIIHexDecode"); nullobj = fz_newnull(); newf = newdp = nil; f = fz_dictgets(dict, "Filter"); dp = fz_dictgets(dict, "DecodeParms"); if (fz_isname(f)) { newf = fz_newarray(2); fz_arraypush(newf, ahx); fz_arraypush(newf, f); f = newf; if (fz_isdict(dp)) { newdp = fz_newarray(2); fz_arraypush(newdp, nullobj); fz_arraypush(newdp, dp); dp = newdp; } } else if (fz_isarray(f)) { fz_arrayinsert(f, ahx); if (fz_isarray(dp)) fz_arrayinsert(dp, nullobj); } else f = ahx; fz_dictputs(dict, "Filter", f); if (dp) fz_dictputs(dict, "DecodeParms", dp); fz_dropobj(ahx); fz_dropobj(nullobj); if (newf) fz_dropobj(newf); if (newdp) fz_dropobj(newdp); }
static void writexref(void) { fz_obj *trailer; fz_obj *obj; int startxref; int num; startxref = ftell(out); fprintf(out, "xref\n0 %d\n", xref->len); for (num = 0; num < xref->len; num++) { if (uselist[num]) fprintf(out, "%010d %05d n \n", ofslist[num], genlist[num]); else fprintf(out, "%010d %05d f \n", ofslist[num], genlist[num]); } fprintf(out, "\n"); trailer = fz_newdict(5); obj = fz_newint(xref->len); fz_dictputs(trailer, "Size", obj); fz_dropobj(obj); obj = fz_dictgets(xref->trailer, "Info"); if (obj) fz_dictputs(trailer, "Info", obj); obj = fz_dictgets(xref->trailer, "Root"); if (obj) fz_dictputs(trailer, "Root", obj); obj = fz_dictgets(xref->trailer, "ID"); if (obj) fz_dictputs(trailer, "ID", obj); fprintf(out, "trailer\n"); fz_fprintobj(out, trailer, !doexpand); fprintf(out, "\n"); fz_dropobj(trailer); fprintf(out, "startxref\n%d\n%%%%EOF\n", startxref); }
BKPDF* BKPDF::create(string& file) { if (singleton != 0) { printf("cannot open more than 1 pdf at the same time\n"); return singleton; } reset_allocs(); BKPDF* b = new BKPDF(file); singleton = b; fz_setmemorycontext(&bkmem); fz_cpudetect(); fz_accelerate(); pdfInit(); PDFContext* ctx = pdfOpen((char*)file.c_str()); if (ctx == 0) { delete b; return 0; } b->ctx = ctx; int lastSlash = 0; int n = file.size(); for (int i = 0; i < n; ++i) { if (file[i] == '\\') lastSlash == i++; else if (file[i] == '/') lastSlash == i++; } b->title.assign(file, lastSlash, n - lastSlash); if (ctx->xref->info) { fz_error *error; fz_obj *obj; obj = fz_dictgets(ctx->xref->info, "Title"); if (obj) { char *p = NULL; error = pdf_toutf8(&p, obj); if (error == NULL) { b->title = p; } } } // Add bookmark support //int position = BKBookmark::getLastView(b->filePath); //b->setPage(position); b->pageError = pdfLoadPage(ctx) != 0; FZScreen::resetReps(); b->redrawBuffer(); print_allocs(); lastScrollFlag = BKUser::options.pdfFastScroll; return b; }
fz_error * pdf_loadannots(pdf_comment **cp, pdf_link **lp, pdf_xref *xref, fz_obj *annots) { fz_error *error; pdf_comment *comment; pdf_link *link; fz_obj *subtype; fz_obj *obj; int i; comment = nil; link = nil; pdf_logpage("load annotations {\n"); for (i = 0; i < fz_arraylen(annots); i++) { obj = fz_arrayget(annots, i); error = pdf_resolve(&obj, xref); if (error) goto cleanup; subtype = fz_dictgets(obj, "Subtype"); if (!strcmp(fz_toname(subtype), "Link")) { pdf_link *temp = nil; error = pdf_loadlink(&temp, xref, obj); fz_dropobj(obj); if (error) goto cleanup; if (temp) { temp->next = link; link = temp; } } else { error = loadcomment(&comment, xref, obj); fz_dropobj(obj); if (error) goto cleanup; } } pdf_logpage("}\n"); *cp = comment; *lp = link; return nil; cleanup: pdf_droplink(link); return error; }
fz_error* setPageMediaBox( pdf_xref* pdfXRef, fz_obj* pageObj, fz_rect mediaBox ) { fz_error *error; fz_obj *objMedia; fz_irect mRect; fz_obj *objInt; // Delete the CropBox. This is done because we are reducing // the size of the media box and CropBox is of no use to us fz_dictdels(pageObj, "CropBox"); //objMedia = fz_dictgets(pageObj, "CropBox"); //if (objMedia == NULL) return fz_throw("no CropBox entry"); //error = pdf_resolve(&objMedia, pdfXRef); //if (error) return fz_rethrow(error, "cannot resolve page bounds"); //if (! fz_isarray(objMedia)) return fz_throw("cannot find page bounds"); //fz_rect cRect = pdf_torect(objMedia); // Get the media box objMedia = fz_dictgets(pageObj, "MediaBox"); if (objMedia == NULL) return fz_throw("no MediaBox entry"); error = pdf_resolve(&objMedia, pdfXRef); if (error) return fz_rethrow(error, "cannot resolve page bounds"); if (! fz_isarray(objMedia)) return fz_throw("cannot find page bounds"); // We have the MediaBox array here mRect = fz_roundrect(mediaBox); error = fz_newint(&objInt, mRect.x0); if (error) return fz_rethrow(error, "cannot allocate int"); fz_arrayput(objMedia, 0, objInt); fz_dropobj(objInt); error = fz_newint(&objInt, mRect.y0); if (error) return fz_rethrow(error, "cannot allocate int"); fz_arrayput(objMedia, 1, objInt); fz_dropobj(objInt); error = fz_newint(&objInt, mRect.x1); if (error) return fz_rethrow(error, "cannot allocate int"); fz_arrayput(objMedia, 2, objInt); fz_dropobj(objInt); error = fz_newint(&objInt, mRect.y1); if (error) return fz_rethrow(error, "cannot allocate int"); fz_arrayput(objMedia, 3, objInt); fz_dropobj(objInt); return NULL; }
void openxref(char *filename, char *password, int dieonbadpass) { fz_error error; int okay; basename = strrchr(filename, '/'); if (!basename) basename = filename; else basename++; xref = pdf_newxref(); error = pdf_loadxref(xref, filename); if (error) { fz_catch(error, "trying to repair"); error = pdf_repairxref(xref, filename); if (error) die(error); } error = pdf_decryptxref(xref); if (error) die(error); if (pdf_needspassword(xref)) { okay = pdf_authenticatepassword(xref, password); if (!okay && !dieonbadpass) fz_warn("invalid password, attempting to continue."); else if (!okay && dieonbadpass) die(fz_throw("invalid password")); } xref->root = fz_dictgets(xref->trailer, "Root"); if (xref->root) fz_keepobj(xref->root); xref->info = fz_dictgets(xref->trailer, "Info"); if (xref->info) fz_keepobj(xref->info); pagecount = pdf_getpagecount(xref); }
static fz_colorspace * loadcalgray(pdf_xref *xref, fz_obj *dict) { struct calgray *cs; fz_obj *tmp; cs = fz_malloc(sizeof(struct calgray)); pdf_logrsrc("load CalGray\n"); initcs((fz_colorspace*)cs, "CalGray", 1, graytoxyz, xyztogray, nil); cs->white[0] = 1.0; cs->white[1] = 1.0; cs->white[2] = 1.0; cs->black[0] = 0.0; cs->black[1] = 0.0; cs->black[2] = 0.0; cs->gamma = 1.0; tmp = fz_dictgets(dict, "WhitePoint"); if (fz_isarray(tmp)) { cs->white[0] = fz_toreal(fz_arrayget(tmp, 0)); cs->white[1] = fz_toreal(fz_arrayget(tmp, 1)); cs->white[2] = fz_toreal(fz_arrayget(tmp, 2)); } tmp = fz_dictgets(dict, "BlackPoint"); if (fz_isarray(tmp)) { cs->black[0] = fz_toreal(fz_arrayget(tmp, 0)); cs->black[1] = fz_toreal(fz_arrayget(tmp, 1)); cs->black[2] = fz_toreal(fz_arrayget(tmp, 2)); } tmp = fz_dictgets(dict, "Gamma"); if (fz_isreal(tmp)) cs->gamma = fz_toreal(tmp); return (fz_colorspace*) cs; }
fz_error pdf_loadannots(pdf_comment **cp, pdf_link **lp, pdf_xref *xref, fz_obj *annots) { fz_error error; pdf_comment *comment; pdf_link *link; fz_obj *subtype; fz_obj *obj; int i; comment = nil; link = nil; pdf_logpage("load annotations {\n"); for (i = 0; i < fz_arraylen(annots); i++) { obj = fz_arrayget(annots, i); subtype = fz_dictgets(obj, "Subtype"); if (fz_isname(subtype) && !strcmp(fz_toname(subtype), "Link")) { pdf_link *temp = nil; error = pdf_loadlink(&temp, xref, obj); if (error) { if (link) pdf_droplink(link); return fz_rethrow(error, "cannot load annotation link"); } if (temp) { temp->next = link; link = temp; } } else { error = loadcomment(&comment, xref, obj); if (error) { if (link) pdf_droplink(link); return fz_rethrow(error, "cannot load annotation comment"); } } } pdf_logpage("}\n"); *cp = comment; *lp = link; return fz_okay; }
static fz_error * loadtype0(pdf_font **fontp, pdf_xref *xref, fz_obj *dict, fz_obj *ref) { fz_error *error; fz_obj *dfonts; fz_obj *dfont; fz_obj *subtype; fz_obj *encoding; fz_obj *tounicode; dfonts = fz_dictgets(dict, "DescendantFonts"); error = pdf_resolve(&dfonts, xref); if (error) return fz_rethrow(error, "cannot find DescendantFonts"); dfont = fz_arrayget(dfonts, 0); error = pdf_resolve(&dfont, xref); if (error) { fz_dropobj(dfonts); return fz_rethrow(error, "cannot find descendant font"); } subtype = fz_dictgets(dfont, "Subtype"); encoding = fz_dictgets(dict, "Encoding"); tounicode = fz_dictgets(dict, "ToUnicode"); if (!strcmp(fz_toname(subtype), "CIDFontType0")) error = loadcidfont(fontp, xref, dfont, ref, encoding, tounicode); else if (!strcmp(fz_toname(subtype), "CIDFontType2")) error = loadcidfont(fontp, xref, dfont, ref, encoding, tounicode); else error = fz_throw("syntaxerror: unknown cid font type"); fz_dropobj(dfont); fz_dropobj(dfonts); if (error) return fz_rethrow(error, "cannot load descendant font"); return fz_okay; }
static int pdf_xobjectusesblending(fz_obj *dict) { fz_obj *obj; obj = fz_dictgets(dict, "Resources"); if (fz_isdict(obj) && pdf_resourcesuseblending(obj)) return 1; return 0; }
static int pdf_extgstateusesblending(fz_obj *dict) { fz_obj *obj; obj = fz_dictgets(dict, "BM"); if (fz_isname(obj) && strcmp(fz_toname(obj), "Normal")) return 1; return 0; }
static fz_error pdf_loadxref(pdf_xref *xref, char *buf, int bufsize) { fz_error error; fz_obj *size; int i; error = pdf_loadversion(xref); if (error) return fz_rethrow(error, "cannot read version marker"); error = pdf_readstartxref(xref); if (error) return fz_rethrow(error, "cannot read startxref"); error = pdf_readtrailer(xref, buf, bufsize); if (error) return fz_rethrow(error, "cannot read trailer"); size = fz_dictgets(xref->trailer, "Size"); if (!size) return fz_throw("trailer missing Size entry"); pdf_logxref("\tsize %d at 0x%x\n", fz_toint(size), xref->startxref); xref->len = fz_toint(size); xref->cap = xref->len + 1; /* for hack to allow broken pdf generators with off-by-one errors */ xref->table = fz_malloc(xref->cap * sizeof(pdf_xrefentry)); for (i = 0; i < xref->cap; i++) { xref->table[i].ofs = 0; xref->table[i].gen = 0; xref->table[i].stmofs = 0; xref->table[i].obj = nil; xref->table[i].type = 0; } error = pdf_readxrefsections(xref, xref->startxref, buf, bufsize); if (error) return fz_rethrow(error, "cannot read xref"); /* broken pdfs where first object is not free */ if (xref->table[0].type != 'f') return fz_throw("first object in xref is not free"); /* broken pdfs where object offsets are out of range */ for (i = 0; i < xref->len; i++) if (xref->table[i].type == 'n') if (xref->table[i].ofs <= 0 || xref->table[i].ofs >= xref->filesize) return fz_throw("object offset out of range: %d", xref->table[i].ofs); return fz_okay; }
fz_error * fz_newpredict(fz_filter **fp, fz_obj *params, int encode) { fz_obj *obj; FZ_NEWFILTER(fz_predict, p, predict); p->encode = encode; p->predictor = 1; p->columns = 1; p->colors = 1; p->bpc = 8; obj = fz_dictgets(params, "Predictor"); if (obj) p->predictor = fz_toint(obj); obj = fz_dictgets(params, "Columns"); if (obj) p->columns = fz_toint(obj); obj = fz_dictgets(params, "Colors"); if (obj) p->colors = fz_toint(obj); obj = fz_dictgets(params, "BitsPerComponent"); if (obj) p->bpc = fz_toint(obj); p->stride = (p->bpc * p->colors * p->columns + 7) / 8; p->bpp = (p->bpc * p->colors + 7) / 8; if (p->predictor >= 10) { p->ref = fz_malloc(p->stride); if (!p->ref) { fz_free(p); return fz_throw("outofmem: predictor reference buffer"); } memset(p->ref, 0, p->stride); } else { p->ref = nil; } return fz_okay; }
fz_error * pdf_loadnametrees(pdf_xref *xref) { fz_error *error; fz_obj *names; fz_obj *dests; /* PDF 1.1 */ dests = fz_dictgets(xref->root, "Dests"); if (dests) { error = pdf_resolve(&dests, xref); if (error) return error; xref->dests = dests; return nil; } /* PDF 1.2 */ names = fz_dictgets(xref->root, "Names"); if (names) { error = pdf_resolve(&names, xref); if (error) return error; dests = fz_dictgets(names, "Dests"); if (dests) { error = pdf_loadnametree(&xref->dests, xref, dests); if (error) { fz_dropobj(names); return error; } } fz_dropobj(names); } return nil; }
fz_error * pdf_loadoutline(pdf_outline **nodep, pdf_xref *xref) { fz_error *error; pdf_outline *node; fz_obj *obj; fz_obj *first; pdf_logpage("load outlines {\n"); node = nil; obj = fz_dictgets(xref->root, "Outlines"); if (obj) { error = pdf_resolve(&obj, xref); if (error) return error; first = fz_dictgets(obj, "First"); if (first) { error = pdf_resolve(&first, xref); fz_dropobj(obj); if (error) return error; error = loadoutline(&node, xref, first); fz_dropobj(first); if (error) return error; } else fz_dropobj(obj); } pdf_logpage("}\n"); *nodep = node; return nil; }
static fz_error pdf_readxrefsections(pdf_xref *xref, int ofs, char *buf, int cap) { fz_error error; fz_obj *trailer; fz_obj *prev; fz_obj *xrefstm; error = pdf_readxref(&trailer, xref, ofs, buf, cap); if (error) return fz_rethrow(error, "cannot read xref section"); /* FIXME: do we overwrite free entries properly? */ xrefstm = fz_dictgets(trailer, "XRefStm"); if (xrefstm) { pdf_logxref("load xrefstm\n"); error = pdf_readxrefsections(xref, fz_toint(xrefstm), buf, cap); if (error) { fz_dropobj(trailer); return fz_rethrow(error, "cannot read /XRefStm xref section"); } } prev = fz_dictgets(trailer, "Prev"); if (prev) { pdf_logxref("load prev at 0x%x\n", fz_toint(prev)); error = pdf_readxrefsections(xref, fz_toint(prev), buf, cap); if (error) { fz_dropobj(trailer); return fz_rethrow(error, "cannot read /Prev xref section"); } } fz_dropobj(trailer); return fz_okay; }
static fz_error pdf_repairobjstm(pdf_xref *xref, int num, int gen) { fz_error error; fz_obj *obj; fz_stream *stm; int tok; int i, n, count; char buf[256]; error = pdf_loadobject(&obj, xref, num, gen); if (error) return fz_rethrow(error, "cannot load object stream object (%d %d R)", num, gen); count = fz_toint(fz_dictgets(obj, "N")); fz_dropobj(obj); error = pdf_openstream(&stm, xref, num, gen); if (error) return fz_rethrow(error, "cannot open object stream object (%d %d R)", num, gen); for (i = 0; i < count; i++) { error = pdf_lex(&tok, stm, buf, sizeof buf, &n); if (error || tok != PDF_TINT) { fz_close(stm); return fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen); } n = atoi(buf); if (n >= xref->len) pdf_resizexref(xref, n + 1); xref->table[n].ofs = num; xref->table[n].gen = i; xref->table[n].stmofs = 0; xref->table[n].obj = nil; xref->table[n].type = 'o'; error = pdf_lex(&tok, stm, buf, sizeof buf, &n); if (error || tok != PDF_TINT) { fz_close(stm); return fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen); } } fz_close(stm); return fz_okay; }
int epdf_index_item_page_get(const Epdf_Document *doc, const Epdf_Index_Item *item) { fz_obj *dest; int p; int n; int g; if (!item || !item->link) return -1; if (PDF_LGOTO != item->link->kind) return -1; dest = item->link->dest; p = 0; if (fz_isint(dest)) { p = fz_toint(dest); return p; } if (fz_isdict(dest)) { /* The destination is linked from a Go-To action's D array */ fz_obj *D; D = fz_dictgets(dest, "D"); if (D && fz_isarray(D)) dest = fz_arrayget(D, 0); } n = fz_tonum(dest); g = fz_togen(dest); for (p = 1; p <= epdf_document_page_count_get(doc); p++) { fz_obj *page; int np; int gp; page = pdf_getpageobject(doc->xref, p); if (!page) continue; np = fz_tonum(page); gp = fz_togen(page); if (n == np && g == gp) return p-1; } return 0; }
static int pdf_resourcesuseblending(fz_obj *rdb) { fz_obj *dict; fz_obj *tmp; int i; /* stop on cyclic resource dependencies */ if (fz_dictgets(rdb, ".useBM")) return fz_tobool(fz_dictgets(rdb, ".useBM")); tmp = fz_newbool(0); fz_dictputs(rdb, ".useBM", tmp); fz_dropobj(tmp); dict = fz_dictgets(rdb, "ExtGState"); for (i = 0; i < fz_dictlen(dict); i++) if (pdf_extgstateusesblending(fz_dictgetval(dict, i))) goto found; dict = fz_dictgets(rdb, "Pattern"); for (i = 0; i < fz_dictlen(dict); i++) if (pdf_patternusesblending(fz_dictgetval(dict, i))) goto found; dict = fz_dictgets(rdb, "XObject"); for (i = 0; i < fz_dictlen(dict); i++) if (pdf_xobjectusesblending(fz_dictgetval(dict, i))) goto found; return 0; found: tmp = fz_newbool(1); fz_dictputs(rdb, ".useBM", tmp); fz_dropobj(tmp); return 1; }
int pdf_isjpximage(fz_obj *dict) { fz_obj *filter; int i; filter = fz_dictgets(dict, "Filter"); if (!strcmp(fz_toname(filter), "JPXDecode")) return 1; for (i = 0; i < fz_arraylen(filter); i++) if (!strcmp(fz_toname(fz_arrayget(filter, i)), "JPXDecode")) return 1; return 0; }
pdf_outline * pdf_loadoutline(pdf_xref *xref) { pdf_outline *node; fz_obj *root, *obj, *first; pdf_logpage("load outlines {\n"); node = nil; root = fz_dictgets(xref->trailer, "Root"); obj = fz_dictgets(root, "Outlines"); if (obj) { first = fz_dictgets(obj, "First"); if (first) node = pdf_loadoutlineimp(xref, first); } pdf_logpage("}\n"); return node; }
static fz_error gathershadings(int page, fz_obj *pageobj, fz_obj *dict) { int i; for (i = 0; i < fz_dictlen(dict); i++) { fz_obj *ref; fz_obj *shade; fz_obj *type; int k; shade = ref = fz_dictgetval(dict, i); if (!fz_isdict(shade)) return fz_throw("not a shading dict (%d %d R)", fz_tonum(ref), fz_togen(ref)); type = fz_dictgets(shade, "ShadingType"); if (!fz_isint(type) || fz_toint(type) < 1 || fz_toint(type) > 7) { fz_warn("not a shading type (%d %d R)", fz_tonum(ref), fz_togen(ref)); type = nil; } for (k = 0; k < shadings; k++) if (fz_tonum(shading[k]->ref) == fz_tonum(ref) && fz_togen(shading[k]->ref) == fz_togen(ref)) break; if (k < shadings) continue; shadings++; shading = fz_realloc(shading, shadings * sizeof (struct info *)); if (!shading) return fz_throw("out of memory"); shading[shadings - 1] = fz_malloc(sizeof (struct info)); if (!shading[shadings - 1]) return fz_throw("out of memory"); shading[shadings - 1]->page = page; shading[shadings - 1]->pageobj = pageobj; shading[shadings - 1]->ref = ref; shading[shadings - 1]->u.shading.type = type; } return fz_okay; }
fz_filter * fz_newdctd(fz_obj *params) { fz_obj *obj; int colortransform; FZ_NEWFILTER(fz_dctd, d, dctd); colortransform = -1; /* "unset" */ if (params) { obj = fz_dictgets(params, "ColorTransform"); if (obj) colortransform = fz_toint(obj); } d->colortransform = colortransform; d->stage = 0; /* setup error callback first thing */ myiniterr(&d->err); d->cinfo.err = (struct jpeg_error_mgr*) &d->err; if (setjmp(d->err.jb)) fz_warn("cannot initialise jpeg: %s", d->err.msg); /* create decompression object. this zeroes cinfo except for err. */ jpeg_create_decompress(&d->cinfo); /* prepare source manager */ d->cinfo.src = (struct jpeg_source_mgr *)&d->src; d->src.super.init_source = myinitsource; d->src.super.fill_input_buffer = myfillinput; d->src.super.skip_input_data = myskipinput; d->src.super.resync_to_restart = jpeg_resync_to_restart; d->src.super.term_source = mytermsource; d->src.super.bytes_in_buffer = 0; d->src.super.next_input_byte = nil; d->src.skip = 0; /* speed up jpeg decoding a bit */ d->cinfo.dct_method = JDCT_FASTEST; d->cinfo.do_fancy_upsampling = FALSE; return (fz_filter *)d; }
/* * Build a filter for reading raw stream data. * This is a null filter to constrain reading to the * stream length, followed by a decryption filter. */ static fz_error * buildrawfilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj, int oid, int gen) { fz_error *error; fz_filter *base; fz_obj *stmlen; int len; stmlen = fz_dictgets(stmobj, "Length"); error = pdf_resolve(&stmlen, xref); if (error) return fz_rethrow(error, "cannot resolve stream /Length"); len = fz_toint(stmlen); fz_dropobj(stmlen); error = fz_newnullfilter(&base, len); if (error) return fz_rethrow(error, "cannot create null filter"); if (xref->crypt) { fz_filter *crypt; fz_filter *pipe; error = pdf_cryptstream(&crypt, xref->crypt, oid, gen); if (error) { fz_dropfilter(base); return fz_rethrow(error, "cannot create decryption filter"); } error = fz_newpipeline(&pipe, base, crypt); fz_dropfilter(base); fz_dropfilter(crypt); if (error) return fz_rethrow(error, "cannot create pipeline filter"); *filterp = pipe; } else { *filterp = base; } return fz_okay; }
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 pdf_outline * pdf_loadoutlineimp(pdf_xref *xref, fz_obj *dict) { pdf_outline *node; fz_obj *obj; if (fz_isnull(dict)) return nil; node = fz_malloc(sizeof(pdf_outline)); node->title = nil; node->link = nil; node->child = nil; node->next = nil; node->count = 0; pdf_logpage("load outline {\n"); obj = fz_dictgets(dict, "Title"); if (obj) { node->title = pdf_toutf8(obj); pdf_logpage("title %s\n", node->title); } obj = fz_dictgets(dict, "Count"); if (obj) { node->count = fz_toint(obj); } if (fz_dictgets(dict, "Dest") || fz_dictgets(dict, "A")) { node->link = pdf_loadlink(xref, dict); } obj = fz_dictgets(dict, "First"); if (obj) { node->child = pdf_loadoutlineimp(xref, obj); } pdf_logpage("}\n"); obj = fz_dictgets(dict, "Next"); if (obj) { node->next = pdf_loadoutlineimp(xref, obj); } return node; }