diff options
Diffstat (limited to 'draw')
| -rw-r--r-- | draw/draw_device.c | 272 | ||||
| -rw-r--r-- | draw/draw_edge.c | 30 | ||||
| -rw-r--r-- | draw/draw_glyph.c | 36 | ||||
| -rw-r--r-- | draw/draw_mesh.c | 18 | ||||
| -rw-r--r-- | draw/draw_path.c | 6 | ||||
| -rw-r--r-- | draw/draw_scale.c | 25 | ||||
| -rw-r--r-- | draw/draw_simple_scale.c | 24 |
7 files changed, 204 insertions, 207 deletions
diff --git a/draw/draw_device.c b/draw/draw_device.c index 0efe701a..5407d618 100644 --- a/draw/draw_device.c +++ b/draw/draw_device.c @@ -38,6 +38,7 @@ struct fz_draw_device_s { fz_glyph_cache *cache; fz_gel *gel; + fz_context *ctx; fz_pixmap *dest; fz_pixmap *shape; @@ -88,9 +89,8 @@ static void dump_spaces(int x, const char *s) #endif -static void fz_knockout_begin(void *user) +static void fz_knockout_begin(fz_draw_device *dev) { - fz_draw_device *dev = user; fz_bbox bbox; fz_pixmap *dest, *shape; int isolated = dev->blendmode & FZ_BLEND_ISOLATED; @@ -100,13 +100,13 @@ static void fz_knockout_begin(void *user) if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } bbox = fz_bound_pixmap(dev->dest); bbox = fz_intersect_bbox(bbox, dev->scissor); - dest = fz_new_pixmap_with_rect(dev->dest->colorspace, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, dev->dest->colorspace, bbox); if (isolated) { @@ -130,7 +130,7 @@ static void fz_knockout_begin(void *user) } else { - shape = fz_new_pixmap_with_rect(NULL, bbox); + shape = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(shape); } dev->stack[dev->top].blendmode = dev->blendmode; @@ -148,9 +148,8 @@ static void fz_knockout_begin(void *user) dev->blendmode &= ~FZ_BLEND_MODEMASK; } -static void fz_knockout_end(void *user) +static void fz_knockout_end(fz_draw_device *dev) { - fz_draw_device *dev = user; fz_pixmap *group = dev->dest; fz_pixmap *shape = dev->shape; int blendmode; @@ -161,7 +160,7 @@ static void fz_knockout_end(void *user) if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } @@ -194,14 +193,14 @@ static void fz_knockout_end(void *user) else fz_blend_pixmap(dev->dest, group, 255, blendmode, isolated, shape); - fz_drop_pixmap(group); + fz_drop_pixmap(dev->ctx, group); if (shape != dev->shape) { if (dev->shape) { fz_paint_pixmap(dev->shape, shape, 255); } - fz_drop_pixmap(shape); + fz_drop_pixmap(dev->ctx, shape); } #ifdef DUMP_GROUP_BLENDS fz_dump_blend(dev->dest, " to get "); @@ -213,10 +212,10 @@ static void fz_knockout_end(void *user) } static void -fz_draw_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm, +fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; @@ -238,7 +237,7 @@ fz_draw_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm, if (dev->blendmode & FZ_BLEND_KNOCKOUT) fz_knockout_begin(dev); - fz_convert_color(colorspace, color, model, colorfv); + fz_convert_color(dev->ctx, colorspace, color, model, colorfv); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -259,10 +258,10 @@ fz_draw_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm, } static void -fz_draw_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, +fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; @@ -291,7 +290,7 @@ fz_draw_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matri if (dev->blendmode & FZ_BLEND_KNOCKOUT) fz_knockout_begin(dev); - fz_convert_color(colorspace, color, model, colorfv); + fz_convert_color(dev->ctx, colorspace, color, model, colorfv); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -315,9 +314,9 @@ fz_draw_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matri } static void -fz_draw_clip_path(void *user, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm) +fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; @@ -326,7 +325,7 @@ fz_draw_clip_path(void *user, fz_path *path, fz_rect *rect, int even_odd, fz_mat if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } @@ -354,14 +353,14 @@ fz_draw_clip_path(void *user, fz_path *path, fz_rect *rect, int even_odd, fz_mat return; } - mask = fz_new_pixmap_with_rect(NULL, bbox); + mask = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(mask); - dest = fz_new_pixmap_with_rect(model, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, model, bbox); /* FIXME: See note #1 */ fz_clear_pixmap(dest); if (dev->shape) { - shape = fz_new_pixmap_with_rect(NULL, bbox); + shape = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(shape); } else @@ -385,9 +384,9 @@ fz_draw_clip_path(void *user, fz_path *path, fz_rect *rect, int even_odd, fz_mat } static void -fz_draw_clip_stroke_path(void *user, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm) +fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; @@ -397,7 +396,7 @@ fz_draw_clip_stroke_path(void *user, fz_path *path, fz_rect *rect, fz_stroke_sta if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } @@ -416,14 +415,14 @@ fz_draw_clip_stroke_path(void *user, fz_path *path, fz_rect *rect, fz_stroke_sta if (rect) bbox = fz_intersect_bbox(bbox, fz_round_rect(*rect)); - mask = fz_new_pixmap_with_rect(NULL, bbox); + mask = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(mask); - dest = fz_new_pixmap_with_rect(model, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, model, bbox); /* FIXME: See note #1 */ fz_clear_pixmap(dest); if (dev->shape) { - shape = fz_new_pixmap_with_rect(NULL, bbox); + shape = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(shape); } else @@ -484,10 +483,10 @@ draw_glyph(unsigned char *colorbv, fz_pixmap *dst, fz_pixmap *msk, } static void -fz_draw_fill_text(void *user, fz_text *text, fz_matrix ctm, +fz_draw_fill_text(fz_device *devp, fz_text *text, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; unsigned char colorbv[FZ_MAX_COLORS + 1]; unsigned char shapebv; @@ -499,7 +498,7 @@ fz_draw_fill_text(void *user, fz_text *text, fz_matrix ctm, if (dev->blendmode & FZ_BLEND_KNOCKOUT) fz_knockout_begin(dev); - fz_convert_color(colorspace, color, model, colorfv); + fz_convert_color(dev->ctx, colorspace, color, model, colorfv); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -521,7 +520,7 @@ fz_draw_fill_text(void *user, fz_text *text, fz_matrix ctm, trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX); trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX); - glyph = fz_render_glyph(dev->cache, text->font, gid, trm, model); + glyph = fz_render_glyph(dev->ctx, dev->cache, text->font, gid, trm, model); if (glyph) { if (glyph->n == 1) @@ -535,7 +534,7 @@ fz_draw_fill_text(void *user, fz_text *text, fz_matrix ctm, fz_matrix ctm = {glyph->w, 0.0, 0.0, -glyph->h, x + glyph->x, y + glyph->y + glyph->h}; fz_paint_image(dev->dest, dev->scissor, dev->shape, glyph, ctm, alpha * 255); } - fz_drop_pixmap(glyph); + fz_drop_pixmap(dev->ctx, glyph); } } @@ -544,10 +543,10 @@ fz_draw_fill_text(void *user, fz_text *text, fz_matrix ctm, } static void -fz_draw_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm, +fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; unsigned char colorbv[FZ_MAX_COLORS + 1]; float colorfv[FZ_MAX_COLORS]; @@ -558,7 +557,7 @@ fz_draw_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matri if (dev->blendmode & FZ_BLEND_KNOCKOUT) fz_knockout_begin(dev); - fz_convert_color(colorspace, color, model, colorfv); + fz_convert_color(dev->ctx, colorspace, color, model, colorfv); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -579,13 +578,13 @@ fz_draw_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matri trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX); trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX); - glyph = fz_render_stroked_glyph(dev->cache, text->font, gid, trm, ctm, stroke); + glyph = fz_render_stroked_glyph(dev->ctx, dev->cache, text->font, gid, trm, ctm, stroke); if (glyph) { draw_glyph(colorbv, dev->dest, glyph, x, y, dev->scissor); if (dev->shape) draw_glyph(colorbv, dev->shape, glyph, x, y, dev->scissor); - fz_drop_pixmap(glyph); + fz_drop_pixmap(dev->ctx, glyph); } } @@ -594,9 +593,9 @@ fz_draw_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matri } static void -fz_draw_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate) +fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; fz_bbox bbox; fz_pixmap *mask, *dest, *shape; @@ -610,7 +609,7 @@ fz_draw_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate) if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } @@ -628,14 +627,14 @@ fz_draw_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate) if (accumulate == 0 || accumulate == 1) { - mask = fz_new_pixmap_with_rect(NULL, bbox); + mask = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(mask); - dest = fz_new_pixmap_with_rect(model, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, model, bbox); /* FIXME: See note #1 */ fz_clear_pixmap(dest); if (dev->shape) { - shape = fz_new_pixmap_with_rect(NULL, bbox); + shape = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(shape); } else @@ -678,22 +677,22 @@ fz_draw_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate) trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX); trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX); - glyph = fz_render_glyph(dev->cache, text->font, gid, trm, model); + glyph = fz_render_glyph(dev->ctx, dev->cache, text->font, gid, trm, model); if (glyph) { draw_glyph(NULL, mask, glyph, x, y, bbox); if (dev->shape) draw_glyph(NULL, dev->shape, glyph, x, y, bbox); - fz_drop_pixmap(glyph); + fz_drop_pixmap(dev->ctx, glyph); } } } } static void -fz_draw_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm) +fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; fz_bbox bbox; fz_pixmap *mask, *dest, *shape; @@ -703,7 +702,7 @@ fz_draw_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_ if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } @@ -711,14 +710,14 @@ fz_draw_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_ bbox = fz_round_rect(fz_bound_text(text, ctm)); bbox = fz_intersect_bbox(bbox, dev->scissor); - mask = fz_new_pixmap_with_rect(NULL, bbox); + mask = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(mask); - dest = fz_new_pixmap_with_rect(model, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, model, bbox); /* FIXME: See note #1 */ fz_clear_pixmap(dest); if (dev->shape) { - shape = fz_new_pixmap_with_rect(NULL, bbox); + shape = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(shape); } else @@ -756,27 +755,27 @@ fz_draw_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_ trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX); trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX); - glyph = fz_render_stroked_glyph(dev->cache, text->font, gid, trm, ctm, stroke); + glyph = fz_render_stroked_glyph(dev->ctx, dev->cache, text->font, gid, trm, ctm, stroke); if (glyph) { draw_glyph(NULL, mask, glyph, x, y, bbox); if (dev->shape) draw_glyph(NULL, dev->shape, glyph, x, y, bbox); - fz_drop_pixmap(glyph); + fz_drop_pixmap(dev->ctx, glyph); } } } } static void -fz_draw_ignore_text(void *user, fz_text *text, fz_matrix ctm) +fz_draw_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm) { } static void -fz_draw_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha) +fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; fz_pixmap *dest = dev->dest; fz_rect bounds; @@ -795,13 +794,13 @@ fz_draw_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha) if (!model) { - fz_warn("cannot render shading directly to an alpha mask"); + fz_warn(dev->ctx, "cannot render shading directly to an alpha mask"); return; } if (alpha < 1) { - dest = fz_new_pixmap_with_rect(dev->dest->colorspace, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, dev->dest->colorspace, bbox); fz_clear_pixmap(dest); } @@ -812,7 +811,7 @@ fz_draw_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha) { unsigned char *s; int x, y, n, i; - fz_convert_color(shade->colorspace, shade->background, model, colorfv); + fz_convert_color(dev->ctx, shade->colorspace, shade->background, model, colorfv); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = 255; @@ -840,14 +839,14 @@ fz_draw_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha) } } - fz_paint_shade(shade, ctm, dest, bbox); + fz_paint_shade(dev->ctx, shade, ctm, dest, bbox); if (dev->shape) fz_clear_pixmap_rect_with_color(dev->shape, 255, bbox); if (alpha < 1) { fz_paint_pixmap(dev->dest, dest, alpha * 255); - fz_drop_pixmap(dest); + fz_drop_pixmap(dev->ctx, dest); } if (dev->blendmode & FZ_BLEND_KNOCKOUT) @@ -855,7 +854,7 @@ fz_draw_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha) } static fz_pixmap * -fz_transform_pixmap(fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy, int gridfit) +fz_transform_pixmap(fz_context *ctx, fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy, int gridfit) { fz_pixmap *scaled; @@ -865,7 +864,7 @@ fz_transform_pixmap(fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int fz_matrix m = *ctm; if (gridfit) fz_gridfit_matrix(&m); - scaled = fz_scale_pixmap(image, m.e, m.f, m.a, m.d); + scaled = fz_scale_pixmap(ctx, image, m.e, m.f, m.a, m.d); if (scaled == NULL) return NULL; ctm->a = scaled->w; @@ -881,7 +880,7 @@ fz_transform_pixmap(fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int fz_matrix m = *ctm; if (gridfit) fz_gridfit_matrix(&m); - scaled = fz_scale_pixmap(image, m.f, m.e, m.b, m.c); + scaled = fz_scale_pixmap(ctx, image, m.f, m.e, m.b, m.c); if (scaled == NULL) return NULL; ctm->b = scaled->w; @@ -894,7 +893,7 @@ fz_transform_pixmap(fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int /* Downscale, non rectilinear case */ if (dx > 0 && dy > 0) { - scaled = fz_scale_pixmap(image, 0, 0, (float)dx, (float)dy); + scaled = fz_scale_pixmap(ctx, image, 0, 0, (float)dx, (float)dy); return scaled; } @@ -902,9 +901,9 @@ fz_transform_pixmap(fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int } static void -fz_draw_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha) +fz_draw_fill_image(fz_device *devp, fz_pixmap *image, fz_matrix ctm, float alpha) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; fz_pixmap *converted = NULL; fz_pixmap *scaled = NULL; @@ -913,7 +912,7 @@ fz_draw_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha) if (!model) { - fz_warn("cannot render image directly to an alpha mask"); + fz_warn(dev->ctx, "cannot render image directly to an alpha mask"); return; } @@ -933,8 +932,8 @@ fz_draw_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha) if (image->colorspace != model && !after) { - converted = fz_new_pixmap_with_rect(model, fz_bound_pixmap(image)); - fz_convert_pixmap(image, converted); + converted = fz_new_pixmap_with_rect(dev->ctx, model, fz_bound_pixmap(image)); + fz_convert_pixmap(dev->ctx, image, converted); image = converted; } @@ -943,14 +942,14 @@ fz_draw_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha) if (dx < image->w && dy < image->h) { int gridfit = alpha == 1.0f && !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3); - scaled = fz_transform_pixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy, gridfit); + scaled = fz_transform_pixmap(dev->ctx, image, &ctm, dev->dest->x, dev->dest->y, dx, dy, gridfit); if (scaled == NULL) { if (dx < 1) dx = 1; if (dy < 1) dy = 1; - scaled = fz_scale_pixmap(image, image->x, image->y, dx, dy); + scaled = fz_scale_pixmap(dev->ctx, image, image->x, image->y, dx, dy); } if (scaled != NULL) image = scaled; @@ -965,8 +964,8 @@ fz_draw_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha) } else { - converted = fz_new_pixmap_with_rect(model, fz_bound_pixmap(image)); - fz_convert_pixmap(image, converted); + converted = fz_new_pixmap_with_rect(dev->ctx, model, fz_bound_pixmap(image)); + fz_convert_pixmap(dev->ctx, image, converted); image = converted; } } @@ -974,19 +973,19 @@ fz_draw_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha) fz_paint_image(dev->dest, dev->scissor, dev->shape, image, ctm, alpha * 255); if (scaled) - fz_drop_pixmap(scaled); + fz_drop_pixmap(dev->ctx, scaled); if (converted) - fz_drop_pixmap(converted); + fz_drop_pixmap(dev->ctx, converted); if (dev->blendmode & FZ_BLEND_KNOCKOUT) fz_knockout_end(dev); } static void -fz_draw_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm, +fz_draw_fill_image_mask(fz_device *devp, fz_pixmap *image, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; unsigned char colorbv[FZ_MAX_COLORS + 1]; float colorfv[FZ_MAX_COLORS]; @@ -1005,20 +1004,20 @@ fz_draw_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm, if (dx < image->w && dy < image->h) { int gridfit = alpha == 1.0f && !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3); - scaled = fz_transform_pixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy, gridfit); + scaled = fz_transform_pixmap(dev->ctx, image, &ctm, dev->dest->x, dev->dest->y, dx, dy, gridfit); if (scaled == NULL) { if (dx < 1) dx = 1; if (dy < 1) dy = 1; - scaled = fz_scale_pixmap(image, image->x, image->y, dx, dy); + scaled = fz_scale_pixmap(dev->ctx, image, image->x, image->y, dx, dy); } if (scaled != NULL) image = scaled; } - fz_convert_color(colorspace, color, model, colorfv); + fz_convert_color(dev->ctx, colorspace, color, model, colorfv); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -1026,16 +1025,16 @@ fz_draw_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm, fz_paint_image_with_color(dev->dest, dev->scissor, dev->shape, image, ctm, colorbv); if (scaled) - fz_drop_pixmap(scaled); + fz_drop_pixmap(dev->ctx, scaled); if (dev->blendmode & FZ_BLEND_KNOCKOUT) fz_knockout_begin(dev); } static void -fz_draw_clip_image_mask(void *user, fz_pixmap *image, fz_rect *rect, fz_matrix ctm) +fz_draw_clip_image_mask(fz_device *devp, fz_pixmap *image, fz_rect *rect, fz_matrix ctm) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; fz_bbox bbox; fz_pixmap *mask, *dest, *shape; @@ -1044,7 +1043,7 @@ fz_draw_clip_image_mask(void *user, fz_pixmap *image, fz_rect *rect, fz_matrix c if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } @@ -1068,14 +1067,14 @@ fz_draw_clip_image_mask(void *user, fz_pixmap *image, fz_rect *rect, fz_matrix c if (rect) bbox = fz_intersect_bbox(bbox, fz_round_rect(*rect)); - mask = fz_new_pixmap_with_rect(NULL, bbox); + mask = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(mask); - dest = fz_new_pixmap_with_rect(model, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, model, bbox); /* FIXME: See note #1 */ fz_clear_pixmap(dest); if (dev->shape) { - shape = fz_new_pixmap_with_rect(NULL, bbox); + shape = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(shape); } else @@ -1086,14 +1085,14 @@ fz_draw_clip_image_mask(void *user, fz_pixmap *image, fz_rect *rect, fz_matrix c if (dx < image->w && dy < image->h) { int gridfit = !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3); - scaled = fz_transform_pixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy, gridfit); + scaled = fz_transform_pixmap(dev->ctx, image, &ctm, dev->dest->x, dev->dest->y, dx, dy, gridfit); if (scaled == NULL) { if (dx < 1) dx = 1; if (dy < 1) dy = 1; - scaled = fz_scale_pixmap(image, image->x, image->y, dx, dy); + scaled = fz_scale_pixmap(dev->ctx, image, image->x, image->y, dx, dy); } if (scaled != NULL) image = scaled; @@ -1102,7 +1101,7 @@ fz_draw_clip_image_mask(void *user, fz_pixmap *image, fz_rect *rect, fz_matrix c fz_paint_image(mask, bbox, dev->shape, image, ctm, 255); if (scaled) - fz_drop_pixmap(scaled); + fz_drop_pixmap(dev->ctx, scaled); dev->stack[dev->top].scissor = dev->scissor; dev->stack[dev->top].mask = mask; @@ -1117,9 +1116,9 @@ fz_draw_clip_image_mask(void *user, fz_pixmap *image, fz_rect *rect, fz_matrix c } static void -fz_draw_pop_clip(void *user) +fz_draw_pop_clip(fz_device *devp) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_pixmap *mask, *dest, *shape; if (dev->top > 0) { @@ -1153,11 +1152,11 @@ fz_draw_pop_clip(void *user) { assert(shape != dev->shape); fz_paint_pixmap_with_mask(shape, dev->shape, mask); - fz_drop_pixmap(dev->shape); + fz_drop_pixmap(dev->ctx, dev->shape); dev->shape = shape; } - fz_drop_pixmap(mask); - fz_drop_pixmap(dev->dest); + fz_drop_pixmap(dev->ctx, mask); + fz_drop_pixmap(dev->ctx, dev->dest); dev->dest = dest; #ifdef DUMP_GROUP_BLENDS fz_dump_blend(dev->dest, " to get "); @@ -1178,22 +1177,22 @@ fz_draw_pop_clip(void *user) } static void -fz_draw_begin_mask(void *user, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *colorfv) +fz_draw_begin_mask(fz_device *devp, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *colorfv) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_pixmap *dest; fz_pixmap *shape = dev->shape; fz_bbox bbox; if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } bbox = fz_round_rect(rect); bbox = fz_intersect_bbox(bbox, dev->scissor); - dest = fz_new_pixmap_with_rect(fz_device_gray, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, fz_device_gray, bbox); if (dev->shape) { /* FIXME: If we ever want to support AIS true, then we @@ -1210,7 +1209,7 @@ fz_draw_begin_mask(void *user, fz_rect rect, int luminosity, fz_colorspace *colo float bc; if (!colorspace) colorspace = fz_device_gray; - fz_convert_color(colorspace, colorfv, fz_device_gray, &bc); + fz_convert_color(dev->ctx, colorspace, colorfv, fz_device_gray, &bc); fz_clear_pixmap_with_color(dest, bc * 255); if (shape) fz_clear_pixmap_with_color(shape, 255); @@ -1238,9 +1237,9 @@ fz_draw_begin_mask(void *user, fz_rect rect, int luminosity, fz_colorspace *colo } static void -fz_draw_end_mask(void *user) +fz_draw_end_mask(fz_device *devp) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_pixmap *mask = dev->dest; fz_pixmap *maskshape = dev->shape; fz_pixmap *temp, *dest; @@ -1249,7 +1248,7 @@ fz_draw_end_mask(void *user) if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } @@ -1263,13 +1262,13 @@ fz_draw_end_mask(void *user) dev->shape = dev->stack[dev->top].shape; /* convert to alpha mask */ - temp = fz_alpha_from_gray(mask, luminosity); - fz_drop_pixmap(mask); - fz_drop_pixmap(maskshape); + temp = fz_alpha_from_gray(dev->ctx, mask, luminosity); + fz_drop_pixmap(dev->ctx, mask); + fz_drop_pixmap(dev->ctx, maskshape); /* create new dest scratch buffer */ bbox = fz_bound_pixmap(temp); - dest = fz_new_pixmap_with_rect(dev->dest->colorspace, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, dev->dest->colorspace, bbox); /* FIXME: See note #1 */ fz_clear_pixmap(dest); @@ -1284,7 +1283,7 @@ fz_draw_end_mask(void *user) if (dev->shape) { dev->stack[dev->top].shape = dev->shape; - dev->shape = fz_new_pixmap_with_rect(NULL, bbox); + dev->shape = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(dev->shape); } dev->scissor = bbox; @@ -1297,16 +1296,16 @@ fz_draw_end_mask(void *user) } static void -fz_draw_begin_group(void *user, fz_rect rect, int isolated, int knockout, int blendmode, float alpha) +fz_draw_begin_group(fz_device *devp, fz_rect rect, int isolated, int knockout, int blendmode, float alpha) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; fz_bbox bbox; fz_pixmap *dest, *shape; if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } @@ -1315,7 +1314,7 @@ fz_draw_begin_group(void *user, fz_rect rect, int isolated, int knockout, int bl bbox = fz_round_rect(rect); bbox = fz_intersect_bbox(bbox, dev->scissor); - dest = fz_new_pixmap_with_rect(model, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, model, bbox); #ifndef ATTEMPT_KNOCKOUT_AND_ISOLATED knockout = 0; @@ -1339,7 +1338,7 @@ fz_draw_begin_group(void *user, fz_rect rect, int isolated, int knockout, int bl } else { - shape = fz_new_pixmap_with_rect(NULL, bbox); + shape = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox); fz_clear_pixmap(shape); } @@ -1360,9 +1359,9 @@ fz_draw_begin_group(void *user, fz_rect rect, int isolated, int knockout, int bl } static void -fz_draw_end_group(void *user) +fz_draw_end_group(fz_device *devp) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_pixmap *group = dev->dest; fz_pixmap *shape = dev->shape; int blendmode; @@ -1402,14 +1401,14 @@ fz_draw_end_group(void *user) else fz_blend_pixmap(dev->dest, group, alpha * 255, blendmode, isolated, shape); - fz_drop_pixmap(group); + fz_drop_pixmap(dev->ctx, group); if (shape != dev->shape) { if (dev->shape) { fz_paint_pixmap(dev->shape, shape, alpha * 255); } - fz_drop_pixmap(shape); + fz_drop_pixmap(dev->ctx, shape); } #ifdef DUMP_GROUP_BLENDS fz_dump_blend(dev->dest, " to get "); @@ -1424,9 +1423,9 @@ fz_draw_end_group(void *user) } static void -fz_draw_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm) +fz_draw_begin_tile(fz_device *devp, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_colorspace *model = dev->dest->colorspace; fz_pixmap *dest; fz_bbox bbox; @@ -1436,7 +1435,7 @@ fz_draw_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ys if (dev->top == STACK_SIZE) { - fz_warn("assert: too many buffers on stack"); + fz_warn(dev->ctx, "assert: too many buffers on stack"); return; } @@ -1444,7 +1443,7 @@ fz_draw_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ys fz_knockout_begin(dev); bbox = fz_round_rect(fz_transform_rect(ctm, view)); - dest = fz_new_pixmap_with_rect(model, bbox); + dest = fz_new_pixmap_with_rect(dev->ctx, model, bbox); /* FIXME: See note #1 */ fz_clear_pixmap(dest); @@ -1467,9 +1466,9 @@ fz_draw_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ys } static void -fz_draw_end_tile(void *user) +fz_draw_end_tile(fz_device *devp) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; fz_pixmap *tile = dev->dest; float xstep, ystep; fz_matrix ctm, ttm; @@ -1510,7 +1509,7 @@ fz_draw_end_tile(void *user) } } - fz_drop_pixmap(tile); + fz_drop_pixmap(dev->ctx, tile); } if (dev->blendmode & FZ_BLEND_KNOCKOUT) @@ -1518,35 +1517,36 @@ fz_draw_end_tile(void *user) } static void -fz_draw_free_user(void *user) +fz_draw_free_user(fz_device *devp) { - fz_draw_device *dev = user; + fz_draw_device *dev = devp->user; /* TODO: pop and free the stacks */ if (dev->top > 0) - fz_warn("items left on stack in draw device: %d", dev->top); + fz_warn(dev->ctx, "items left on stack in draw device: %d", dev->top); fz_free_gel(dev->gel); - fz_free(dev); + fz_free(devp->ctx, dev); } fz_device * -fz_new_draw_device(fz_glyph_cache *cache, fz_pixmap *dest) +fz_new_draw_device(fz_context *ctx, fz_glyph_cache *cache, fz_pixmap *dest) { fz_device *dev; - fz_draw_device *ddev = fz_malloc(sizeof(fz_draw_device)); + fz_draw_device *ddev = fz_malloc(ctx, sizeof(fz_draw_device)); ddev->cache = cache; - ddev->gel = fz_new_gel(); + ddev->gel = fz_new_gel(ctx); ddev->dest = dest; ddev->shape = NULL; ddev->top = 0; ddev->blendmode = 0; ddev->flags = 0; + ddev->ctx = ctx; ddev->scissor.x0 = dest->x; ddev->scissor.y0 = dest->y; ddev->scissor.x1 = dest->x + dest->w; ddev->scissor.y1 = dest->y + dest->h; - dev = fz_new_device(ddev); + dev = fz_new_device(ctx, ddev); dev->free_user = fz_draw_free_user; dev->fill_path = fz_draw_fill_path; @@ -1579,9 +1579,9 @@ fz_new_draw_device(fz_glyph_cache *cache, fz_pixmap *dest) } fz_device * -fz_new_draw_device_type3(fz_glyph_cache *cache, fz_pixmap *dest) +fz_new_draw_device_type3(fz_context *ctx, fz_glyph_cache *cache, fz_pixmap *dest) { - fz_device *dev = fz_new_draw_device(cache, dest); + fz_device *dev = fz_new_draw_device(ctx, cache, dest); fz_draw_device *ddev = dev->user; ddev->flags |= FZ_DRAWDEV_FLAGS_TYPE3; return dev; diff --git a/draw/draw_edge.c b/draw/draw_edge.c index 123c3268..e6408bf3 100644 --- a/draw/draw_edge.c +++ b/draw/draw_edge.c @@ -65,7 +65,7 @@ void fz_set_aa_level(int level) { #ifdef AA_BITS - fz_warn("anti-aliasing was compiled with a fixed precision of %d bits", fz_aa_level); + fz_warn(ctx, "anti-aliasing was compiled with a fixed precision of %d bits", fz_aa_level); #else if (level > 6) { @@ -127,17 +127,19 @@ struct fz_gel_s fz_edge *edges; int acap, alen; fz_edge **active; + fz_context *ctx; }; fz_gel * -fz_new_gel(void) +fz_new_gel(fz_context *ctx) { fz_gel *gel; - gel = fz_malloc(sizeof(fz_gel)); + gel = fz_malloc(ctx, sizeof(fz_gel)); + gel->ctx = ctx; gel->cap = 512; gel->len = 0; - gel->edges = fz_calloc(gel->cap, sizeof(fz_edge)); + gel->edges = fz_malloc_array(ctx, gel->cap, sizeof(fz_edge)); gel->clip.x0 = gel->clip.y0 = BBOX_MAX; gel->clip.x1 = gel->clip.y1 = BBOX_MIN; @@ -147,7 +149,7 @@ fz_new_gel(void) gel->acap = 64; gel->alen = 0; - gel->active = fz_calloc(gel->acap, sizeof(fz_edge*)); + gel->active = fz_malloc_array(ctx, gel->acap, sizeof(fz_edge*)); return gel; } @@ -176,9 +178,9 @@ fz_reset_gel(fz_gel *gel, fz_bbox clip) void fz_free_gel(fz_gel *gel) { - fz_free(gel->active); - fz_free(gel->edges); - fz_free(gel); + fz_free(gel->ctx, gel->active); + fz_free(gel->ctx, gel->edges); + fz_free(gel->ctx, gel); } fz_bbox @@ -253,7 +255,7 @@ fz_insert_gel_raw(fz_gel *gel, int x0, int y0, int x1, int y1) if (gel->len + 1 == gel->cap) { gel->cap = gel->cap + 512; - gel->edges = fz_realloc(gel->edges, gel->cap, sizeof(fz_edge)); + gel->edges = fz_resize_array(gel->ctx, gel->edges, gel->cap, sizeof(fz_edge)); } edge = &gel->edges[gel->len++]; @@ -443,7 +445,7 @@ insert_active(fz_gel *gel, int y, int *e) while (*e < gel->len && gel->edges[*e].y == y) { if (gel->alen + 1 == gel->acap) { int newcap = gel->acap + 64; - fz_edge **newactive = fz_realloc(gel->active, newcap, sizeof(fz_edge*)); + fz_edge **newactive = fz_resize_array(gel->ctx, gel->active, newcap, sizeof(fz_edge*)); gel->active = newactive; gel->acap = newcap; } @@ -593,8 +595,8 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip, assert(clip.x0 >= xmin); assert(clip.x1 <= xmax); - alphas = fz_malloc(xmax - xmin + 1); - deltas = fz_malloc((xmax - xmin + 1) * sizeof(int)); + alphas = fz_malloc(gel->ctx, xmax - xmin + 1); + deltas = fz_malloc(gel->ctx, (xmax - xmin + 1) * sizeof(int)); memset(deltas, 0, (xmax - xmin + 1) * sizeof(int)); e = 0; @@ -640,8 +642,8 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip, blit_aa(dst, xmin + skipx, yd, alphas + skipx, clipn, color); } - fz_free(deltas); - fz_free(alphas); + fz_free(gel->ctx, deltas); + fz_free(gel->ctx, alphas); } /* diff --git a/draw/draw_glyph.c b/draw/draw_glyph.c index 95f3955d..6cb1518a 100644 --- a/draw/draw_glyph.c +++ b/draw/draw_glyph.c @@ -22,19 +22,19 @@ struct fz_glyph_key_s }; fz_glyph_cache * -fz_new_glyph_cache(void) +fz_new_glyph_cache(fz_context *ctx) { fz_glyph_cache *cache; - cache = fz_malloc(sizeof(fz_glyph_cache)); - cache->hash = fz_new_hash_table(509, sizeof(fz_glyph_key)); + cache = fz_malloc(ctx, sizeof(fz_glyph_cache)); + cache->hash = fz_new_hash_table(ctx, 509, sizeof(fz_glyph_key)); cache->total = 0; return cache; } static void -fz_evict_glyph_cache(fz_glyph_cache *cache) +fz_evict_glyph_cache(fz_context *ctx, fz_glyph_cache *cache) { fz_glyph_key *key; fz_pixmap *pixmap; @@ -44,10 +44,10 @@ fz_evict_glyph_cache(fz_glyph_cache *cache) { key = fz_hash_get_key(cache->hash, i); if (key->font) - fz_drop_font(key->font); + fz_drop_font(ctx, key->font); pixmap = fz_hash_get_val(cache->hash, i); if (pixmap) - fz_drop_pixmap(pixmap); + fz_drop_pixmap(ctx, pixmap); } cache->total = 0; @@ -56,23 +56,23 @@ fz_evict_glyph_cache(fz_glyph_cache *cache) } void -fz_free_glyph_cache(fz_glyph_cache *cache) +fz_free_glyph_cache(fz_context *ctx, fz_glyph_cache *cache) { - fz_evict_glyph_cache(cache); + fz_evict_glyph_cache(ctx, cache); fz_free_hash(cache->hash); - fz_free(cache); + fz_free(ctx, cache); } fz_pixmap * -fz_render_stroked_glyph(fz_glyph_cache *cache, fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *stroke) +fz_render_stroked_glyph(fz_context *ctx, fz_glyph_cache *cache, fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *stroke) { if (font->ft_face) - return fz_render_ft_stroked_glyph(font, gid, trm, ctm, stroke); - return fz_render_glyph(cache, font, gid, trm, NULL); + return fz_render_ft_stroked_glyph(ctx, font, gid, trm, ctm, stroke); + return fz_render_glyph(ctx, cache, font, gid, trm, NULL); } fz_pixmap * -fz_render_glyph(fz_glyph_cache *cache, fz_font *font, int gid, fz_matrix ctm, fz_colorspace *model) +fz_render_glyph(fz_context *ctx, fz_glyph_cache *cache, fz_font *font, int gid, fz_matrix ctm, fz_colorspace *model) { fz_glyph_key key; fz_pixmap *val; @@ -81,7 +81,7 @@ fz_render_glyph(fz_glyph_cache *cache, fz_font *font, int gid, fz_matrix ctm, fz if (size > MAX_FONT_SIZE) { /* TODO: this case should be handled by rendering glyph as a path fill */ - fz_warn("font size too large (%g), not rendering glyph", size); + fz_warn(ctx, "font size too large (%g), not rendering glyph", size); return NULL; } @@ -104,15 +104,15 @@ fz_render_glyph(fz_glyph_cache *cache, fz_font *font, int gid, fz_matrix ctm, fz if (font->ft_face) { - val = fz_render_ft_glyph(font, gid, ctm); + val = fz_render_ft_glyph(ctx, font, gid, ctm); } else if (font->t3procs) { - val = fz_render_t3_glyph(font, gid, ctm, model); + val = fz_render_t3_glyph(ctx, font, gid, ctm, model); } else { - fz_warn("assert: uninitialized font structure"); + fz_warn(ctx, "assert: uninitialized font structure"); return NULL; } @@ -121,7 +121,7 @@ fz_render_glyph(fz_glyph_cache *cache, fz_font *font, int gid, fz_matrix ctm, fz if (val->w < MAX_GLYPH_SIZE && val->h < MAX_GLYPH_SIZE) { if (cache->total + val->w * val->h > MAX_CACHE_SIZE) - fz_evict_glyph_cache(cache); + fz_evict_glyph_cache(ctx, cache); fz_keep_font(key.font); fz_hash_insert(cache->hash, &key, val); cache->total += val->w * val->h; diff --git a/draw/draw_mesh.c b/draw/draw_mesh.c index 4254cb64..ef4ed95b 100644 --- a/draw/draw_mesh.c +++ b/draw/draw_mesh.c @@ -481,7 +481,7 @@ fz_paint_radial(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) } static void -fz_paint_mesh(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) +fz_paint_mesh(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) { float tri[3][MAXN]; fz_point p; @@ -509,7 +509,7 @@ fz_paint_mesh(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) tri[k][2] = *mesh++ * 255; else { - fz_convert_color(shade->colorspace, mesh, dest->colorspace, tri[k] + 2); + fz_convert_color(ctx, shade->colorspace, mesh, dest->colorspace, tri[k] + 2); for (i = 0; i < dest->colorspace->n; i++) tri[k][i + 2] *= 255; mesh += shade->colorspace->n; @@ -520,7 +520,7 @@ fz_paint_mesh(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) } void -fz_paint_shade(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) +fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) { unsigned char clut[256][FZ_MAX_COLORS]; fz_pixmap *temp, *conv; @@ -533,13 +533,13 @@ fz_paint_shade(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) { for (i = 0; i < 256; i++) { - fz_convert_color(shade->colorspace, shade->function[i], dest->colorspace, color); + fz_convert_color(ctx, shade->colorspace, shade->function[i], dest->colorspace, color); for (k = 0; k < dest->colorspace->n; k++) clut[i][k] = color[k] * 255; clut[i][k] = shade->function[i][shade->colorspace->n] * 255; } - conv = fz_new_pixmap_with_rect(dest->colorspace, bbox); - temp = fz_new_pixmap_with_rect(fz_device_gray, bbox); + conv = fz_new_pixmap_with_rect(ctx, dest->colorspace, bbox); + temp = fz_new_pixmap_with_rect(ctx, fz_device_gray, bbox); fz_clear_pixmap(temp); } else @@ -551,7 +551,7 @@ fz_paint_shade(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) { case FZ_LINEAR: fz_paint_linear(shade, ctm, temp, bbox); break; case FZ_RADIAL: fz_paint_radial(shade, ctm, temp, bbox); break; - case FZ_MESH: fz_paint_mesh(shade, ctm, temp, bbox); break; + case FZ_MESH: fz_paint_mesh(ctx, shade, ctm, temp, bbox); break; } if (shade->use_function) @@ -568,7 +568,7 @@ fz_paint_shade(fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) *d++ = a; } fz_paint_pixmap(dest, conv, 255); - fz_drop_pixmap(conv); - fz_drop_pixmap(temp); + fz_drop_pixmap(ctx, conv); + fz_drop_pixmap(ctx, temp); } } diff --git a/draw/draw_path.c b/draw/draw_path.c index efa881ef..ca33f5f2 100644 --- a/draw/draw_path.c +++ b/draw/draw_path.c @@ -542,10 +542,7 @@ fz_flatten_stroke_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_m i = 0; if (path->len > 0 && path->items[0].k != FZ_MOVETO) - { - fz_warn("assert: path must begin with moveto"); return; - } p0.x = p0.y = 0; @@ -750,10 +747,7 @@ fz_flatten_dash_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_mat s.cap = stroke->start_cap; if (path->len > 0 && path->items[0].k != FZ_MOVETO) - { - fz_warn("assert: path must begin with moveto"); return; - } phase_len = 0; for (i = 0; i < stroke->dash_len; i++) diff --git a/draw/draw_scale.c b/draw/draw_scale.c index b7aa72f3..fd3c3798 100644 --- a/draw/draw_scale.c +++ b/draw/draw_scale.c @@ -271,7 +271,7 @@ struct fz_weights_s }; static fz_weights * -new_weights(fz_scale_filter *filter, int src_w, float dst_w, int dst_w_i, int n, int flip) +new_weights(fz_context *ctx, fz_scale_filter *filter, int src_w, float dst_w, int dst_w_i, int n, int flip) { int max_len; fz_weights *weights; @@ -297,7 +297,7 @@ new_weights(fz_scale_filter *filter, int src_w, float dst_w, int dst_w_i, int n, * plus (2+max_len)*sizeof(int) for the weights * plus room for an extra set of weights for reordering. */ - weights = fz_malloc(sizeof(*weights)+(max_len+3)*(dst_w_i+1)*sizeof(int)); + weights = fz_malloc(ctx, sizeof(*weights)+(max_len+3)*(dst_w_i+1)*sizeof(int)); if (weights == NULL) return NULL; weights->count = -1; @@ -505,7 +505,7 @@ check_weights(fz_weights *weights, int j, int w, float x, float wf) } static fz_weights * -make_weights(int src_w, float x, float dst_w, fz_scale_filter *filter, int vertical, int dst_w_int, int n, int flip) +make_weights(fz_context *ctx, int src_w, float x, float dst_w, fz_scale_filter *filter, int vertical, int dst_w_int, int n, int flip) { fz_weights *weights; float F, G; @@ -526,7 +526,7 @@ make_weights(int src_w, float x, float dst_w, fz_scale_filter *filter, int verti } window = filter->width / F; DBUG(("make_weights src_w=%d x=%g dst_w=%g dst_w_int=%d F=%g window=%g\n", src_w, x, dst_w, dst_w_int, F, window)); - weights = new_weights(filter, src_w, dst_w, dst_w_int, n, flip); + weights = new_weights(ctx, filter, src_w, dst_w, dst_w_int, n, flip); if (weights == NULL) return NULL; for (j = 0; j < dst_w_int; j++) @@ -1206,8 +1206,9 @@ scale_single_col(unsigned char *dst, unsigned char *src, fz_weights *weights, in } #endif /* SINGLE_PIXEL_SPECIALS */ + fz_pixmap * -fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) +fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h) { fz_scale_filter *filter = &fz_scale_filter_simple; fz_weights *contrib_rows = NULL; @@ -1289,7 +1290,7 @@ fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) else #endif /* SINGLE_PIXEL_SPECIALS */ { - contrib_cols = make_weights(src->w, x, w, filter, 0, dst_w_int, src->n, flip_x); + contrib_cols = make_weights(ctx, src->w, x, w, filter, 0, dst_w_int, src->n, flip_x); if (contrib_cols == NULL) goto cleanup; } @@ -1301,14 +1302,14 @@ fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) else #endif /* SINGLE_PIXEL_SPECIALS */ { - contrib_rows = make_weights(src->h, y, h, filter, 1, dst_h_int, src->n, flip_y); + contrib_rows = make_weights(ctx, src->h, y, h, filter, 1, dst_h_int, src->n, flip_y); if (contrib_rows == NULL) goto cleanup; } assert(contrib_cols == NULL || contrib_cols->count == dst_w_int); assert(contrib_rows == NULL || contrib_rows->count == dst_h_int); - output = fz_new_pixmap(src->colorspace, dst_w_int, dst_h_int); + output = fz_new_pixmap(ctx, src->colorspace, dst_w_int, dst_h_int); output->x = dst_x_int; output->y = dst_y_int; @@ -1342,7 +1343,7 @@ fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) temp_rows = contrib_rows->max_len; if (temp_span <= 0 || temp_rows > INT_MAX / temp_span) goto cleanup; - temp = fz_calloc(temp_span*temp_rows, sizeof(int)); + temp = fz_malloc_array(ctx, temp_span*temp_rows, sizeof(int)); if (temp == NULL) goto cleanup; switch (src->n) @@ -1383,11 +1384,11 @@ fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) DBUG(("scaling row %d from temp\n", row)); scale_row_from_temp(&output->samples[row*output->w*output->n], temp, contrib_rows, temp_span, row); } - fz_free(temp); + fz_free(ctx, temp); } cleanup: - fz_free(contrib_rows); - fz_free(contrib_cols); + fz_free(ctx, contrib_rows); + fz_free(ctx, contrib_cols); return output; } diff --git a/draw/draw_simple_scale.c b/draw/draw_simple_scale.c index c2d429b1..dcd5cd68 100644 --- a/draw/draw_simple_scale.c +++ b/draw/draw_simple_scale.c @@ -227,7 +227,7 @@ struct fz_weights_s }; static fz_weights * -new_weights(fz_scale_filter *filter, int src_w, float dst_w, int dst_w_i, int n, int flip) +new_weights(fz_context *ctx, fz_scale_filter *filter, int src_w, float dst_w, int dst_w_i, int n, int flip) { int max_len; fz_weights *weights; @@ -253,7 +253,7 @@ new_weights(fz_scale_filter *filter, int src_w, float dst_w, int dst_w_i, int n, * plus (2+max_len)*sizeof(int) for the weights * plus room for an extra set of weights for reordering. */ - weights = fz_malloc(sizeof(*weights)+(max_len+3)*(dst_w_i+1)*sizeof(int)); + weights = fz_malloc(ctx, sizeof(*weights)+(max_len+3)*(dst_w_i+1)*sizeof(int)); if (weights == NULL) return NULL; weights->count = -1; @@ -443,7 +443,7 @@ check_weights(fz_weights *weights, int j, int w, float x, float wf) } static fz_weights * -make_weights(int src_w, float x, float dst_w, fz_scale_filter *filter, int vertical, int dst_w_int, int n, int flip) +make_weights(fz_context *ctx, int src_w, float x, float dst_w, fz_scale_filter *filter, int vertical, int dst_w_int, int n, int flip) { fz_weights *weights; float F, G; @@ -464,7 +464,7 @@ make_weights(int src_w, float x, float dst_w, fz_scale_filter *filter, int verti } window = filter->width / F; DBUG(("make_weights src_w=%d x=%g dst_w=%g dst_w_int=%d F=%g window=%g\n", src_w, x, dst_w, dst_w_int, F, window)); - weights = new_weights(filter, src_w, dst_w, dst_w_int, n, flip); + weights = new_weights(ctx, filter, src_w, dst_w, dst_w_int, n, flip); if (weights == NULL) return NULL; for (j = 0; j < dst_w_int; j++) @@ -1167,7 +1167,7 @@ scale_single_col(unsigned char *dst, unsigned char *src, fz_weights *weights, in #endif /* SINGLE_PIXEL_SPECIALS */ fz_pixmap * -fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) +fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h) { fz_scale_filter *filter = &fz_scale_filter_simple; fz_weights *contrib_rows = NULL; @@ -1249,7 +1249,7 @@ fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) else #endif /* SINGLE_PIXEL_SPECIALS */ { - contrib_cols = make_weights(src->w, x, w, filter, 0, dst_w_int, src->n, flip_x); + contrib_cols = make_weights(ctx, src->w, x, w, filter, 0, dst_w_int, src->n, flip_x); if (contrib_cols == NULL) goto cleanup; } @@ -1261,14 +1261,14 @@ fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) else #endif /* SINGLE_PIXEL_SPECIALS */ { - contrib_rows = make_weights(src->h, y, h, filter, 1, dst_h_int, src->n, flip_y); + contrib_rows = make_weights(ctx, src->h, y, h, filter, 1, dst_h_int, src->n, flip_y); if (contrib_rows == NULL) goto cleanup; } assert(contrib_cols == NULL || contrib_cols->count == dst_w_int); assert(contrib_rows == NULL || contrib_rows->count == dst_h_int); - output = fz_new_pixmap(src->colorspace, dst_w_int, dst_h_int); + output = fz_new_pixmap(ctx, src->colorspace, dst_w_int, dst_h_int); output->x = dst_x_int; output->y = dst_y_int; @@ -1302,7 +1302,7 @@ fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) temp_rows = contrib_rows->max_len; if (temp_span <= 0 || temp_rows > INT_MAX / temp_span) goto cleanup; - temp = fz_calloc(temp_span*temp_rows, sizeof(unsigned char)); + temp = fz_calloc(ctx, temp_span*temp_rows, sizeof(unsigned char)); if (temp == NULL) goto cleanup; switch (src->n) @@ -1343,11 +1343,11 @@ fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) DBUG(("scaling row %d from temp\n", row)); scale_row_from_temp(&output->samples[row*output->w*output->n], temp, contrib_rows, temp_span, row); } - fz_free(temp); + fz_free(ctx, temp); } cleanup: - fz_free(contrib_rows); - fz_free(contrib_cols); + fz_free(ctx, contrib_rows); + fz_free(ctx, contrib_cols); return output; } |