kolibrios/contrib/media/updf/pdf/pdf_stream.c
right-hearted 4f7ee97ec9 uPDF with buttons
git-svn-id: svn://kolibrios.org@4680 a494cfbc-eb01-0410-851d-a64ba20cac60
2014-03-22 21:00:40 +00:00

386 lines
8.8 KiB
C

#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;
}