static void
pdf_load_function_based_shading(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, pdf_function *func)
{
pdf_obj *obj;
float x0, y0, x1, y1;
float fv[2];
fz_matrix matrix;
int xx, yy;
float *p;
int n = fz_colorspace_n(ctx, shade->colorspace);
x0 = y0 = 0;
x1 = y1 = 1;
obj = pdf_dict_get(ctx, dict, PDF_NAME(Domain));
if (obj)
{
x0 = pdf_array_get_real(ctx, obj, 0);
x1 = pdf_array_get_real(ctx, obj, 1);
y0 = pdf_array_get_real(ctx, obj, 2);
y1 = pdf_array_get_real(ctx, obj, 3);
}
obj = pdf_dict_get(ctx, dict, PDF_NAME(Matrix));
if (obj)
pdf_to_matrix(ctx, obj, &matrix);
else
matrix = fz_identity;
shade->u.f.matrix = matrix;
shade->u.f.xdivs = FUNSEGS;
shade->u.f.ydivs = FUNSEGS;
shade->u.f.fn_vals = fz_malloc(ctx, (FUNSEGS+1)*(FUNSEGS+1)*n*sizeof(float));
shade->u.f.domain[0][0] = x0;
shade->u.f.domain[0][1] = y0;
shade->u.f.domain[1][0] = x1;
shade->u.f.domain[1][1] = y1;
p = shade->u.f.fn_vals;
for (yy = 0; yy <= FUNSEGS; yy++)
{
fv[1] = y0 + (y1 - y0) * yy / FUNSEGS;
for (xx = 0; xx <= FUNSEGS; xx++)
{
fv[0] = x0 + (x1 - x0) * xx / FUNSEGS;
pdf_eval_function(ctx, func, fv, 2, p, n);
p += n;
}
}
}
void
pdf_annot_line(fz_context *ctx, pdf_annot *annot, fz_point *a, fz_point *b)
{
fz_matrix page_ctm;
pdf_obj *line;
check_allowed_subtypes(ctx, annot, PDF_NAME(L), line_subtypes);
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
line = pdf_dict_get(ctx, annot->obj, PDF_NAME(L));
a->x = pdf_array_get_real(ctx, line, 0);
a->y = pdf_array_get_real(ctx, line, 1);
b->x = pdf_array_get_real(ctx, line, 2);
b->y = pdf_array_get_real(ctx, line, 3);
fz_transform_point(a, &page_ctm);
fz_transform_point(b, &page_ctm);
}
fz_point
pdf_annot_vertex(fz_context *ctx, pdf_annot *annot, int i)
{
pdf_obj *vertices;
fz_matrix page_ctm;
fz_point point;
check_allowed_subtypes(ctx, annot, PDF_NAME(Vertices), vertices_subtypes);
vertices = pdf_dict_get(ctx, annot->obj, PDF_NAME(Vertices));
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
point.x = pdf_array_get_real(ctx, vertices, i * 2);
point.y = pdf_array_get_real(ctx, vertices, i * 2 + 1);
fz_transform_point(&point, &page_ctm);
return point;
}
fz_point
pdf_annot_ink_list_stroke_vertex(fz_context *ctx, pdf_annot *annot, int i, int k)
{
pdf_obj *ink_list;
pdf_obj *stroke;
fz_matrix page_ctm;
fz_point point;
check_allowed_subtypes(ctx, annot, PDF_NAME(InkList), ink_list_subtypes);
ink_list = pdf_dict_get(ctx, annot->obj, PDF_NAME(InkList));
stroke = pdf_array_get(ctx, ink_list, i);
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
point.x = pdf_array_get_real(ctx, stroke, k * 2 + 0);
point.y = pdf_array_get_real(ctx, stroke, k * 2 + 1);
fz_transform_point(&point, &page_ctm);
return point;
}
void
pdf_annot_quad_point(fz_context *ctx, pdf_annot *annot, int idx, float v[8])
{
pdf_obj *quad_points;
fz_matrix page_ctm;
int i;
check_allowed_subtypes(ctx, annot, PDF_NAME(QuadPoints), quad_point_subtypes);
quad_points = pdf_dict_get(ctx, annot->obj, PDF_NAME(QuadPoints));
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
for (i = 0; i < 8; i += 2)
{
fz_point point;
point.x = pdf_array_get_real(ctx, quad_points, idx * 8 + i + 0);
point.y = pdf_array_get_real(ctx, quad_points, idx * 8 + i + 1);
fz_transform_point(&point, &page_ctm);
v[i+0] = point.x;
v[i+1] = point.y;
}
}
static void
pdf_load_linear_shading(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, int funcs, pdf_function **func)
{
pdf_obj *obj;
float d0, d1;
int e0, e1;
obj = pdf_dict_get(ctx, dict, PDF_NAME(Coords));
shade->u.l_or_r.coords[0][0] = pdf_array_get_real(ctx, obj, 0);
shade->u.l_or_r.coords[0][1] = pdf_array_get_real(ctx, obj, 1);
shade->u.l_or_r.coords[1][0] = pdf_array_get_real(ctx, obj, 2);
shade->u.l_or_r.coords[1][1] = pdf_array_get_real(ctx, obj, 3);
d0 = 0;
d1 = 1;
obj = pdf_dict_get(ctx, dict, PDF_NAME(Domain));
if (obj)
{
d0 = pdf_array_get_real(ctx, obj, 0);
d1 = pdf_array_get_real(ctx, obj, 1);
}
e0 = e1 = 0;
obj = pdf_dict_get(ctx, dict, PDF_NAME(Extend));
if (obj)
{
e0 = pdf_array_get_bool(ctx, obj, 0);
e1 = pdf_array_get_bool(ctx, obj, 1);
}
pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1);
shade->u.l_or_r.extend[0] = e0;
shade->u.l_or_r.extend[1] = e1;
}
static void pdf_annot_color_imp(fz_context *ctx, pdf_annot *annot, pdf_obj *key, int *n, float color[4], pdf_obj **allowed)
{
pdf_obj *arr;
int len;
if (allowed)
check_allowed_subtypes(ctx, annot, key, allowed);
arr = pdf_dict_get(ctx, annot->obj, key);
len = pdf_array_len(ctx, arr);
switch (len)
{
case 0:
if (n)
*n = 0;
break;
case 1:
case 2:
if (n)
*n = 1;
if (color)
color[0] = pdf_array_get_real(ctx, arr, 0);
break;
case 3:
if (n)
*n = 3;
if (color)
{
color[0] = pdf_array_get_real(ctx, arr, 0);
color[1] = pdf_array_get_real(ctx, arr, 1);
color[2] = pdf_array_get_real(ctx, arr, 2);
}
break;
case 4:
default:
if (n)
*n = 4;
if (color)
{
color[0] = pdf_array_get_real(ctx, arr, 0);
color[1] = pdf_array_get_real(ctx, arr, 1);
color[2] = pdf_array_get_real(ctx, arr, 2);
color[3] = pdf_array_get_real(ctx, arr, 3);
}
break;
}
}
static float
extract_quad(fz_context *ctx, fz_point *quad, pdf_obj *obj, int i)
{
float dx, dy;
quad[0].x = pdf_array_get_real(ctx, obj, i+0);
quad[0].y = pdf_array_get_real(ctx, obj, i+1);
quad[1].x = pdf_array_get_real(ctx, obj, i+2);
quad[1].y = pdf_array_get_real(ctx, obj, i+3);
quad[2].x = pdf_array_get_real(ctx, obj, i+4);
quad[2].y = pdf_array_get_real(ctx, obj, i+5);
quad[3].x = pdf_array_get_real(ctx, obj, i+6);
quad[3].y = pdf_array_get_real(ctx, obj, i+7);
dx = quad[UL].x - quad[LL].x;
dy = quad[UL].y - quad[LL].y;
return sqrtf(dx * dx + dy * dy);
}
static void
pdf_write_polygon_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf, fz_rect *rect, int close)
{
pdf_obj *verts;
fz_point p;
int i, n;
float lw;
lw = pdf_write_border_appearance(ctx, annot, buf);
pdf_write_stroke_color_appearance(ctx, annot, buf);
*rect = fz_empty_rect;
verts = pdf_dict_get(ctx, annot->obj, PDF_NAME(Vertices));
n = pdf_array_len(ctx, verts) / 2;
if (n > 0)
{
for (i = 0; i < n; ++i)
{
p.x = pdf_array_get_real(ctx, verts, i*2+0);
p.y = pdf_array_get_real(ctx, verts, i*2+1);
if (i == 0)
{
rect->x0 = rect->x1 = p.x;
rect->y0 = rect->y1 = p.y;
}
else
*rect = fz_include_point_in_rect(*rect, p);
if (i == 0)
fz_append_printf(ctx, buf, "%g %g m\n", p.x, p.y);
else
fz_append_printf(ctx, buf, "%g %g l\n", p.x, p.y);
}
fz_append_string(ctx, buf, close ? "s" : "S");
*rect = fz_expand_rect(*rect, lw);
}
}
static void
pdf_write_ink_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf, fz_rect *rect)
{
pdf_obj *ink_list, *stroke;
int i, n, k, m;
float lw;
fz_point p;
lw = pdf_write_border_appearance(ctx, annot, buf);
pdf_write_stroke_color_appearance(ctx, annot, buf);
*rect = fz_empty_rect;
ink_list = pdf_dict_get(ctx, annot->obj, PDF_NAME(InkList));
n = pdf_array_len(ctx, ink_list);
for (i = 0; i < n; ++i)
{
stroke = pdf_array_get(ctx, ink_list, i);
m = pdf_array_len(ctx, stroke) / 2;
for (k = 0; k < m; ++k)
{
p.x = pdf_array_get_real(ctx, stroke, k*2+0);
p.y = pdf_array_get_real(ctx, stroke, k*2+1);
if (i == 0 && k == 0)
{
rect->x0 = rect->x1 = p.x;
rect->y0 = rect->y1 = p.y;
}
else
*rect = fz_include_point_in_rect(*rect, p);
fz_append_printf(ctx, buf, "%g %g %c\n", p.x, p.y, k == 0 ? 'm' : 'l');
}
}
fz_append_printf(ctx, buf, "S");
*rect = fz_expand_rect(*rect, lw);
}
static void
pdf_write_line_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf, fz_rect *rect)
{
pdf_obj *line, *le;
fz_point a, b;
float w;
int ic;
w = pdf_write_border_appearance(ctx, annot, buf);
pdf_write_stroke_color_appearance(ctx, annot, buf);
ic = pdf_write_interior_fill_color_appearance(ctx, annot, buf);
line = pdf_dict_get(ctx, annot->obj, PDF_NAME(L));
a.x = pdf_array_get_real(ctx, line, 0);
a.y = pdf_array_get_real(ctx, line, 1);
b.x = pdf_array_get_real(ctx, line, 2);
b.y = pdf_array_get_real(ctx, line, 3);
fz_append_printf(ctx, buf, "%g %g m\n%g %g l\nS\n", a.x, a.y, b.x, b.y);
rect->x0 = fz_min(a.x, b.x);
rect->y0 = fz_min(a.y, b.y);
rect->x1 = fz_max(a.x, b.x);
rect->y1 = fz_max(a.y, b.y);
le = pdf_dict_get(ctx, annot->obj, PDF_NAME(LE));
if (pdf_array_len(ctx, le) == 2)
{
float dx = b.x - a.x;
float dy = b.y - a.y;
float l = sqrtf(dx*dx + dy*dy);
pdf_write_line_cap_appearance(ctx, buf, rect, a.x, a.y, dx/l, dy/l, w, ic, pdf_array_get(ctx, le, 0));
pdf_write_line_cap_appearance(ctx, buf, rect, b.x, b.y, -dx/l, -dy/l, w, ic, pdf_array_get(ctx, le, 1));
}
*rect = fz_expand_rect(*rect, fz_max(1, w));
}
static fz_shade *
pdf_load_shading_dict(fz_context *ctx, pdf_document *doc, pdf_obj *dict, const fz_matrix *transform)
{
fz_shade *shade = NULL;
pdf_function *func[FZ_MAX_COLORS] = { NULL };
pdf_obj *obj;
int funcs = 0;
int type = 0;
int i, in, out, n;
fz_var(shade);
fz_var(func);
fz_var(funcs);
fz_var(type);
fz_try(ctx)
{
shade = fz_malloc_struct(ctx, fz_shade);
FZ_INIT_STORABLE(shade, 1, fz_drop_shade_imp);
shade->type = FZ_MESH_TYPE4;
shade->use_background = 0;
shade->use_function = 0;
shade->matrix = *transform;
shade->bbox = fz_infinite_rect;
shade->colorspace = NULL;
funcs = 0;
obj = pdf_dict_get(ctx, dict, PDF_NAME(ShadingType));
type = pdf_to_int(ctx, obj);
obj = pdf_dict_get(ctx, dict, PDF_NAME(ColorSpace));
if (!obj)
fz_throw(ctx, FZ_ERROR_SYNTAX, "shading colorspace is missing");
shade->colorspace = pdf_load_colorspace(ctx, obj);
n = fz_colorspace_n(ctx, shade->colorspace);
obj = pdf_dict_get(ctx, dict, PDF_NAME(Background));
if (obj)
{
shade->use_background = 1;
for (i = 0; i < n; i++)
shade->background[i] = pdf_array_get_real(ctx, obj, i);
}
obj = pdf_dict_get(ctx, dict, PDF_NAME(BBox));
if (pdf_is_array(ctx, obj))
pdf_to_rect(ctx, obj, &shade->bbox);
obj = pdf_dict_get(ctx, dict, PDF_NAME(Function));
if (pdf_is_dict(ctx, obj))
{
funcs = 1;
if (type == 1)
in = 2;
else
in = 1;
out = n;
func[0] = pdf_load_function(ctx, obj, in, out);
if (!func[0])
fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot load shading function (%d 0 R)", pdf_to_num(ctx, obj));
}
else if (pdf_is_array(ctx, obj))
{
funcs = pdf_array_len(ctx, obj);
if (funcs != 1 && funcs != n)
{
funcs = 0;
fz_throw(ctx, FZ_ERROR_SYNTAX, "incorrect number of shading functions");
}
if (funcs > FZ_MAX_COLORS)
{
funcs = 0;
fz_throw(ctx, FZ_ERROR_SYNTAX, "too many shading functions");
}
if (type == 1)
in = 2;
else
in = 1;
out = 1;
for (i = 0; i < funcs; i++)
{
func[i] = pdf_load_function(ctx, pdf_array_get(ctx, obj, i), in, out);
if (!func[i])
fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot load shading function (%d 0 R)", pdf_to_num(ctx, obj));
}
}
else if (type < 4)
{
/* Functions are compulsory for types 1,2,3 */
fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot load shading function (%d 0 R)", pdf_to_num(ctx, obj));
}
shade->type = type;
switch (type)
{
case 1: pdf_load_function_based_shading(ctx, doc, shade, dict, func[0]); break;
case 2: pdf_load_linear_shading(ctx, doc, shade, dict, funcs, func); break;
case 3: pdf_load_radial_shading(ctx, doc, shade, dict, funcs, func); break;
case 4: pdf_load_type4_shade(ctx, doc, shade, dict, funcs, func); break;
case 5: pdf_load_type5_shade(ctx, doc, shade, dict, funcs, func); break;
case 6: pdf_load_type6_shade(ctx, doc, shade, dict, funcs, func); break;
case 7: pdf_load_type7_shade(ctx, doc, shade, dict, funcs, func); break;
default:
fz_throw(ctx, FZ_ERROR_SYNTAX, "unknown shading type: %d", type);
}
}
fz_always(ctx)
{
for (i = 0; i < funcs; i++)
pdf_drop_function(ctx, func[i]);
}
fz_catch(ctx)
{
fz_drop_shade(ctx, shade);
fz_rethrow(ctx);
}
return shade;
}
static void
pdf_load_mesh_params(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict)
{
pdf_obj *obj;
int i, n;
shade->u.m.x0 = shade->u.m.y0 = 0;
shade->u.m.x1 = shade->u.m.y1 = 1;
for (i = 0; i < FZ_MAX_COLORS; i++)
{
shade->u.m.c0[i] = 0;
shade->u.m.c1[i] = 1;
}
shade->u.m.vprow = pdf_dict_get_int(ctx, dict, PDF_NAME(VerticesPerRow));
shade->u.m.bpflag = pdf_dict_get_int(ctx, dict, PDF_NAME(BitsPerFlag));
shade->u.m.bpcoord = pdf_dict_get_int(ctx, dict, PDF_NAME(BitsPerCoordinate));
shade->u.m.bpcomp = pdf_dict_get_int(ctx, dict, PDF_NAME(BitsPerComponent));
obj = pdf_dict_get(ctx, dict, PDF_NAME(Decode));
if (pdf_array_len(ctx, obj) >= 6)
{
n = fz_mini(FZ_MAX_COLORS, (pdf_array_len(ctx, obj) - 4) / 2);
shade->u.m.x0 = pdf_array_get_real(ctx, obj, 0);
shade->u.m.x1 = pdf_array_get_real(ctx, obj, 1);
shade->u.m.y0 = pdf_array_get_real(ctx, obj, 2);
shade->u.m.y1 = pdf_array_get_real(ctx, obj, 3);
for (i = 0; i < n; i++)
{
shade->u.m.c0[i] = pdf_array_get_real(ctx, obj, 4 + i * 2);
shade->u.m.c1[i] = pdf_array_get_real(ctx, obj, 5 + i * 2);
}
}
if (shade->u.m.vprow < 2 && shade->type == 5)
{
fz_warn(ctx, "Too few vertices per row (%d)", shade->u.m.vprow);
shade->u.m.vprow = 2;
}
if (shade->u.m.bpflag != 2 && shade->u.m.bpflag != 4 && shade->u.m.bpflag != 8 &&
shade->type != 5)
{
fz_warn(ctx, "Invalid number of bits per flag (%d)", shade->u.m.bpflag);
shade->u.m.bpflag = 8;
}
if (shade->u.m.bpcoord != 1 && shade->u.m.bpcoord != 2 && shade->u.m.bpcoord != 4 &&
shade->u.m.bpcoord != 8 && shade->u.m.bpcoord != 12 && shade->u.m.bpcoord != 16 &&
shade->u.m.bpcoord != 24 && shade->u.m.bpcoord != 32)
{
fz_warn(ctx, "Invalid number of bits per coordinate (%d)", shade->u.m.bpcoord);
shade->u.m.bpcoord = 8;
}
if (shade->u.m.bpcomp != 1 && shade->u.m.bpcomp != 2 && shade->u.m.bpcomp != 4 &&
shade->u.m.bpcomp != 8 && shade->u.m.bpcomp != 12 && shade->u.m.bpcomp != 16)
{
fz_warn(ctx, "Invalid number of bits per component (%d)", shade->u.m.bpcomp);
shade->u.m.bpcomp = 8;
}
}
static fz_image *
pdf_load_image_imp(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cstm, int forcemask)
{
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 use_colorkey = 0;
fz_colorspace *colorspace = NULL;
float decode[FZ_MAX_COLORS * 2];
int colorkey[FZ_MAX_COLORS * 2];
int stride;
int i;
fz_compressed_buffer *buffer;
/* special case for JPEG2000 images */
if (pdf_is_jpx_image(ctx, dict))
return pdf_load_jpx_imp(ctx, doc, rdb, dict, cstm, forcemask);
w = pdf_to_int(ctx, pdf_dict_geta(ctx, dict, PDF_NAME(Width), PDF_NAME(W)));
h = pdf_to_int(ctx, pdf_dict_geta(ctx, dict, PDF_NAME(Height), PDF_NAME(H)));
bpc = pdf_to_int(ctx, pdf_dict_geta(ctx, dict, PDF_NAME(BitsPerComponent), PDF_NAME(BPC)));
if (bpc == 0)
bpc = 8;
imagemask = pdf_to_bool(ctx, pdf_dict_geta(ctx, dict, PDF_NAME(ImageMask), PDF_NAME(IM)));
interpolate = pdf_to_bool(ctx, pdf_dict_geta(ctx, dict, PDF_NAME(Interpolate), PDF_NAME(I)));
indexed = 0;
use_colorkey = 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");
fz_var(mask);
fz_var(image);
fz_var(colorspace);
fz_try(ctx)
{
obj = pdf_dict_geta(ctx, dict, PDF_NAME(ColorSpace), PDF_NAME(CS));
if (obj && !imagemask && !forcemask)
{
/* colorspace resource lookup is only done for inline images */
if (pdf_is_name(ctx, obj))
{
res = pdf_dict_get(ctx, pdf_dict_get(ctx, rdb, PDF_NAME(ColorSpace)), obj);
if (res)
obj = res;
}
colorspace = pdf_load_colorspace(ctx, obj);
indexed = fz_colorspace_is_indexed(ctx, colorspace);
n = fz_colorspace_n(ctx, colorspace);
}
else
{
n = 1;
}
obj = pdf_dict_geta(ctx, dict, PDF_NAME(Decode), PDF_NAME(D));
if (obj)
{
for (i = 0; i < n * 2; i++)
decode[i] = pdf_array_get_real(ctx, obj, i);
}
else if (fz_colorspace_is_lab(ctx, colorspace) || fz_colorspace_is_lab_icc(ctx, colorspace))
{
decode[0] = 0;
decode[1] = 100;
decode[2] = -128;
decode[3] = 127;
decode[4] = -128;
decode[5] = 127;
}
else
{
float maxval = indexed ? (1 << bpc) - 1 : 1;
for (i = 0; i < n * 2; i++)
decode[i] = i & 1 ? maxval : 0;
}
obj = pdf_dict_geta(ctx, dict, PDF_NAME(SMask), PDF_NAME(Mask));
if (pdf_is_dict(ctx, 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(ctx, doc, rdb, obj, NULL, 1);
obj = pdf_dict_get(ctx, obj, PDF_NAME(Matte));
if (pdf_is_array(ctx, obj))
{
use_colorkey = 1;
for (i = 0; i < n; i++)
colorkey[i] = pdf_array_get_real(ctx, obj, i) * 255;
}
}
}
else if (pdf_is_array(ctx, obj))
{
use_colorkey = 1;
for (i = 0; i < n * 2; i++)
{
if (!pdf_is_int(ctx, pdf_array_get(ctx, obj, i)))
{
fz_warn(ctx, "invalid value in color key mask");
use_colorkey = 0;
}
colorkey[i] = pdf_array_get_int(ctx, 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. */
buffer = pdf_load_compressed_stream(ctx, doc, pdf_to_num(ctx, dict));
image = fz_new_image_from_compressed_buffer(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, use_colorkey ? colorkey : NULL, buffer, mask);
image->invert_cmyk_jpeg = 0;
}
else
{
/* Inline stream */
stride = (w * n * bpc + 7) / 8;
image = fz_new_image_from_compressed_buffer(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, use_colorkey ? colorkey : NULL, NULL, mask);
image->invert_cmyk_jpeg = 0;
pdf_load_compressed_inline_image(ctx, doc, dict, stride * h, cstm, indexed, (fz_compressed_image *)image);
}
}
fz_always(ctx)
{
fz_drop_colorspace(ctx, colorspace);
fz_drop_image(ctx, mask);
}
fz_catch(ctx)
{
fz_drop_image(ctx, image);
fz_rethrow(ctx);
}
return image;
}
static fz_image *
pdf_load_jpx(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int forcemask)
{
fz_buffer *buf = NULL;
fz_colorspace *colorspace = NULL;
fz_pixmap *pix = NULL;
pdf_obj *obj;
fz_image *mask = NULL;
fz_image *img = NULL;
fz_var(pix);
fz_var(buf);
fz_var(colorspace);
fz_var(mask);
buf = pdf_load_stream(ctx, dict);
/* FIXME: We can't handle decode arrays for indexed images currently */
fz_try(ctx)
{
unsigned char *data;
size_t len;
obj = pdf_dict_get(ctx, dict, PDF_NAME(ColorSpace));
if (obj)
colorspace = pdf_load_colorspace(ctx, obj);
len = fz_buffer_storage(ctx, buf, &data);
pix = fz_load_jpx(ctx, data, len, colorspace);
obj = pdf_dict_geta(ctx, dict, PDF_NAME(SMask), PDF_NAME(Mask));
if (pdf_is_dict(ctx, obj))
{
if (forcemask)
fz_warn(ctx, "Ignoring recursive JPX soft mask");
else
mask = pdf_load_image_imp(ctx, doc, NULL, obj, NULL, 1);
}
obj = pdf_dict_geta(ctx, dict, PDF_NAME(Decode), PDF_NAME(D));
if (obj && !fz_colorspace_is_indexed(ctx, colorspace))
{
float decode[FZ_MAX_COLORS * 2];
int i;
for (i = 0; i < pix->n * 2; i++)
decode[i] = pdf_array_get_real(ctx, obj, i);
fz_decode_tile(ctx, pix, decode);
}
img = fz_new_image_from_pixmap(ctx, pix, mask);
}
fz_always(ctx)
{
fz_drop_image(ctx, mask);
fz_drop_pixmap(ctx, pix);
fz_drop_colorspace(ctx, colorspace);
fz_drop_buffer(ctx, buf);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
return img;
}