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;
}
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;
}
fz_stream *
fz_open_leecher(fz_context *ctx, fz_stream *chain, fz_buffer *buffer)
{
fz_leech *state = fz_malloc_struct(ctx, fz_leech);
state->chain = fz_keep_stream(ctx, chain);
state->buffer = fz_keep_buffer(ctx, buffer);
return fz_new_stream(ctx, state, next_leech, close_leech);
}
/*
Open an output stream that appends
to a buffer.
buf: The buffer to append to.
*/
fz_output *
fz_new_output_with_buffer(fz_context *ctx, fz_buffer *buf)
{
fz_output *out = fz_new_output(ctx, 0, fz_keep_buffer(ctx, buf), buffer_write, NULL, buffer_drop);
out->seek = buffer_seek;
out->tell = buffer_tell;
return out;
}
fz_output *
fz_new_output_with_buffer(fz_context *ctx, fz_buffer *buf)
{
fz_output *out = fz_malloc_struct(ctx, fz_output);
out->opaque = fz_keep_buffer(ctx, buf);
out->write = buffer_write;
out->seek = buffer_seek;
out->tell = buffer_tell;
out->close = buffer_close;
return out;
}
fz_image *
fz_new_image_from_buffer(fz_context *ctx, fz_buffer *buffer)
{
fz_compressed_buffer *bc = NULL;
int w, h, xres, yres;
fz_colorspace *cspace;
int len = buffer->len;
unsigned char *buf = buffer->data;
fz_var(bc);
fz_try(ctx)
{
if (len < 8)
fz_throw(ctx, FZ_ERROR_GENERIC, "unknown image file format");
bc = fz_malloc_struct(ctx, fz_compressed_buffer);
bc->buffer = fz_keep_buffer(ctx, buffer);
if (buf[0] == 0xff && buf[1] == 0xd8)
{
bc->params.type = FZ_IMAGE_JPEG;
bc->params.u.jpeg.color_transform = -1;
fz_load_jpeg_info(ctx, buf, len, &w, &h, &xres, &yres, &cspace);
}
else if (memcmp(buf, "\211PNG\r\n\032\n", 8) == 0)
{
bc->params.type = FZ_IMAGE_PNG;
fz_load_png_info(ctx, buf, len, &w, &h, &xres, &yres, &cspace);
}
else if (memcmp(buf, "II", 2) == 0 && buf[2] == 0xBC)
{
bc->params.type = FZ_IMAGE_JXR;
fz_load_jxr_info(ctx, buf, len, &w, &h, &xres, &yres, &cspace);
}
else if (memcmp(buf, "MM", 2) == 0 || memcmp(buf, "II", 2) == 0)
{
bc->params.type = FZ_IMAGE_TIFF;
fz_load_tiff_info(ctx, buf, len, &w, &h, &xres, &yres, &cspace);
}
else
fz_throw(ctx, FZ_ERROR_GENERIC, "unknown image file format");
}
fz_catch(ctx)
{
fz_free_compressed_buffer(ctx, bc);
fz_rethrow(ctx);
}
return fz_new_image(ctx, w, h, 8, cspace, xres, yres, 0, 0, NULL, NULL, bc, NULL);
}
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;
}
/*
Open a buffer as a stream.
buf: The buffer to open. Ownership of the buffer is NOT passed in
(this function takes its own reference).
Returns pointer to newly created stream. May throw exceptions on
failure to allocate.
*/
fz_stream *
fz_open_buffer(fz_context *ctx, fz_buffer *buf)
{
fz_stream *stm;
fz_keep_buffer(ctx, buf);
stm = fz_new_stream(ctx, buf, next_buffer, drop_buffer);
stm->seek = seek_buffer;
stm->rp = buf->data;
stm->wp = buf->data + buf->len;
stm->pos = (int64_t)buf->len;
return stm;
}
fz_stream *
fz_open_buffer(fz_context *ctx, fz_buffer *buf)
{
fz_stream *stm;
fz_keep_buffer(ctx, buf);
stm = fz_new_stream(ctx, buf, next_buffer, close_buffer, NULL);
stm->seek = seek_buffer;
stm->reopen = reopen_buffer;
stm->rp = buf->data;
stm->wp = buf->data + buf->len;
stm->pos = buf->len;
return stm;
}
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;
}
pdf_obj *
pdf_add_image(fz_context *ctx, pdf_document *doc, fz_image *image)
{
fz_pixmap *pixmap = NULL;
pdf_obj *imobj = NULL;
pdf_obj *dp;
fz_buffer *buffer = NULL;
pdf_obj *imref = NULL;
fz_compressed_buffer *cbuffer;
unsigned char digest[16];
int i, n;
/* If we can maintain compression, do so */
cbuffer = fz_compressed_image_buffer(ctx, image);
fz_var(pixmap);
fz_var(buffer);
fz_var(imobj);
fz_var(imref);
/* Check if the same image already exists in this doc. */
imref = pdf_find_image_resource(ctx, doc, image, digest);
if (imref)
return imref;
imobj = pdf_add_new_dict(ctx, doc, 3);
fz_try(ctx)
{
dp = pdf_dict_put_dict(ctx, imobj, PDF_NAME(DecodeParms), 3);
pdf_dict_put(ctx, imobj, PDF_NAME(Type), PDF_NAME(XObject));
pdf_dict_put(ctx, imobj, PDF_NAME(Subtype), PDF_NAME(Image));
if (cbuffer)
{
fz_compression_params *cp = &cbuffer->params;
switch (cp ? cp->type : FZ_IMAGE_UNKNOWN)
{
default:
goto raw_or_unknown_compression;
case FZ_IMAGE_JPEG:
if (cp->u.jpeg.color_transform != -1)
pdf_dict_put_int(ctx, dp, PDF_NAME(ColorTransform), cp->u.jpeg.color_transform);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(DCTDecode));
break;
case FZ_IMAGE_JPX:
if (cp->u.jpx.smask_in_data)
pdf_dict_put_int(ctx, dp, PDF_NAME(SMaskInData), cp->u.jpx.smask_in_data);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(JPXDecode));
break;
case FZ_IMAGE_FAX:
if (cp->u.fax.columns)
pdf_dict_put_int(ctx, dp, PDF_NAME(Columns), cp->u.fax.columns);
if (cp->u.fax.rows)
pdf_dict_put_int(ctx, dp, PDF_NAME(Rows), cp->u.fax.rows);
if (cp->u.fax.k)
pdf_dict_put_int(ctx, dp, PDF_NAME(K), cp->u.fax.k);
if (cp->u.fax.end_of_line)
pdf_dict_put_bool(ctx, dp, PDF_NAME(EndOfLine), cp->u.fax.end_of_line);
if (cp->u.fax.encoded_byte_align)
pdf_dict_put_bool(ctx, dp, PDF_NAME(EncodedByteAlign), cp->u.fax.encoded_byte_align);
if (cp->u.fax.end_of_block)
pdf_dict_put_bool(ctx, dp, PDF_NAME(EndOfBlock), cp->u.fax.end_of_block);
if (cp->u.fax.black_is_1)
pdf_dict_put_bool(ctx, dp, PDF_NAME(BlackIs1), cp->u.fax.black_is_1);
if (cp->u.fax.damaged_rows_before_error)
pdf_dict_put_int(ctx, dp, PDF_NAME(DamagedRowsBeforeError), cp->u.fax.damaged_rows_before_error);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(CCITTFaxDecode));
break;
case FZ_IMAGE_FLATE:
if (cp->u.flate.columns)
pdf_dict_put_int(ctx, dp, PDF_NAME(Columns), cp->u.flate.columns);
if (cp->u.flate.colors)
pdf_dict_put_int(ctx, dp, PDF_NAME(Colors), cp->u.flate.colors);
if (cp->u.flate.predictor)
pdf_dict_put_int(ctx, dp, PDF_NAME(Predictor), cp->u.flate.predictor);
if (cp->u.flate.bpc)
pdf_dict_put_int(ctx, dp, PDF_NAME(BitsPerComponent), cp->u.flate.bpc);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(FlateDecode));
pdf_dict_put_int(ctx, imobj, PDF_NAME(BitsPerComponent), image->bpc);
break;
case FZ_IMAGE_LZW:
if (cp->u.lzw.columns)
pdf_dict_put_int(ctx, dp, PDF_NAME(Columns), cp->u.lzw.columns);
if (cp->u.lzw.colors)
pdf_dict_put_int(ctx, dp, PDF_NAME(Colors), cp->u.lzw.colors);
if (cp->u.lzw.predictor)
pdf_dict_put_int(ctx, dp, PDF_NAME(Predictor), cp->u.lzw.predictor);
if (cp->u.lzw.early_change)
pdf_dict_put_int(ctx, dp, PDF_NAME(EarlyChange), cp->u.lzw.early_change);
if (cp->u.lzw.bpc)
pdf_dict_put_int(ctx, dp, PDF_NAME(BitsPerComponent), cp->u.lzw.bpc);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(LZWDecode));
break;
case FZ_IMAGE_RLD:
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(RunLengthDecode));
break;
}
if (!pdf_dict_len(ctx, dp))
pdf_dict_del(ctx, imobj, PDF_NAME(DecodeParms));
buffer = fz_keep_buffer(ctx, cbuffer->buffer);
if (image->use_decode)
{
pdf_obj *ary = pdf_dict_put_array(ctx, imobj, PDF_NAME(Decode), image->n * 2);
for (i = 0; i < image->n * 2; ++i)
pdf_array_push_real(ctx, ary, image->decode[i]);
}
}
else
{
unsigned int size;
int h;
unsigned char *d, *s;
raw_or_unknown_compression:
/* Currently, set to maintain resolution; should we consider
* subsampling here according to desired output res? */
pixmap = fz_get_pixmap_from_image(ctx, image, NULL, NULL, NULL, NULL);
n = pixmap->n - pixmap->alpha - pixmap->s; /* number of colorants */
if (n == 0)
n = 1; /* treat pixmaps with only alpha or spots as grayscale */
size = image->w * n;
h = image->h;
s = pixmap->samples;
d = fz_malloc(ctx, size * h);
buffer = fz_new_buffer_from_data(ctx, d, size * h);
if (n == pixmap->n)
{
/* If we use all channels, we can copy the data as is. */
while (h--)
{
memcpy(d, s, size);
d += size;
s += pixmap->stride;
}
}
else
{
/* Need to remove the alpha and spot planes. */
/* TODO: extract alpha plane to a soft mask. */
/* TODO: convert spots to colors. */
int line_skip = pixmap->stride - pixmap->w * pixmap->n;
int skip = pixmap->n - n;
while (h--)
{
int w = pixmap->w;
while (w--)
{
int k;
for (k = 0; k < n; ++k)
*d++ = *s++;
s += skip;
}
s += line_skip;
}
}
}
pdf_dict_put_int(ctx, imobj, PDF_NAME(Width), pixmap ? pixmap->w : image->w);
pdf_dict_put_int(ctx, imobj, PDF_NAME(Height), pixmap ? pixmap->h : image->h);
if (image->imagemask)
{
pdf_dict_put_bool(ctx, imobj, PDF_NAME(ImageMask), 1);
}
else
{
fz_colorspace *cs;
pdf_dict_put_int(ctx, imobj, PDF_NAME(BitsPerComponent), image->bpc);
cs = pixmap ? pixmap->colorspace : image->colorspace;
switch (fz_colorspace_type(ctx, cs))
{
case FZ_COLORSPACE_INDEXED:
{
fz_colorspace *basecs;
unsigned char *lookup = NULL;
int high = 0;
int basen;
pdf_obj *arr;
lookup = fz_indexed_colorspace_palette(ctx, cs, &high);
basecs = fz_colorspace_base(ctx, cs);
basen = fz_colorspace_n(ctx, basecs);
arr = pdf_dict_put_array(ctx, imobj, PDF_NAME(ColorSpace), 4);
pdf_array_push(ctx, arr, PDF_NAME(Indexed));
switch (fz_colorspace_type(ctx, basecs))
{
case FZ_COLORSPACE_GRAY:
pdf_array_push(ctx, arr, PDF_NAME(DeviceGray));
break;
case FZ_COLORSPACE_RGB:
pdf_array_push(ctx, arr, PDF_NAME(DeviceRGB));
break;
case FZ_COLORSPACE_CMYK:
pdf_array_push(ctx, arr, PDF_NAME(DeviceCMYK));
break;
default:
// TODO: convert to RGB!
fz_throw(ctx, FZ_ERROR_GENERIC, "only indexed Gray, RGB, and CMYK colorspaces supported");
break;
}
pdf_array_push_int(ctx, arr, high);
pdf_array_push_string(ctx, arr, (char *) lookup, basen * (high + 1));
}
break;
case FZ_COLORSPACE_NONE:
case FZ_COLORSPACE_GRAY:
pdf_dict_put(ctx, imobj, PDF_NAME(ColorSpace), PDF_NAME(DeviceGray));
break;
case FZ_COLORSPACE_RGB:
pdf_dict_put(ctx, imobj, PDF_NAME(ColorSpace), PDF_NAME(DeviceRGB));
break;
case FZ_COLORSPACE_CMYK:
pdf_dict_put(ctx, imobj, PDF_NAME(ColorSpace), PDF_NAME(DeviceCMYK));
break;
default:
// TODO: convert to RGB!
fz_throw(ctx, FZ_ERROR_GENERIC, "only Gray, RGB, and CMYK colorspaces supported");
break;
}
}
if (image->mask)
{
pdf_dict_put_drop(ctx, imobj, PDF_NAME(SMask), pdf_add_image(ctx, doc, image->mask));
}
pdf_update_stream(ctx, doc, imobj, buffer, 1);
/* Add ref to our image resource hash table. */
imref = pdf_insert_image_resource(ctx, doc, digest, imobj);
}
fz_always(ctx)
{
fz_drop_pixmap(ctx, pixmap);
fz_drop_buffer(ctx, buffer);
pdf_drop_obj(ctx, imobj);
}
fz_catch(ctx)
fz_rethrow(ctx);
return imref;
}