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_image *pack_jp2(fz_context *ctx, const char *data, size_t len, SizeI size)
{
fz_compressed_buffer *buf = nullptr;
fz_var(buf);
fz_try(ctx) {
buf = fz_malloc_struct(ctx, fz_compressed_buffer);
buf->buffer = fz_new_buffer(ctx, (int)len);
memcpy(buf->buffer->data, data, (buf->buffer->len = (int)len));
buf->params.type = FZ_IMAGE_JPX;
}
fz_catch(ctx) {
fz_free_compressed_buffer(ctx, buf);
fz_rethrow(ctx);
}
return fz_new_image(ctx, size.dx, size.dy, 8, fz_device_rgb(ctx), 96, 96, 0, 0, nullptr, nullptr, buf, nullptr);
}
static fz_image *pack_jpeg(fz_context *ctx, const char *data, size_t len, SizeI size)
{
fz_compressed_buffer *buf = NULL;
fz_var(buf);
fz_try(ctx) {
buf = fz_malloc_struct(ctx, fz_compressed_buffer);
buf->buffer = fz_new_buffer(ctx, (int)len);
memcpy(buf->buffer->data, data, (buf->buffer->len = (int)len));
buf->params.type = FZ_IMAGE_JPEG;
buf->params.u.jpeg.color_transform = -1;
}
fz_catch(ctx) {
fz_free_compressed_buffer(ctx, buf);
fz_rethrow(ctx);
}
return fz_new_image(ctx, size.dx, size.dy, 8, fz_device_rgb(ctx), 96, 96, 0, 0, NULL, NULL, buf, NULL);
}
static fz_image *render_to_pixmap(fz_context *ctx, HBITMAP hbmp, SizeI size)
{
int w = size.dx, h = size.dy;
int stride = ((w * 3 + 3) / 4) * 4;
unsigned char *data = (unsigned char *)fz_malloc(ctx, stride * h);
BITMAPINFO bmi = { 0 };
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biWidth = w;
bmi.bmiHeader.biHeight = -h;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 24;
bmi.bmiHeader.biCompression = BI_RGB;
HDC hDC = GetDC(nullptr);
int res = GetDIBits(hDC, hbmp, 0, h, data, &bmi, DIB_RGB_COLORS);
ReleaseDC(nullptr, hDC);
if (!res) {
fz_free(ctx, data);
fz_throw(ctx, FZ_ERROR_GENERIC, "GetDIBits failed");
}
// convert BGR with padding to RGB without padding
unsigned char *out = data;
bool is_grayscale = true;
for (int y = 0; y < h; y++) {
const unsigned char *in = data + y * stride;
unsigned char green, blue;
for (int x = 0; x < w; x++) {
is_grayscale = is_grayscale && in[0] == in[1] && in[0] == in[2];
blue = *in++;
green = *in++;
*out++ = *in++;
*out++ = green;
*out++ = blue;
}
}
// convert grayscale RGB to proper grayscale
if (is_grayscale) {
const unsigned char *in = out = data;
for (int i = 0; i < w * h; i++) {
*out++ = *in++;
in += 2;
}
}
fz_compressed_buffer *buf = nullptr;
fz_var(buf);
fz_try(ctx) {
buf = fz_malloc_struct(ctx, fz_compressed_buffer);
buf->buffer = fz_new_buffer(ctx, w * h * 4 + 10);
buf->params.type = FZ_IMAGE_FLATE;
buf->params.u.flate.predictor = 1;
z_stream zstm = { 0 };
zstm.next_in = data;
zstm.avail_in = out - data;
zstm.next_out = buf->buffer->data;
zstm.avail_out = buf->buffer->cap;
res = deflateInit(&zstm, 9);
if (res != Z_OK)
fz_throw(ctx, FZ_ERROR_GENERIC, "deflate failure %d", res);
res = deflate(&zstm, Z_FINISH);
if (res != Z_STREAM_END)
fz_throw(ctx, FZ_ERROR_GENERIC, "deflate failure %d", res);
buf->buffer->len = zstm.total_out;
res = deflateEnd(&zstm);
if (res != Z_OK)
fz_throw(ctx, FZ_ERROR_GENERIC, "deflate failure %d", res);
}
fz_always(ctx) {
fz_free(ctx, data);
}
fz_catch(ctx) {
fz_free_compressed_buffer(ctx, buf);
fz_rethrow(ctx);
}
fz_colorspace *cs = is_grayscale ? fz_device_gray(ctx) : fz_device_rgb(ctx);
return fz_new_image(ctx, w, h, 8, cs, 96, 96, 0, 0, nullptr, nullptr, buf, nullptr);
}
static fz_image *
pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cstm, int forcemask)
{
fz_stream *stm = NULL;
fz_image *image = NULL;
pdf_obj *obj, *res;
int w, h, bpc, n;
int imagemask;
int interpolate;
int indexed;
fz_image *mask = NULL; /* explicit mask/soft mask image */
int usecolorkey = 0;
fz_colorspace *colorspace = NULL;
float decode[FZ_MAX_COLORS * 2];
int colorkey[FZ_MAX_COLORS * 2];
int stride;
int i;
fz_context *ctx = doc->ctx;
fz_compressed_buffer *buffer;
fz_var(stm);
fz_var(mask);
fz_var(image);
fz_var(colorspace);
fz_try(ctx)
{
/* special case for JPEG2000 images */
if (pdf_is_jpx_image(ctx, dict))
{
// image = pdf_load_jpx(doc, dict, forcemask);
//
// if (forcemask)
// {
// fz_pixmap *mask_pixmap;
// if (image->n != 2)
// {
// fz_pixmap *gray;
// fz_irect bbox;
// fz_warn(ctx, "soft mask should be grayscale");
// gray = fz_new_pixmap_with_bbox(ctx, fz_device_gray(ctx), fz_pixmap_bbox(ctx, image->tile, &bbox));
// fz_convert_pixmap(ctx, gray, image->tile);
// fz_drop_pixmap(ctx, image->tile);
// image->tile = gray;
// }
// mask_pixmap = fz_alpha_from_gray(ctx, image->tile, 1);
// fz_drop_pixmap(ctx, image->tile);
// image->tile = mask_pixmap;
// }
break; /* Out of fz_try */
}
w = pdf_to_int(pdf_dict_getsa(dict, "Width", "W"));
h = pdf_to_int(pdf_dict_getsa(dict, "Height", "H"));
bpc = pdf_to_int(pdf_dict_getsa(dict, "BitsPerComponent", "BPC"));
if (bpc == 0)
bpc = 8;
imagemask = pdf_to_bool(pdf_dict_getsa(dict, "ImageMask", "IM"));
interpolate = pdf_to_bool(pdf_dict_getsa(dict, "Interpolate", "I"));
indexed = 0;
usecolorkey = 0;
if (imagemask)
bpc = 1;
if (w <= 0)
fz_throw(ctx, FZ_ERROR_GENERIC, "image width is zero (or less)");
if (h <= 0)
fz_throw(ctx, FZ_ERROR_GENERIC, "image height is zero (or less)");
if (bpc <= 0)
fz_throw(ctx, FZ_ERROR_GENERIC, "image depth is zero (or less)");
if (bpc > 16)
fz_throw(ctx, FZ_ERROR_GENERIC, "image depth is too large: %d", bpc);
if (w > (1 << 16))
fz_throw(ctx, FZ_ERROR_GENERIC, "image is too wide");
if (h > (1 << 16))
fz_throw(ctx, FZ_ERROR_GENERIC, "image is too high");
obj = pdf_dict_getsa(dict, "ColorSpace", "CS");
if (obj && !imagemask && !forcemask)
{
/* colorspace resource lookup is only done for inline images */
if (pdf_is_name(obj))
{
res = pdf_dict_get(pdf_dict_gets(rdb, "ColorSpace"), obj);
if (res)
obj = res;
}
colorspace = pdf_load_colorspace(doc, obj);
indexed = fz_colorspace_is_indexed(colorspace);
n = colorspace->n;
}
else
{
n = 1;
}
obj = pdf_dict_getsa(dict, "Decode", "D");
if (obj)
{
for (i = 0; i < n * 2; i++)
decode[i] = pdf_to_real(pdf_array_get(obj, i));
}
else
{
float maxval = indexed ? (1 << bpc) - 1 : 1;
for (i = 0; i < n * 2; i++)
decode[i] = i & 1 ? maxval : 0;
}
obj = pdf_dict_getsa(dict, "SMask", "Mask");
if (pdf_is_dict(obj))
{
/* Not allowed for inline images or soft masks */
if (cstm)
fz_warn(ctx, "Ignoring invalid inline image soft mask");
else if (forcemask)
fz_warn(ctx, "Ignoring recursive image soft mask");
else
{
mask = pdf_load_image_imp(doc, rdb, obj, NULL, 1);
obj = pdf_dict_gets(obj, "Matte");
if (pdf_is_array(obj))
{
usecolorkey = 1;
for (i = 0; i < n; i++)
colorkey[i] = pdf_to_real(pdf_array_get(obj, i)) * 255;
}
}
}
else if (pdf_is_array(obj))
{
usecolorkey = 1;
for (i = 0; i < n * 2; i++)
{
if (!pdf_is_int(pdf_array_get(obj, i)))
{
fz_warn(ctx, "invalid value in color key mask");
usecolorkey = 0;
}
colorkey[i] = pdf_to_int(pdf_array_get(obj, i));
}
}
/* Do we load from a ref, or do we load an inline stream? */
if (cstm == NULL)
{
/* Just load the compressed image data now and we can
* decode it on demand. */
int num = pdf_to_num(dict);
int gen = pdf_to_gen(dict);
buffer = pdf_load_compressed_stream(doc, num, gen);
image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, buffer, mask);
}
else
{
/* Inline stream */
stride = (w * n * bpc + 7) / 8;
image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, NULL, mask);
pdf_load_compressed_inline_image(doc, dict, stride * h, cstm, indexed, image);
}
}
fz_catch(ctx)
{
fz_drop_colorspace(ctx, colorspace);
fz_drop_image(ctx, mask);
fz_drop_image(ctx, image);
fz_rethrow(ctx);
}
return image;
}
static fz_image *
pdf_load_image_imp(pdf_document *xref, pdf_obj *rdb, pdf_obj *dict, fz_stream *cstm, int forcemask)
{
fz_stream *stm = NULL;
fz_image *image = NULL;
pdf_obj *obj, *res;
int w, h, bpc, n;
int imagemask;
int interpolate;
int indexed;
fz_image *mask = NULL; /* explicit mask/soft mask image */
int usecolorkey = 0;
fz_colorspace *colorspace = NULL;
float decode[FZ_MAX_COLORS * 2];
int colorkey[FZ_MAX_COLORS * 2];
int i;
fz_context *ctx = xref->ctx;
fz_var(stm);
fz_var(mask);
fz_var(image);
fz_var(colorspace);
fz_try(ctx)
{
/* special case for JPEG2000 images */
if (pdf_is_jpx_image(ctx, dict))
{
image = pdf_load_jpx(xref, dict, forcemask);
if (forcemask)
{
fz_pixmap *mask_pixmap;
if (image->n != 2)
{
/* SumatraPDF: ignore invalid JPX softmasks */
fz_warn(ctx, "soft mask must be grayscale");
mask_pixmap = fz_new_pixmap(ctx, NULL, image->tile->w, image->tile->h);
fz_clear_pixmap_with_value(ctx, mask_pixmap, 255);
}
else
mask_pixmap = fz_alpha_from_gray(ctx, image->tile, 1);
fz_drop_pixmap(ctx, image->tile);
image->tile = mask_pixmap;
}
break; /* Out of fz_try */
}
w = pdf_to_int(pdf_dict_getsa(dict, "Width", "W"));
h = pdf_to_int(pdf_dict_getsa(dict, "Height", "H"));
bpc = pdf_to_int(pdf_dict_getsa(dict, "BitsPerComponent", "BPC"));
if (bpc == 0)
bpc = 8;
imagemask = pdf_to_bool(pdf_dict_getsa(dict, "ImageMask", "IM"));
interpolate = pdf_to_bool(pdf_dict_getsa(dict, "Interpolate", "I"));
indexed = 0;
usecolorkey = 0;
mask = NULL;
if (imagemask)
bpc = 1;
if (w <= 0)
fz_throw(ctx, "image width is zero (or less)");
if (h <= 0)
fz_throw(ctx, "image height is zero (or less)");
if (bpc <= 0)
fz_throw(ctx, "image depth is zero (or less)");
if (bpc > 16)
fz_throw(ctx, "image depth is too large: %d", bpc);
if (w > (1 << 16))
fz_throw(ctx, "image is too wide");
if (h > (1 << 16))
fz_throw(ctx, "image is too high");
obj = pdf_dict_getsa(dict, "ColorSpace", "CS");
if (obj && !imagemask && !forcemask)
{
/* colorspace resource lookup is only done for inline images */
if (pdf_is_name(obj))
{
res = pdf_dict_get(pdf_dict_gets(rdb, "ColorSpace"), obj);
if (res)
obj = res;
}
colorspace = pdf_load_colorspace(xref, obj);
if (!strcmp(colorspace->name, "Indexed"))
indexed = 1;
n = colorspace->n;
}
else
{
n = 1;
}
obj = pdf_dict_getsa(dict, "Decode", "D");
if (obj)
{
for (i = 0; i < n * 2; i++)
decode[i] = pdf_to_real(pdf_array_get(obj, i));
}
else
{
float maxval = indexed ? (1 << bpc) - 1 : 1;
for (i = 0; i < n * 2; i++)
decode[i] = i & 1 ? maxval : 0;
}
obj = pdf_dict_getsa(dict, "SMask", "Mask");
if (pdf_is_dict(obj))
{
/* Not allowed for inline images or soft masks */
if (cstm)
fz_warn(ctx, "Ignoring invalid inline image soft mask");
else if (forcemask)
fz_warn(ctx, "Ignoring recursive image soft mask");
else
mask = pdf_load_image_imp(xref, rdb, obj, NULL, 1);
}
else if (pdf_is_array(obj))
{
usecolorkey = 1;
for (i = 0; i < n * 2; i++)
{
if (!pdf_is_int(pdf_array_get(obj, i)))
{
fz_warn(ctx, "invalid value in color key mask");
usecolorkey = 0;
}
colorkey[i] = pdf_to_int(pdf_array_get(obj, i));
}
}
/* Now, do we load a ref, or do we load the actual thing? */
if (!cstm)
{
/* Just load the compressed image data now and we can
* decode it on demand. */
int num = pdf_to_num(dict);
int gen = pdf_to_gen(dict);
fz_compressed_buffer *buffer = pdf_load_compressed_stream(xref, num, gen);
image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, buffer, mask);
break; /* Out of fz_try */
}
/* We need to decompress the image now */
if (cstm)
{
int stride = (w * n * bpc + 7) / 8;
stm = pdf_open_inline_stream(xref, dict, stride * h, cstm, NULL);
}
else
{
stm = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
}
image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, NULL, mask);
image->tile = fz_decomp_image_from_stream(ctx, stm, image, cstm != NULL, indexed, 0, 0);
}
fz_catch(ctx)
{
/* SumatraPDF: fix memory leak */
if (!image)
fz_drop_colorspace(ctx, colorspace);
else
fz_drop_image(ctx, image);
fz_rethrow(ctx);
}
/* cf. http://bugs.ghostscript.com/show_bug.cgi?id=693517 */
fz_try(ctx)
{
obj = pdf_dict_getp(dict, "SMask/Matte");
if (pdf_is_array(obj) && image->mask)
{
assert(!image->usecolorkey);
image->usecolorkey = 2;
for (i = 0; i < n; i++)
image->colorkey[i] = pdf_to_int(pdf_array_get(obj, i));
}
}
fz_catch(ctx)
{
fz_drop_image(ctx, image);
fz_rethrow(ctx);
}
return image;
}
