forked from KolibriOS/kolibrios
386 lines
8.8 KiB
C
Executable File
386 lines
8.8 KiB
C
Executable File
#include "fitz.h"
|
|
#include "mupdf.h"
|
|
|
|
/*
|
|
* Check if an object is a stream or not.
|
|
*/
|
|
int
|
|
pdf_is_stream(pdf_xref *xref, int num, int gen)
|
|
{
|
|
fz_error error;
|
|
|
|
if (num < 0 || num >= xref->len)
|
|
return 0;
|
|
|
|
error = pdf_cache_object(xref, num, gen);
|
|
if (error)
|
|
{
|
|
fz_catch(error, "cannot load object, ignoring error");
|
|
return 0;
|
|
}
|
|
|
|
return xref->table[num].stm_ofs > 0;
|
|
}
|
|
|
|
/*
|
|
* Scan stream dictionary for an explicit /Crypt filter
|
|
*/
|
|
static int
|
|
pdf_stream_has_crypt(fz_obj *stm)
|
|
{
|
|
fz_obj *filters;
|
|
fz_obj *obj;
|
|
int i;
|
|
|
|
filters = fz_dict_getsa(stm, "Filter", "F");
|
|
if (filters)
|
|
{
|
|
if (!strcmp(fz_to_name(filters), "Crypt"))
|
|
return 1;
|
|
if (fz_is_array(filters))
|
|
{
|
|
for (i = 0; i < fz_array_len(filters); i++)
|
|
{
|
|
obj = fz_array_get(filters, i);
|
|
if (!strcmp(fz_to_name(obj), "Crypt"))
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Create a filter given a name and param dictionary.
|
|
*/
|
|
static fz_stream *
|
|
build_filter(fz_stream *chain, pdf_xref * xref, fz_obj * f, fz_obj * p, int num, int gen)
|
|
{
|
|
fz_error error;
|
|
char *s;
|
|
|
|
s = fz_to_name(f);
|
|
|
|
if (!strcmp(s, "ASCIIHexDecode") || !strcmp(s, "AHx"))
|
|
return fz_open_ahxd(chain);
|
|
|
|
else if (!strcmp(s, "ASCII85Decode") || !strcmp(s, "A85"))
|
|
return fz_open_a85d(chain);
|
|
|
|
else if (!strcmp(s, "CCITTFaxDecode") || !strcmp(s, "CCF"))
|
|
return fz_open_faxd(chain, p);
|
|
|
|
else if (!strcmp(s, "DCTDecode") || !strcmp(s, "DCT"))
|
|
return fz_open_dctd(chain, p);
|
|
|
|
else if (!strcmp(s, "RunLengthDecode") || !strcmp(s, "RL"))
|
|
return fz_open_rld(chain);
|
|
|
|
else if (!strcmp(s, "FlateDecode") || !strcmp(s, "Fl"))
|
|
{
|
|
fz_obj *obj = fz_dict_gets(p, "Predictor");
|
|
if (fz_to_int(obj) > 1)
|
|
return fz_open_predict(fz_open_flated(chain), p);
|
|
return fz_open_flated(chain);
|
|
}
|
|
|
|
else if (!strcmp(s, "LZWDecode") || !strcmp(s, "LZW"))
|
|
{
|
|
fz_obj *obj = fz_dict_gets(p, "Predictor");
|
|
if (fz_to_int(obj) > 1)
|
|
return fz_open_predict(fz_open_lzwd(chain, p), p);
|
|
return fz_open_lzwd(chain, p);
|
|
}
|
|
|
|
else if (!strcmp(s, "JBIG2Decode"))
|
|
{
|
|
fz_obj *obj = fz_dict_gets(p, "JBIG2Globals");
|
|
if (obj)
|
|
{
|
|
fz_buffer *globals;
|
|
error = pdf_load_stream(&globals, xref, fz_to_num(obj), fz_to_gen(obj));
|
|
if (error)
|
|
fz_catch(error, "cannot load jbig2 global segments");
|
|
chain = fz_open_jbig2d(chain, globals);
|
|
fz_drop_buffer(globals);
|
|
return chain;
|
|
}
|
|
return fz_open_jbig2d(chain, NULL);
|
|
}
|
|
|
|
else if (!strcmp(s, "JPXDecode"))
|
|
return chain; /* JPX decoding is special cased in the image loading code */
|
|
|
|
else if (!strcmp(s, "Crypt"))
|
|
{
|
|
fz_obj *name;
|
|
|
|
if (!xref->crypt)
|
|
{
|
|
fz_warn("crypt filter in unencrypted document");
|
|
return chain;
|
|
}
|
|
|
|
name = fz_dict_gets(p, "Name");
|
|
if (fz_is_name(name))
|
|
return pdf_open_crypt_with_filter(chain, xref->crypt, fz_to_name(name), num, gen);
|
|
|
|
return chain;
|
|
}
|
|
|
|
fz_warn("unknown filter name (%s)", s);
|
|
return chain;
|
|
}
|
|
|
|
/*
|
|
* 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_xref *xref, fz_obj *fs, fz_obj *ps, int num, int gen)
|
|
{
|
|
fz_obj *f;
|
|
fz_obj *p;
|
|
int i;
|
|
|
|
for (i = 0; i < fz_array_len(fs); i++)
|
|
{
|
|
f = fz_array_get(fs, i);
|
|
p = fz_array_get(ps, i);
|
|
chain = build_filter(chain, xref, f, p, num, gen);
|
|
}
|
|
|
|
return chain;
|
|
}
|
|
|
|
/*
|
|
* 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_stream *
|
|
pdf_open_raw_filter(fz_stream *chain, pdf_xref *xref, fz_obj *stmobj, int num, int gen)
|
|
{
|
|
int hascrypt;
|
|
int len;
|
|
|
|
/* don't close chain when we close this filter */
|
|
fz_keep_stream(chain);
|
|
|
|
len = fz_to_int(fz_dict_gets(stmobj, "Length"));
|
|
chain = fz_open_null(chain, len);
|
|
|
|
hascrypt = pdf_stream_has_crypt(stmobj);
|
|
if (xref->crypt && !hascrypt)
|
|
chain = pdf_open_crypt(chain, xref->crypt, num, gen);
|
|
|
|
return chain;
|
|
}
|
|
|
|
/*
|
|
* Construct a filter to decode a stream, constraining
|
|
* to stream length and decrypting.
|
|
*/
|
|
static fz_stream *
|
|
pdf_open_filter(fz_stream *chain, pdf_xref *xref, fz_obj *stmobj, int num, int gen)
|
|
{
|
|
fz_obj *filters;
|
|
fz_obj *params;
|
|
|
|
filters = fz_dict_getsa(stmobj, "Filter", "F");
|
|
params = fz_dict_getsa(stmobj, "DecodeParms", "DP");
|
|
|
|
chain = pdf_open_raw_filter(chain, xref, stmobj, num, gen);
|
|
|
|
if (fz_is_name(filters))
|
|
return build_filter(chain, xref, filters, params, num, gen);
|
|
if (fz_array_len(filters) > 0)
|
|
return build_filter_chain(chain, xref, filters, params, num, gen);
|
|
|
|
return chain;
|
|
}
|
|
|
|
/*
|
|
* Construct a filter to decode a stream, without
|
|
* constraining to stream length, and without decryption.
|
|
*/
|
|
fz_stream *
|
|
pdf_open_inline_stream(fz_stream *chain, pdf_xref *xref, fz_obj *stmobj, int length)
|
|
{
|
|
fz_obj *filters;
|
|
fz_obj *params;
|
|
|
|
filters = fz_dict_getsa(stmobj, "Filter", "F");
|
|
params = fz_dict_getsa(stmobj, "DecodeParms", "DP");
|
|
|
|
/* don't close chain when we close this filter */
|
|
fz_keep_stream(chain);
|
|
|
|
if (fz_is_name(filters))
|
|
return build_filter(chain, xref, filters, params, 0, 0);
|
|
if (fz_array_len(filters) > 0)
|
|
return build_filter_chain(chain, xref, filters, params, 0, 0);
|
|
|
|
return fz_open_null(chain, length);
|
|
}
|
|
|
|
/*
|
|
* Open a stream for reading the raw (compressed but decrypted) data.
|
|
* Using xref->file while this is open is a bad idea.
|
|
*/
|
|
fz_error
|
|
pdf_open_raw_stream(fz_stream **stmp, pdf_xref *xref, int num, int gen)
|
|
{
|
|
pdf_xref_entry *x;
|
|
fz_error error;
|
|
|
|
if (num < 0 || num >= xref->len)
|
|
return fz_throw("object id out of range (%d %d R)", num, gen);
|
|
|
|
x = xref->table + num;
|
|
|
|
error = pdf_cache_object(xref, num, gen);
|
|
if (error)
|
|
return fz_rethrow(error, "cannot load stream object (%d %d R)", num, gen);
|
|
|
|
if (x->stm_ofs)
|
|
{
|
|
*stmp = pdf_open_raw_filter(xref->file, xref, x->obj, num, gen);
|
|
fz_seek(xref->file, x->stm_ofs, 0);
|
|
return fz_okay;
|
|
}
|
|
|
|
return fz_throw("object is not a stream");
|
|
}
|
|
|
|
/*
|
|
* Open a stream for reading uncompressed data.
|
|
* Put the opened file in xref->stream.
|
|
* Using xref->file while a stream is open is a Bad idea.
|
|
*/
|
|
fz_error
|
|
pdf_open_stream(fz_stream **stmp, pdf_xref *xref, int num, int gen)
|
|
{
|
|
pdf_xref_entry *x;
|
|
fz_error error;
|
|
|
|
if (num < 0 || num >= xref->len)
|
|
return fz_throw("object id out of range (%d %d R)", num, gen);
|
|
|
|
x = xref->table + num;
|
|
|
|
error = pdf_cache_object(xref, num, gen);
|
|
if (error)
|
|
return fz_rethrow(error, "cannot load stream object (%d %d R)", num, gen);
|
|
|
|
if (x->stm_ofs)
|
|
{
|
|
*stmp = pdf_open_filter(xref->file, xref, x->obj, num, gen);
|
|
fz_seek(xref->file, x->stm_ofs, 0);
|
|
return fz_okay;
|
|
}
|
|
|
|
return fz_throw("object is not a stream");
|
|
}
|
|
|
|
fz_error
|
|
pdf_open_stream_at(fz_stream **stmp, pdf_xref *xref, int num, int gen, fz_obj *dict, int stm_ofs)
|
|
{
|
|
if (stm_ofs)
|
|
{
|
|
*stmp = pdf_open_filter(xref->file, xref, dict, num, gen);
|
|
fz_seek(xref->file, stm_ofs, 0);
|
|
return fz_okay;
|
|
}
|
|
return fz_throw("object is not a stream");
|
|
}
|
|
|
|
/*
|
|
* Load raw (compressed but decrypted) contents of a stream into buf.
|
|
*/
|
|
fz_error
|
|
pdf_load_raw_stream(fz_buffer **bufp, pdf_xref *xref, int num, int gen)
|
|
{
|
|
fz_error error;
|
|
fz_stream *stm;
|
|
fz_obj *dict;
|
|
int len;
|
|
|
|
error = pdf_load_object(&dict, xref, num, gen);
|
|
if (error)
|
|
return fz_rethrow(error, "cannot load stream dictionary (%d %d R)", num, gen);
|
|
|
|
len = fz_to_int(fz_dict_gets(dict, "Length"));
|
|
|
|
fz_drop_obj(dict);
|
|
|
|
error = pdf_open_raw_stream(&stm, xref, num, gen);
|
|
if (error)
|
|
return fz_rethrow(error, "cannot open raw stream (%d %d R)", num, gen);
|
|
|
|
error = fz_read_all(bufp, stm, len);
|
|
if (error)
|
|
{
|
|
fz_close(stm);
|
|
return fz_rethrow(error, "cannot read raw stream (%d %d R)", num, gen);
|
|
}
|
|
|
|
fz_close(stm);
|
|
return fz_okay;
|
|
}
|
|
|
|
static int
|
|
pdf_guess_filter_length(int len, char *filter)
|
|
{
|
|
if (!strcmp(filter, "ASCIIHexDecode"))
|
|
return len / 2;
|
|
if (!strcmp(filter, "ASCII85Decode"))
|
|
return len * 4 / 5;
|
|
if (!strcmp(filter, "FlateDecode"))
|
|
return len * 3;
|
|
if (!strcmp(filter, "RunLengthDecode"))
|
|
return len * 3;
|
|
if (!strcmp(filter, "LZWDecode"))
|
|
return len * 2;
|
|
return len;
|
|
}
|
|
|
|
/*
|
|
* Load uncompressed contents of a stream into buf.
|
|
*/
|
|
fz_error
|
|
pdf_load_stream(fz_buffer **bufp, pdf_xref *xref, int num, int gen)
|
|
{
|
|
fz_error error;
|
|
fz_stream *stm;
|
|
fz_obj *dict, *obj;
|
|
int i, len;
|
|
|
|
error = pdf_open_stream(&stm, xref, num, gen);
|
|
if (error)
|
|
return fz_rethrow(error, "cannot open stream (%d %d R)", num, gen);
|
|
|
|
error = pdf_load_object(&dict, xref, num, gen);
|
|
if (error)
|
|
return fz_rethrow(error, "cannot load stream dictionary (%d %d R)", num, gen);
|
|
|
|
len = fz_to_int(fz_dict_gets(dict, "Length"));
|
|
obj = fz_dict_gets(dict, "Filter");
|
|
len = pdf_guess_filter_length(len, fz_to_name(obj));
|
|
for (i = 0; i < fz_array_len(obj); i++)
|
|
len = pdf_guess_filter_length(len, fz_to_name(fz_array_get(obj, i)));
|
|
|
|
fz_drop_obj(dict);
|
|
|
|
error = fz_read_all(bufp, stm, len);
|
|
if (error)
|
|
{
|
|
fz_close(stm);
|
|
return fz_rethrow(error, "cannot read raw stream (%d %d R)", num, gen);
|
|
}
|
|
|
|
fz_close(stm);
|
|
return fz_okay;
|
|
}
|