From f84a189d5f94250e46d2cbd1a75aba00130e2dd6 Mon Sep 17 00:00:00 2001 From: Tor Andersson Date: Wed, 21 Jan 2015 16:42:45 +0100 Subject: Add ctx parameter and remove embedded contexts for API regularity. Purge several embedded contexts: Remove embedded context in fz_output. Remove embedded context in fz_stream. Remove embedded context in fz_device. Remove fz_rebind_stream (since it is no longer necessary). Remove embedded context in svg_device. Remove embedded context in XML parser. Add ctx argument to fz_document functions. Remove embedded context in fz_document. Remove embedded context in pdf_document. Remove embedded context in pdf_obj. Make fz_page independent of fz_document in the interface. We shouldn't need to pass the document to all functions handling a page. If a page is tied to the source document, it's redundant; otherwise it's just pointless. Fix reference counting oddity in fz_new_image_from_pixmap. --- source/fitz/shade.c | 207 +++++++++++++++++++++++++++------------------------- 1 file changed, 108 insertions(+), 99 deletions(-) (limited to 'source/fitz/shade.c') diff --git a/source/fitz/shade.c b/source/fitz/shade.c index 01ada9a4..f5e25639 100644 --- a/source/fitz/shade.c +++ b/source/fitz/shade.c @@ -1,18 +1,28 @@ #include "mupdf/fitz.h" +typedef struct fz_mesh_processor_s fz_mesh_processor; + +struct fz_mesh_processor_s { + fz_shade *shade; + fz_mesh_prepare_fn *prepare; + fz_mesh_process_fn *process; + void *process_arg; + int ncomp; +}; + #define SWAP(a,b) {fz_vertex *t = (a); (a) = (b); (b) = t;} static inline void -paint_tri(fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex *v2) +paint_tri(fz_context *ctx, fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex *v2) { if (painter->process) { - painter->process(painter->process_arg, v0, v1, v2); + painter->process(ctx, painter->process_arg, v0, v1, v2); } } static inline void -paint_quad(fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex *v2, fz_vertex *v3) +paint_quad(fz_context *ctx, fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex *v2, fz_vertex *v3) { /* For a quad with corners (in clockwise or anticlockwise order) are * v0, v1, v2, v3. We can choose to split in in various different ways. @@ -35,27 +45,27 @@ paint_quad(fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex * */ if (painter->process) { - painter->process(painter->process_arg, v0, v1, v3); - painter->process(painter->process_arg, v3, v2, v1); + painter->process(ctx, painter->process_arg, v0, v1, v3); + painter->process(ctx, painter->process_arg, v3, v2, v1); } } static inline void -fz_prepare_color(fz_mesh_processor *painter, fz_vertex *v, float *c) +fz_prepare_color(fz_context *ctx, fz_mesh_processor *painter, fz_vertex *v, float *c) { if (painter->prepare) { - painter->prepare(painter->process_arg, v, c); + painter->prepare(ctx, painter->process_arg, v, c); } } static inline void -fz_prepare_vertex(fz_mesh_processor *painter, fz_vertex *v, const fz_matrix *ctm, float x, float y, float *c) +fz_prepare_vertex(fz_context *ctx, fz_mesh_processor *painter, fz_vertex *v, const fz_matrix *ctm, float x, float y, float *c) { fz_transform_point_xy(&v->p, ctm, x, y); if (painter->prepare) { - painter->prepare(painter->process_arg, v, c); + painter->prepare(ctx, painter->process_arg, v, c); } } @@ -86,19 +96,19 @@ fz_process_mesh_type1(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz x = x0; - fz_prepare_vertex(painter, &v[0], &local_ctm, x, y, p); + fz_prepare_vertex(ctx, painter, &v[0], &local_ctm, x, y, p); p += n; - fz_prepare_vertex(painter, &v[1], &local_ctm, x, yn, p + xdivs * n); + fz_prepare_vertex(ctx, painter, &v[1], &local_ctm, x, yn, p + xdivs * n); for (xx = 0; xx < xdivs; xx++) { x = x0 + (x1 - x0) * (xx + 1) / xdivs; - fz_prepare_vertex(painter, &vn[0], &local_ctm, x, y, p); + fz_prepare_vertex(ctx, painter, &vn[0], &local_ctm, x, y, p); p += n; - fz_prepare_vertex(painter, &vn[1], &local_ctm, x, yn, p + xdivs * n); + fz_prepare_vertex(ctx, painter, &vn[1], &local_ctm, x, yn, p + xdivs * n); - paint_quad(painter, &v[0], &vn[0], &vn[1], &v[1]); + paint_quad(ctx, painter, &v[0], &vn[0], &vn[1], &v[1]); SWAP(v,vn); } y = yn; @@ -142,42 +152,42 @@ fz_process_mesh_type2(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz v2.p = fz_point_on_circle(p0, -HUGENUM, theta); v3.p = fz_point_on_circle(p1, -HUGENUM, theta); - fz_prepare_color(painter, &v0, &zero); - fz_prepare_color(painter, &v1, &one); - fz_prepare_color(painter, &v2, &zero); - fz_prepare_color(painter, &v3, &one); + fz_prepare_color(ctx, painter, &v0, &zero); + fz_prepare_color(ctx, painter, &v1, &one); + fz_prepare_color(ctx, painter, &v2, &zero); + fz_prepare_color(ctx, painter, &v3, &one); - paint_quad(painter, &v0, &v2, &v3, &v1); + paint_quad(ctx, painter, &v0, &v2, &v3, &v1); if (shade->u.l_or_r.extend[0]) { e0.p.x = v0.p.x - (p1.x - p0.x) * HUGENUM; e0.p.y = v0.p.y - (p1.y - p0.y) * HUGENUM; - fz_prepare_color(painter, &e0, &zero); + fz_prepare_color(ctx, painter, &e0, &zero); e1.p.x = v2.p.x - (p1.x - p0.x) * HUGENUM; e1.p.y = v2.p.y - (p1.y - p0.y) * HUGENUM; - fz_prepare_color(painter, &e1, &zero); + fz_prepare_color(ctx, painter, &e1, &zero); - paint_quad(painter, &e0, &v0, &v2, &e1); + paint_quad(ctx, painter, &e0, &v0, &v2, &e1); } if (shade->u.l_or_r.extend[1]) { e0.p.x = v1.p.x + (p1.x - p0.x) * HUGENUM; e0.p.y = v1.p.y + (p1.y - p0.y) * HUGENUM; - fz_prepare_color(painter, &e0, &one); + fz_prepare_color(ctx, painter, &e0, &one); e1.p.x = v3.p.x + (p1.x - p0.x) * HUGENUM; e1.p.y = v3.p.y + (p1.y - p0.y) * HUGENUM; - fz_prepare_color(painter, &e1, &one); + fz_prepare_color(ctx, painter, &e1, &one); - paint_quad(painter, &e0, &v1, &v3, &e1); + paint_quad(ctx, painter, &e0, &v1, &v3, &e1); } } static void -fz_paint_annulus(const fz_matrix *ctm, +fz_paint_annulus(fz_context *ctx, const fz_matrix *ctm, fz_point p0, float r0, float c0, fz_point p1, float r1, float c1, int count, @@ -213,17 +223,17 @@ fz_paint_annulus(const fz_matrix *ctm, fz_transform_point(&b2.p, ctm); fz_transform_point(&b3.p, ctm); - fz_prepare_color(painter, &t0, &c0); - fz_prepare_color(painter, &t1, &c0); - fz_prepare_color(painter, &t2, &c1); - fz_prepare_color(painter, &t3, &c1); - fz_prepare_color(painter, &b0, &c0); - fz_prepare_color(painter, &b1, &c0); - fz_prepare_color(painter, &b2, &c1); - fz_prepare_color(painter, &b3, &c1); + fz_prepare_color(ctx, painter, &t0, &c0); + fz_prepare_color(ctx, painter, &t1, &c0); + fz_prepare_color(ctx, painter, &t2, &c1); + fz_prepare_color(ctx, painter, &t3, &c1); + fz_prepare_color(ctx, painter, &b0, &c0); + fz_prepare_color(ctx, painter, &b1, &c0); + fz_prepare_color(ctx, painter, &b2, &c1); + fz_prepare_color(ctx, painter, &b3, &c1); - paint_quad(painter, &t0, &t2, &t3, &t1); - paint_quad(painter, &b0, &b2, &b3, &b1); + paint_quad(ctx, painter, &t0, &t2, &t3, &t1); + paint_quad(ctx, painter, &b0, &b2, &b3, &b1); a = b; } @@ -264,10 +274,10 @@ fz_process_mesh_type3(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz e.y = p0.y + (p1.y - p0.y) * rs; er = r0 + (r1 - r0) * rs; - fz_paint_annulus(ctm, e, er, 0, p0, r0, 0, count, painter); + fz_paint_annulus(ctx, ctm, e, er, 0, p0, r0, 0, count, painter); } - fz_paint_annulus(ctm, p0, r0, 0, p1, r1, 1, count, painter); + fz_paint_annulus(ctx, ctm, p0, r0, 0, p1, r1, 1, count, painter); if (shade->u.l_or_r.extend[1]) { @@ -280,15 +290,15 @@ fz_process_mesh_type3(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz e.y = p1.y + (p0.y - p1.y) * rs; er = r1 + (r0 - r1) * rs; - fz_paint_annulus(ctm, p1, r1, 1, e, er, 1, count, painter); + fz_paint_annulus(ctx, ctm, p1, r1, 1, e, er, 1, count, painter); } } -static inline float read_sample(fz_stream *stream, int bits, float min, float max) +static inline float read_sample(fz_context *ctx, fz_stream *stream, int bits, float min, float max) { /* we use pow(2,x) because (1<