static tiff_document *
tiff_open_document_with_stream(fz_context *ctx, fz_stream *file)
{
tiff_document *doc;
doc = fz_new_document(ctx, tiff_document);
doc->super.drop_document = (fz_document_drop_fn *)tiff_drop_document;
doc->super.count_pages = (fz_document_count_pages_fn *)tiff_count_pages;
doc->super.load_page = (fz_document_load_page_fn *)tiff_load_page;
doc->super.lookup_metadata = (fz_document_lookup_metadata_fn *)tiff_lookup_metadata;
fz_try(ctx)
{
size_t len;
unsigned char *data;
doc->buffer = fz_read_all(ctx, file, 1024);
len = fz_buffer_storage(ctx, doc->buffer, &data);
doc->page_count = fz_load_tiff_subimage_count(ctx, data, len);
}
fz_catch(ctx)
{
fz_drop_document(ctx, &doc->super);
fz_rethrow(ctx);
}
return doc;
}
static tiff_document *
tiff_open_document_with_stream(fz_context *ctx, fz_stream *file)
{
tiff_document *doc;
doc = fz_new_document(ctx, sizeof *doc);
doc->super.close = (fz_document_close_fn *)tiff_close_document;
doc->super.count_pages = (fz_document_count_pages_fn *)tiff_count_pages;
doc->super.load_page = (fz_document_load_page_fn *)tiff_load_page;
doc->super.meta = (fz_document_meta_fn *)tiff_meta;
fz_try(ctx)
{
doc->buffer = fz_read_all(ctx, file, 1024);
doc->page_count = fz_load_tiff_subimage_count(ctx, doc->buffer->data, doc->buffer->len);
}
fz_catch(ctx)
{
tiff_close_document(ctx, doc);
fz_rethrow(ctx);
}
return doc;
}
fz_buffer *
pdf_load_raw_renumbered_stream(fz_context *ctx, pdf_document *doc, int num, int gen, int orig_num, int orig_gen)
{
fz_stream *stm;
pdf_obj *dict;
int len;
fz_buffer *buf;
if (num > 0 && num < pdf_xref_len(ctx, doc))
{
pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, num);
if (entry->stm_buf)
return fz_keep_buffer(ctx, entry->stm_buf);
}
dict = pdf_load_object(ctx, doc, num, gen);
len = pdf_to_int(ctx, pdf_dict_get(ctx, dict, PDF_NAME_Length));
pdf_drop_obj(ctx, dict);
stm = pdf_open_raw_renumbered_stream(ctx, doc, num, gen, orig_num, orig_gen);
buf = fz_read_all(ctx, stm, len);
fz_drop_stream(ctx, stm);
return buf;
}
/*
* 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;
}
/*
* 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 img_document *
img_open_document_with_stream(fz_context *ctx, fz_stream *stm)
{
fz_buffer *buffer = NULL;
fz_image *image = NULL;
img_document *doc;
fz_var(buffer);
fz_var(image);
fz_try(ctx)
{
buffer = fz_read_all(ctx, stm, 1024);
image = fz_new_image_from_buffer(ctx, buffer);
doc = img_new_document(ctx, image);
}
fz_always(ctx)
{
fz_drop_image(ctx, image);
fz_drop_buffer(ctx, buffer);
}
fz_catch(ctx)
fz_rethrow(ctx);
return doc;
}
fz_buffer *
pdf_load_raw_renumbered_stream(pdf_document *xref, int num, int gen, int orig_num, int orig_gen)
{
fz_stream *stm;
pdf_obj *dict;
int len;
fz_buffer *buf;
if (num > 0 && num < xref->len && xref->table[num].stm_buf)
return fz_keep_buffer(xref->ctx, xref->table[num].stm_buf);
dict = pdf_load_object(xref, num, gen);
/* RJW: "cannot load stream dictionary (%d %d R)", num, gen */
len = pdf_to_int(pdf_dict_gets(dict, "Length"));
pdf_drop_obj(dict);
stm = pdf_open_raw_renumbered_stream(xref, num, gen, orig_num, orig_gen);
/* RJW: "cannot open raw stream (%d %d R)", num, gen */
buf = fz_read_all(stm, len);
/* RJW: "cannot read raw stream (%d %d R)", num, gen */
fz_close(stm);
return buf;
}
static fz_buffer *
pdf_load_image_stream(fz_context *ctx, pdf_document *doc, int num, int gen, int orig_num, int orig_gen, fz_compression_params *params, int *truncated)
{
fz_stream *stm = NULL;
pdf_obj *dict, *obj;
int i, len, n;
fz_buffer *buf;
fz_var(buf);
if (num > 0 && num < pdf_xref_len(ctx, doc))
{
pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, num);
/* Return ref to existing buffer, but only if uncompressed,
* or shortstoppable */
if (can_reuse_buffer(ctx, entry, params))
return fz_keep_buffer(ctx, entry->stm_buf);
}
dict = pdf_load_object(ctx, doc, num, gen);
len = pdf_to_int(ctx, pdf_dict_get(ctx, dict, PDF_NAME_Length));
obj = pdf_dict_get(ctx, dict, PDF_NAME_Filter);
len = pdf_guess_filter_length(len, pdf_to_name(ctx, obj));
n = pdf_array_len(ctx, obj);
for (i = 0; i < n; i++)
len = pdf_guess_filter_length(len, pdf_to_name(ctx, pdf_array_get(ctx, obj, i)));
pdf_drop_obj(ctx, dict);
stm = pdf_open_image_stream(ctx, doc, num, gen, orig_num, orig_gen, params);
fz_try(ctx)
{
if (truncated)
buf = fz_read_best(ctx, stm, len, truncated);
else
buf = fz_read_all(ctx, stm, len);
}
fz_always(ctx)
{
fz_drop_stream(ctx, stm);
}
fz_catch(ctx)
{
fz_rethrow_message(ctx, "cannot read raw stream (%d %d R)", num, gen);
}
return buf;
}
static fz_document *
svg_open_document_with_stream(fz_context *ctx, fz_stream *file)
{
fz_buffer *buf;
fz_document *doc;
buf = fz_read_all(ctx, file, 0);
fz_try(ctx)
doc = svg_open_document_with_buffer(ctx, buf);
fz_always(ctx)
fz_drop_buffer(ctx, buf);
fz_catch(ctx)
fz_rethrow(ctx);
return doc;
}
fz_buffer *
pdf_load_image_stream(pdf_document *xref, int num, int gen, int orig_num, int orig_gen, pdf_image_params *params)
{
fz_context *ctx = xref->ctx;
fz_stream *stm = NULL;
pdf_obj *dict, *obj;
int i, len, n;
fz_buffer *buf;
fz_var(buf);
if (num > 0 && num < xref->len && xref->table[num].stm_buf)
return fz_keep_buffer(xref->ctx, xref->table[num].stm_buf);
dict = pdf_load_object(xref, num, gen);
/* RJW: "cannot load stream dictionary (%d %d R)", num, gen */
len = pdf_to_int(pdf_dict_gets(dict, "Length"));
obj = pdf_dict_gets(dict, "Filter");
len = pdf_guess_filter_length(len, pdf_to_name(obj));
n = pdf_array_len(obj);
for (i = 0; i < n; i++)
len = pdf_guess_filter_length(len, pdf_to_name(pdf_array_get(obj, i)));
pdf_drop_obj(dict);
stm = pdf_open_image_stream(xref, num, gen, orig_num, orig_gen, params);
/* RJW: "cannot open stream (%d %d R)", num, gen */
fz_try(ctx)
{
buf = fz_read_all(stm, len);
}
fz_always(ctx)
{
fz_close(stm);
}
fz_catch(ctx)
{
fz_throw(ctx, "cannot read raw stream (%d %d R)", num, gen);
}
return buf;
}
static fz_document *
htdoc_open_document_with_stream(fz_context *ctx, fz_stream *file)
{
html_document *doc;
fz_buffer *buf;
doc = fz_malloc_struct(ctx, html_document);
doc->super.close = htdoc_close_document;
doc->super.layout = htdoc_layout;
doc->super.count_pages = htdoc_count_pages;
doc->super.load_page = htdoc_load_page;
doc->zip = fz_open_directory(ctx, ".");
doc->set = fz_new_html_font_set(ctx);
buf = fz_read_all(ctx, file, 0);
fz_write_buffer_byte(ctx, buf, 0);
doc->box = fz_parse_html(ctx, doc->set, doc->zip, ".", buf, fz_user_css(ctx));
fz_drop_buffer(ctx, buf);
return (fz_document*)doc;
}
/*
* Load raw (compressed but decrypted) contents of a stream into buf.
*/
fz_buffer *
pdf_load_raw_stream(pdf_document *xref, int num, int gen)
{
fz_stream *stm;
pdf_obj *dict;
int len;
fz_buffer *buf;
dict = pdf_load_object(xref, num, gen);
/* RJW: "cannot load stream dictionary (%d %d R)", num, gen */
len = pdf_to_int(pdf_dict_gets(dict, "Length"));
pdf_drop_obj(dict);
stm = pdf_open_raw_stream(xref, num, gen);
/* RJW: "cannot open raw stream (%d %d R)", num, gen */
buf = fz_read_all(stm, len);
/* RJW: "cannot read raw stream (%d %d R)", num, gen */
fz_close(stm);
return buf;
}
fz_buffer *
fz_read_file(fz_context *ctx, const char *filename)
{
fz_stream *stm;
fz_buffer *buf = NULL;
fz_var(buf);
stm = fz_open_file(ctx, filename);
fz_try(ctx)
{
buf = fz_read_all(stm, 0);
}
fz_always(ctx)
{
fz_close(stm);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
return buf;
}
static unsigned char *
gif_read_tbid(fz_context *ctx, struct info *info, unsigned char *dest, unsigned char *p, unsigned char *end)
{
fz_stream *stm, *lzwstm = NULL;
unsigned int mincodesize, y;
fz_buffer *compressed = NULL, *uncompressed = NULL;
const unsigned char *ct;
unsigned char *sp;
if (end - p < 1)
fz_throw(ctx, FZ_ERROR_GENERIC, "premature end in table based image data in gif image");
mincodesize = *p;
fz_var(compressed);
fz_var(lzwstm);
fz_var(uncompressed);
fz_try(ctx)
{
compressed = fz_new_buffer(ctx, 0);
p = gif_read_subblocks(ctx, info, p + 1, end, compressed);
stm = fz_open_buffer(ctx, compressed);
lzwstm = fz_open_lzwd(ctx, stm, 0, mincodesize + 1, 1, 0);
uncompressed = fz_read_all(ctx, lzwstm, info->width * info->height);
sp = uncompressed->data;
if (info->has_lct)
ct = info->lct;
else if (info->has_gct)
ct = info->gct;
else
ct = dct;
if (info->image_interlaced)
{
for (y = 0; y < info->image_height; y += 8, sp += info->image_width)
gif_read_line(ctx, info, dest, ct, y, sp);
for (y = 4; y < info->image_height; y += 8, sp += info->image_width)
gif_read_line(ctx, info, dest, ct, y, sp);
for (y = 2; y < info->image_height; y += 4, sp += info->image_width)
gif_read_line(ctx, info, dest, ct, y, sp);
for (y = 1; y < info->image_height; y += 2, sp += info->image_width)
gif_read_line(ctx, info, dest, ct, y, sp);
}
else
for (y = 0; y < info->image_height; y++, sp += info->image_width)
gif_read_line(ctx, info, dest, ct, y, sp);
}
fz_always(ctx)
{
fz_drop_buffer(ctx, uncompressed);
fz_drop_buffer(ctx, compressed);
fz_drop_stream(ctx, lzwstm);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
return p;
}
static const unsigned char *
gif_read_tbid(fz_context *ctx, struct info *info, unsigned char *dest, const unsigned char *p, const unsigned char *end)
{
fz_stream *stm, *lzwstm = NULL;
unsigned int mincodesize, y;
fz_buffer *compressed = NULL, *uncompressed = NULL;
const unsigned char *ct;
unsigned char *sp;
int ct_entries;
if (end - p < 1)
fz_throw(ctx, FZ_ERROR_GENERIC, "premature end in table based image data in gif image");
mincodesize = *p;
/* if there is no overlap, avoid pasting image data, just consume it */
if (info->image_top >= info->height || info->image_left >= info->width)
{
p = gif_read_subblocks(ctx, info, p + 1, end, NULL);
return p;
}
fz_var(compressed);
fz_var(lzwstm);
fz_var(uncompressed);
fz_try(ctx)
{
compressed = fz_new_buffer(ctx, 0);
p = gif_read_subblocks(ctx, info, p + 1, end, compressed);
stm = fz_open_buffer(ctx, compressed);
lzwstm = fz_open_lzwd(ctx, stm, 0, mincodesize + 1, 1, 1);
uncompressed = fz_read_all(ctx, lzwstm, 0);
if (uncompressed->len < info->image_width * info->image_height)
fz_throw(ctx, FZ_ERROR_GENERIC, "premature end in compressed table based image data in gif image");
if (info->has_lct)
{
ct = info->lct;
ct_entries = info->lct_entries;
}
else if (info->has_gct)
{
ct = info->gct;
ct_entries = info->gct_entries;
}
else
{
ct = dct;
ct_entries = 256;
}
sp = uncompressed->data;
if (info->image_interlaced)
{
for (y = 0; y < info->image_height; y += 8, sp += info->image_width)
gif_read_line(ctx, info, dest, ct_entries, ct, y, sp);
for (y = 4; y < info->image_height; y += 8, sp += info->image_width)
gif_read_line(ctx, info, dest, ct_entries, ct, y, sp);
for (y = 2; y < info->image_height; y += 4, sp += info->image_width)
gif_read_line(ctx, info, dest, ct_entries, ct, y, sp);
for (y = 1; y < info->image_height; y += 2, sp += info->image_width)
gif_read_line(ctx, info, dest, ct_entries, ct, y, sp);
}
else
for (y = 0; y < info->image_height; y++, sp += info->image_width)
gif_read_line(ctx, info, dest, ct_entries, ct, y, sp);
}
fz_always(ctx)
{
fz_drop_buffer(ctx, uncompressed);
fz_drop_buffer(ctx, compressed);
fz_drop_stream(ctx, lzwstm);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
return p;
}
