/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */

/* cairo - a vector graphics library with display and print output

 *

 * Copyright © 2003 University of Southern California

 * Copyright © 2009,2010,2011 Intel Corporation

 *

 * This library is free software; you can redistribute it and/or

 * modify it either under the terms of the GNU Lesser General Public

 * License version 2.1 as published by the Free Software Foundation

 * (the "LGPL") or, at your option, under the terms of the Mozilla

 * Public License Version 1.1 (the "MPL"). If you do not alter this

 * notice, a recipient may use your version of this file under either

 * the MPL or the LGPL.

 *

 * You should have received a copy of the LGPL along with this library

 * in the file COPYING-LGPL-2.1; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA

 * You should have received a copy of the MPL along with this library

 * in the file COPYING-MPL-1.1

 *

 * The contents of this file are subject to the Mozilla Public License

 * Version 1.1 (the "License"); you may not use this file except in

 * compliance with the License. You may obtain a copy of the License at

 * http://www.mozilla.org/MPL/

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY

 * OF ANY KIND, either express or implied. See the LGPL or the MPL for

 * the specific language governing rights and limitations.

 *

 * The Original Code is the cairo graphics library.

 *

 * The Initial Developer of the Original Code is University of Southern

 * California.

 *

 * Contributor(s):

 *	Carl D. Worth <cworth@cworth.org>

 *	Chris Wilson <chris@chris-wilson.co.uk>

 */

/* The primarily reason for keeping a traps-compositor around is

 * for validating cairo-xlib (which currently also uses traps).

 */

#include "cairoint.h"

#include "cairo-image-surface-private.h"

#include "cairo-compositor-private.h"

#include "cairo-spans-compositor-private.h"

#include "cairo-region-private.h"

#include "cairo-traps-private.h"

#include "cairo-tristrip-private.h"

#include "cairo-pixman-private.h"

static pixman_image_t *

{

}

static cairo_int_status_t

{

}

static cairo_int_status_t

{

}

static cairo_int_status_t

		 cairo_region_t *region)

{

}

static cairo_int_status_t

		  cairo_image_surface_t *image,

		  cairo_boxes_t *boxes,

		  int dx, int dy)

{

    struct _cairo_boxes_chunk *chunk;

    int i;

    TRACE ((stderr, "%s x %d\n", __FUNCTION__, boxes->num_boxes));

			      x + dx, y + dy,

			      x, y,

			      w, h))

	    {

					  image->pixman_image, NULL, dst->pixman_image,

					  x + dx, y + dy,

					  0, 0,

					  x, y,

					  w, h);

	    }

	}

    }

}

static inline uint32_t

{

    return

}

static inline cairo_bool_t

                pixman_format_code_t	 format,

                uint32_t		*pixel)

{

    uint32_t c;

          format == PIXMAN_b5g6r5       ||

          format == PIXMAN_a8))

    {

    }

    }

    }

    }

}

static pixman_op_t

{

	return PIXMAN_OP_OVER;

    }

}

static cairo_bool_t

			  const cairo_color_t *color,

			  const cairo_image_surface_t *dst)

{

}

static cairo_bool_t

			const cairo_color_t *color,

			const cairo_image_surface_t *dst,

			uint32_t *pixel)

{

    }

}

static cairo_int_status_t

		 cairo_operator_t	 op,

		 const cairo_color_t	*color,

		 cairo_rectangle_int_t	*rects,

		 int			 num_rects)

{

    uint32_t pixel;

    int i;

    TRACE ((stderr, "%s\n", __FUNCTION__));

			 pixel);

	}

    } else {

				      src, NULL, dst->pixman_image,

				      0, 0,

				      0, 0,

	}

    }

}

static cairo_int_status_t

	    cairo_operator_t	 op,

	    const cairo_color_t	*color,

	    cairo_boxes_t	*boxes)

{

    struct _cairo_boxes_chunk *chunk;

    uint32_t pixel;

    int i;

    TRACE ((stderr, "%s x %d\n", __FUNCTION__, boxes->num_boxes));

			     x, y, w, h, pixel);

	    }

	}

    }

    else

    {

					  src, NULL, dst->pixman_image,

					  0, 0,

					  0, 0,

					  x1, y1,

					  x2-x1, y2-y1);

	    }

	}

    }

}

static cairo_int_status_t

	   cairo_operator_t	op,

	   cairo_surface_t	*abstract_src,

	   cairo_surface_t	*abstract_mask,

	   int			src_x,

	   int			src_y,

	   int			mask_x,

	   int			mask_y,

	   int			dst_x,

	   int			dst_y,

	   unsigned int		width,

	   unsigned int		height)

{

    TRACE ((stderr, "%s\n", __FUNCTION__));

				  src->pixman_image, mask->pixman_image, to_pixman_image (_dst),

				  src_x, src_y,

				  mask_x, mask_y,

				  dst_x, dst_y,

				  width, height);

    } else {

				  src->pixman_image, NULL, to_pixman_image (_dst),

				  src_x, src_y,

				  0, 0,

				  dst_x, dst_y,

				  width, height);

    }

}

static cairo_int_status_t

      cairo_surface_t		*abstract_src,

      cairo_surface_t		*abstract_mask,

      int			src_x,

      int			src_y,

      int			mask_x,

      int			mask_y,

      int			dst_x,

      int			dst_y,

      unsigned int		width,

      unsigned int		height)

{

    TRACE ((stderr, "%s\n", __FUNCTION__));

#if PIXMAN_HAS_OP_LERP

    pixman_image_composite32 (PIXMAN_OP_LERP_SRC,

			      src->pixman_image, mask->pixman_image, dst->pixman_image,

			      src_x,  src_y,

			      mask_x, mask_y,

			      dst_x,  dst_y,

			      width,  height);

#else

    /* Punch the clip out of the destination */

    TRACE ((stderr, "%s - OUT_REVERSE (mask=%d/%p, dst=%d/%p)\n",

	    __FUNCTION__,

	    mask->base.unique_id, mask->pixman_image,

	    dst->base.unique_id, dst->pixman_image));

			      mask->pixman_image, NULL, dst->pixman_image,

			      mask_x, mask_y,

			      0,      0,

			      dst_x,  dst_y,

			      width,  height);

    /* Now add the two results together */

    TRACE ((stderr, "%s - ADD (src=%d/%p, mask=%d/%p, dst=%d/%p)\n",

	    __FUNCTION__,

	    src->base.unique_id, src->pixman_image,

	    mask->base.unique_id, mask->pixman_image,

	    dst->base.unique_id, dst->pixman_image));

			      src->pixman_image, mask->pixman_image, dst->pixman_image,

			      src_x,  src_y,

			      mask_x, mask_y,

			      dst_x,  dst_y,

			      width,  height);

#endif

}

static cairo_int_status_t

		 cairo_operator_t	op,

		 cairo_surface_t	*abstract_src,

		 cairo_surface_t	*abstract_mask,

		 int			src_x,

		 int			src_y,

		 int			mask_x,

		 int			mask_y,

		 int			dst_x,

		 int			dst_y,

		 cairo_boxes_t		*boxes,

		 const cairo_rectangle_int_t  *extents)

{

    struct _cairo_boxes_chunk *chunk;

    int i;

    /* XXX consider using a region? saves multiple prepare-composite */

    TRACE ((stderr, "%s x %d\n", __FUNCTION__, boxes->num_boxes));

	 op == CAIRO_OPERATOR_ADD)) {

#if PIXMAN_HAS_OP_LERP

	    op = PIXMAN_OP_LERP_CLEAR;

#else

#endif

#if PIXMAN_HAS_OP_LERP

	    op = PIXMAN_OP_LERP_SRC;

#else

#endif

	} else {

	}

    } else {

    }

				      x1 + src_x, y1 + src_y,

				      x1 + mask_x, y1 + mask_y,

				      x1 + dst_x, y1 + dst_y,

				      x2 - x1, y2 - y1);

	}

    }

}

#define CAIRO_FIXED_16_16_MIN _cairo_fixed_from_int (-32768)

#define CAIRO_FIXED_16_16_MAX _cairo_fixed_from_int (32767)

static cairo_bool_t

{

    return

}

static void

			   cairo_fixed_t top,

			   cairo_fixed_t bottom,

			   pixman_line_fixed_t *out)

{

    /* XXX use fixed-point arithmetic? */

    cairo_point_double_t p1, p2;

    double m;

void

			 int dst_x, int dst_y,

			 cairo_traps_t *traps)

{

	pixman_trapezoid_t trap;

	/* top/bottom will be clamped to surface bounds */

	/* However, all the other coordinates will have been left untouched so

	 * as not to introduce numerical error. Recompute them if they

	 * exceed the 16.16 limits.

	 */

	} else {

	}

	} else {

	}

    }

static cairo_int_status_t

		 cairo_operator_t	op,

		 cairo_surface_t	*abstract_src,

		 int			src_x,

		 int			src_y,

		 int			dst_x,

		 int			dst_y,

		 const cairo_rectangle_int_t *extents,

		 cairo_antialias_t	antialias,

		 cairo_traps_t		*traps)

{

    cairo_int_status_t status;

    pixman_image_t *mask;

    pixman_format_code_t format;

    TRACE ((stderr, "%s\n", __FUNCTION__));

    /* pixman doesn't eliminate self-intersecting trapezoids/edges */

						      CAIRO_FILL_RULE_WINDING);

    /* Special case adding trapezoids onto a mask surface; we want to avoid

     * creating an intermediate temporary mask unnecessarily.

     *

     * We make the assumption here that the portion of the trapezoids

     * contained within the surface is bounded by [dst_x,dst_y,width,height];

     * the Cairo core code passes bounds based on the trapezoid extents.

     */

    {

    }

				     NULL, 0);

                              src->pixman_image, mask, dst->pixman_image,

                              0, 0,

}

static void

{

void

			    int dst_x, int dst_y,

			    cairo_tristrip_t *strip)

{

    pixman_triangle_t tri;

    int n;

    }

static cairo_int_status_t

		    cairo_operator_t	op,

		    cairo_surface_t	*abstract_src,

		    int			src_x,

		    int			src_y,

		    int			dst_x,

		    int			dst_y,

		    const cairo_rectangle_int_t *extents,

		    cairo_antialias_t	antialias,

		    cairo_tristrip_t	*strip)

{

    pixman_image_t *mask;

    pixman_format_code_t format;

    TRACE ((stderr, "%s\n", __FUNCTION__));

    if (1) { /* pixman doesn't eliminate self-intersecting triangles/edges */

	    cairo_int_status_t status;

	    cairo_traps_t traps;

	    int n;

		    cairo_point_t p[4];

	    }

				      src_x, src_y,

				      dst_x, dst_y,

				      extents, antialias, &traps);

    }

    format = antialias == CAIRO_ANTIALIAS_NONE ? PIXMAN_a1 : PIXMAN_a8;

    if (dst->pixman_format == format &&

	(abstract_src == NULL ||

	 (op == CAIRO_OPERATOR_ADD && src->is_opaque_solid)))

    {

	_pixman_image_add_tristrip (dst->pixman_image, dst_x, dst_y, strip);

	return CAIRO_STATUS_SUCCESS;

    }

    mask = pixman_image_create_bits (format,

				     extents->width, extents->height,

				     NULL, 0);

    if (unlikely (mask == NULL))

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    _pixman_image_add_tristrip (mask, extents->x, extents->y, strip);

    pixman_image_composite32 (_pixman_operator (op),

                              src->pixman_image, mask, dst->pixman_image,

                              extents->x + src_x, extents->y + src_y,

                              0, 0,

                              extents->x - dst_x, extents->y - dst_y,

                              extents->width, extents->height);

    pixman_image_unref (mask);

    return  CAIRO_STATUS_SUCCESS;

}

static cairo_int_status_t

			cairo_scaled_font_t *scaled_font,

			cairo_glyph_t *glyphs,

			int *num_glyphs)

{

}

#if HAS_PIXMAN_GLYPHS

static pixman_glyph_cache_t *global_glyph_cache;

static inline pixman_glyph_cache_t *

{

}

void

{

void

				cairo_scaled_glyph_t *scaled_glyph)

{

	    global_glyph_cache, scaled_font,

    }

#define PHASE(x) ((int)(floor (4 * (x + 0.125)) - 4 * floor (x + 0.125)))

#define POSITION(x) ((int) floor (x + 0.125))

static cairo_int_status_t

		  cairo_operator_t		 op,

		  cairo_surface_t		*_src,

		  int				 src_x,

		  int				 src_y,

		  int				 dst_x,

		  int				 dst_y,

		  cairo_composite_glyphs_info_t *info)

{

    pixman_glyph_cache_t *glyph_cache;

    pixman_glyph_t pglyphs_stack[CAIRO_STACK_ARRAY_LENGTH (pixman_glyph_t)];

    pixman_glyph_t *pg;

    int i;

    TRACE ((stderr, "%s\n", __FUNCTION__));

    }

	}

    }

	const void *glyph;

        unsigned long xphase, yphase;

	    cairo_scaled_glyph_t *scaled_glyph;

	    cairo_image_surface_t *glyph_surface;

	    /* This call can actually end up recursing, so we have to

	     * drop the mutex around it.

	     */

						 CAIRO_SCALED_GLYPH_INFO_SURFACE,

						 NULL, /* foreground color */

						 &scaled_glyph);

					       glyph_surface->pixman_image);

	    }

	}

    }

	pixman_format_code_t mask_format;

				 ((cairo_image_source_t *)_src)->pixman_image,

				 to_pixman_image (_dst),

				 mask_format,

				 info->extents.x, info->extents.y,

				 info->extents.width, info->extents.height,

    } else {

					 ((cairo_image_source_t *)_src)->pixman_image,

					 to_pixman_image (_dst),

					 src_x, src_y,

					 - dst_x, - dst_y,

    }

}

#else

void

_cairo_image_compositor_reset_static_data (void)

{

}

void

_cairo_image_scaled_glyph_fini (cairo_scaled_font_t *scaled_font,

				cairo_scaled_glyph_t *scaled_glyph)

{

}

static cairo_int_status_t

composite_one_glyph (void				*_dst,

		     cairo_operator_t			 op,

		     cairo_surface_t			*_src,

		     int				 src_x,

		     int				 src_y,

		     int				 dst_x,

		     int				 dst_y,

		     cairo_composite_glyphs_info_t	 *info)

{

    cairo_image_surface_t *glyph_surface;

    cairo_scaled_glyph_t *scaled_glyph;

    cairo_status_t status;

    int x, y;

    TRACE ((stderr, "%s\n", __FUNCTION__));

    status = _cairo_scaled_glyph_lookup (info->font,

					 info->glyphs[0].index,

					 CAIRO_SCALED_GLYPH_INFO_SURFACE,

					 NULL, /* foreground color */

					 &scaled_glyph);

    if (unlikely (status))

	return status;

    glyph_surface = scaled_glyph->surface;

    if (glyph_surface->width == 0 || glyph_surface->height == 0)

	return CAIRO_INT_STATUS_NOTHING_TO_DO;

    /* round glyph locations to the nearest pixel */

    /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */

    x = _cairo_lround (info->glyphs[0].x -

		       glyph_surface->base.device_transform.x0);

    y = _cairo_lround (info->glyphs[0].y -

		       glyph_surface->base.device_transform.y0);

    pixman_image_composite32 (_pixman_operator (op),

			      ((cairo_image_source_t *)_src)->pixman_image,

			      glyph_surface->pixman_image,

			      to_pixman_image (_dst),

			      x + src_x,  y + src_y,

			      0, 0,

			      x - dst_x, y - dst_y,

			      glyph_surface->width,

			      glyph_surface->height);

    return CAIRO_INT_STATUS_SUCCESS;

}

static cairo_int_status_t

composite_glyphs_via_mask (void				*_dst,

			   cairo_operator_t		 op,

			   cairo_surface_t		*_src,

			   int				 src_x,

			   int				 src_y,

			   int				 dst_x,

			   int				 dst_y,

			   cairo_composite_glyphs_info_t *info)

{

    cairo_scaled_glyph_t *glyph_cache[64];

    pixman_image_t *white = _pixman_image_for_color (CAIRO_COLOR_WHITE);

    cairo_scaled_glyph_t *scaled_glyph;

    uint8_t buf[2048];

    pixman_image_t *mask;

    pixman_format_code_t format;

    cairo_status_t status;

    int i;

    TRACE ((stderr, "%s\n", __FUNCTION__));

    if (unlikely (white == NULL))

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    /* XXX convert the glyphs to common formats a8/a8r8g8b8 to hit

     * optimised paths through pixman. Should we increase the bit

     * depth of the target surface, we should reconsider the appropriate

     * mask formats.

     */

    status = _cairo_scaled_glyph_lookup (info->font,

					 info->glyphs[0].index,

					 CAIRO_SCALED_GLYPH_INFO_SURFACE,

					 NULL, /* foreground color */

					 &scaled_glyph);

    if (unlikely (status)) {

	pixman_image_unref (white);

	return status;

    }

    memset (glyph_cache, 0, sizeof (glyph_cache));

    glyph_cache[info->glyphs[0].index % ARRAY_LENGTH (glyph_cache)] = scaled_glyph;

    format = PIXMAN_a8;

    i = (info->extents.width + 3) & ~3;

    if (scaled_glyph->surface->base.content & CAIRO_CONTENT_COLOR) {

	format = PIXMAN_a8r8g8b8;

	i = info->extents.width * 4;

    }

    if (i * info->extents.height > (int) sizeof (buf)) {

	mask = pixman_image_create_bits (format,

					info->extents.width,

					info->extents.height,

					NULL, 0);

    } else {

	memset (buf, 0, i * info->extents.height);

	mask = pixman_image_create_bits (format,

					info->extents.width,

					info->extents.height,

					(uint32_t *)buf, i);

    }

    if (unlikely (mask == NULL)) {

	pixman_image_unref (white);

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    }

    status = CAIRO_STATUS_SUCCESS;

    for (i = 0; i < info->num_glyphs; i++) {

	unsigned long glyph_index = info->glyphs[i].index;

	int cache_index = glyph_index % ARRAY_LENGTH (glyph_cache);

	cairo_image_surface_t *glyph_surface;

	int x, y;

	scaled_glyph = glyph_cache[cache_index];

	if (scaled_glyph == NULL ||

	    _cairo_scaled_glyph_index (scaled_glyph) != glyph_index)

	{

	    status = _cairo_scaled_glyph_lookup (info->font, glyph_index,

						 CAIRO_SCALED_GLYPH_INFO_SURFACE,

						 NULL, /* foreground color */

						 &scaled_glyph);

	    if (unlikely (status)) {

		pixman_image_unref (mask);

		pixman_image_unref (white);

		return status;

	    }

	    glyph_cache[cache_index] = scaled_glyph;

	}

	glyph_surface = scaled_glyph->surface;

	if (glyph_surface->width && glyph_surface->height) {

	    if (glyph_surface->base.content & CAIRO_CONTENT_COLOR &&

		format == PIXMAN_a8) {

		pixman_image_t *ca_mask;

		format = PIXMAN_a8r8g8b8;

		ca_mask = pixman_image_create_bits (format,

						    info->extents.width,

						    info->extents.height,

						    NULL, 0);

		if (unlikely (ca_mask == NULL)) {

		    pixman_image_unref (mask);

		    pixman_image_unref (white);

		    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

		}

		pixman_image_composite32 (PIXMAN_OP_SRC,

					  white, mask, ca_mask,

					  0, 0,

					  0, 0,

					  0, 0,

					  info->extents.width,

					  info->extents.height);

		pixman_image_unref (mask);

		mask = ca_mask;

	    }

	    /* round glyph locations to the nearest pixel */

	    /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */

	    x = _cairo_lround (info->glyphs[i].x -

			       glyph_surface->base.device_transform.x0);

	    y = _cairo_lround (info->glyphs[i].y -

			       glyph_surface->base.device_transform.y0);

	    if (glyph_surface->pixman_format == format) {

		pixman_image_composite32 (PIXMAN_OP_ADD,

					  glyph_surface->pixman_image, NULL, mask,

					  0, 0,

					  0, 0,

					  x - info->extents.x, y - info->extents.y,

					  glyph_surface->width,

					  glyph_surface->height);

	    } else {

		pixman_image_composite32 (PIXMAN_OP_ADD,

					  white, glyph_surface->pixman_image, mask,

					  0, 0,

					  0, 0,

					  x - info->extents.x, y - info->extents.y,

					  glyph_surface->width,

					  glyph_surface->height);

	    }

	}

    }

    if (format == PIXMAN_a8r8g8b8)

	pixman_image_set_component_alpha (mask, TRUE);

    pixman_image_composite32 (_pixman_operator (op),

			      ((cairo_image_source_t *)_src)->pixman_image,

			      mask,

			      to_pixman_image (_dst),

			      info->extents.x + src_x, info->extents.y + src_y,

			      0, 0,

			      info->extents.x - dst_x, info->extents.y - dst_y,

			      info->extents.width, info->extents.height);

    pixman_image_unref (mask);

    pixman_image_unref (white);

    return CAIRO_STATUS_SUCCESS;

}

static cairo_int_status_t

composite_glyphs (void				*_dst,

		  cairo_operator_t		 op,

		  cairo_surface_t		*_src,

		  int				 src_x,

		  int				 src_y,

		  int				 dst_x,

		  int				 dst_y,

		  cairo_composite_glyphs_info_t *info)

{

    cairo_scaled_glyph_t *glyph_cache[64];

    pixman_image_t *dst, *src;

    cairo_status_t status;

    int i;

    TRACE ((stderr, "%s\n", __FUNCTION__));

    if (info->num_glyphs == 1)

	return composite_one_glyph(_dst, op, _src, src_x, src_y, dst_x, dst_y, info);

    if (info->use_mask)

	return composite_glyphs_via_mask(_dst, op, _src, src_x, src_y, dst_x, dst_y, info);

    op = _pixman_operator (op);

    dst = to_pixman_image (_dst);

    src = ((cairo_image_source_t *)_src)->pixman_image;

    memset (glyph_cache, 0, sizeof (glyph_cache));

    status = CAIRO_STATUS_SUCCESS;

    for (i = 0; i < info->num_glyphs; i++) {

	int x, y;

	cairo_image_surface_t *glyph_surface;

	cairo_scaled_glyph_t *scaled_glyph;

	unsigned long glyph_index = info->glyphs[i].index;

	int cache_index = glyph_index % ARRAY_LENGTH (glyph_cache);

	scaled_glyph = glyph_cache[cache_index];

	if (scaled_glyph == NULL ||

	    _cairo_scaled_glyph_index (scaled_glyph) != glyph_index)

	{

	    status = _cairo_scaled_glyph_lookup (info->font, glyph_index,

						 CAIRO_SCALED_GLYPH_INFO_SURFACE,

						 NULL, /* foreground color */

						 &scaled_glyph);

	    if (unlikely (status))

		break;

	    glyph_cache[cache_index] = scaled_glyph;

	}

	glyph_surface = scaled_glyph->surface;

	if (glyph_surface->width && glyph_surface->height) {

	    /* round glyph locations to the nearest pixel */

	    /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */

	    x = _cairo_lround (info->glyphs[i].x -

			       glyph_surface->base.device_transform.x0);

	    y = _cairo_lround (info->glyphs[i].y -

			       glyph_surface->base.device_transform.y0);

	    pixman_image_composite32 (op, src, glyph_surface->pixman_image, dst,

                                      x + src_x,  y + src_y,

                                      0, 0,

                                      x - dst_x, y - dst_y,

				      glyph_surface->width,

				      glyph_surface->height);

	}

    }

    return status;

}

#endif

static cairo_int_status_t

{

}

const cairo_compositor_t *

{

    static cairo_atomic_once_t once = CAIRO_ATOMIC_ONCE_INIT;

    static cairo_traps_compositor_t compositor;

				     &__cairo_no_compositor);

	//compositor.copy_boxes = copy_boxes;

	//compositor.check_composite_boxes = check_composite_boxes;

	//compositor.check_composite_traps = check_composite_traps;

	//compositor.check_composite_tristrip = check_composite_traps;

	_cairo_atomic_init_once_leave(&once);

    }

}

const cairo_compositor_t *

{

    static cairo_atomic_once_t once = CAIRO_ATOMIC_ONCE_INIT;

    static cairo_mask_compositor_t compositor;

				     _cairo_image_traps_compositor_get ());

	//compositor.lerp = lerp;

	//compositor.check_composite_boxes = check_composite_boxes;

	_cairo_atomic_init_once_leave(&once);

    }