xserver-multidpi/glamor/glamor_render.c

/*
 * Copyright © 2009 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 * Authors:
 *    Eric Anholt <eric@anholt.net>
 *
 */

/** @file glamor_render.c
 *
 * Render acceleration implementation
 */

#include "glamor_priv.h"

#ifdef RENDER
#include "mipict.h"
#include "fbpict.h"

//#include "glu3/glu3.h"

struct shader_key {
	enum shader_source source;
	enum shader_mask mask;
	enum shader_in in;
};

struct blendinfo {
	Bool dest_alpha;
	Bool source_alpha;
	GLenum source_blend;
	GLenum dest_blend;
};

static struct blendinfo composite_op_info[] = {
	[PictOpClear] = {0, 0, GL_ZERO, GL_ZERO},
	[PictOpSrc] = {0, 0, GL_ONE, GL_ZERO},
	[PictOpDst] = {0, 0, GL_ZERO, GL_ONE},
	[PictOpOver] = {0, 1, GL_ONE, GL_ONE_MINUS_SRC_ALPHA},
	[PictOpOverReverse] = {1, 0, GL_ONE_MINUS_DST_ALPHA, GL_ONE},
	[PictOpIn] = {1, 0, GL_DST_ALPHA, GL_ZERO},
	[PictOpInReverse] = {0, 1, GL_ZERO, GL_SRC_ALPHA},
	[PictOpOut] = {1, 0, GL_ONE_MINUS_DST_ALPHA, GL_ZERO},
	[PictOpOutReverse] = {0, 1, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA},
	[PictOpAtop] = {1, 1, GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA},
	[PictOpAtopReverse] = {1, 1, GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA},
	[PictOpXor] =
	    {1, 1, GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA},
	[PictOpAdd] = {0, 0, GL_ONE, GL_ONE},
};

static GLuint
glamor_create_composite_fs(glamor_gl_dispatch * dispatch,
			   struct shader_key *key)
{
	const char *source_solid_fetch =
	    GLAMOR_DEFAULT_PRECISION
	    "uniform vec4 source;\n"
	    "vec4 get_source()\n" "{\n" "	return source;\n" "}\n";
	const char *source_alpha_pixmap_fetch =
	    GLAMOR_DEFAULT_PRECISION
	    "varying vec2 source_texture;\n"
	    "uniform sampler2D source_sampler;\n"
	    "vec4 get_source()\n"
	    "{\n" "	return texture2D(source_sampler, source_texture);\n"
	    "}\n";
	const char *source_pixmap_fetch =
	    GLAMOR_DEFAULT_PRECISION "varying vec2 source_texture;\n"
	    "uniform sampler2D source_sampler;\n" "vec4 get_source()\n"
	    "{\n"
	    "       return vec4(texture2D(source_sampler, source_texture).rgb, 1);\n"
	    "}\n";
	const char *mask_solid_fetch =
	    GLAMOR_DEFAULT_PRECISION "uniform vec4 mask;\n"
	    "vec4 get_mask()\n" "{\n" "	return mask;\n" "}\n";
	const char *mask_alpha_pixmap_fetch =
	    GLAMOR_DEFAULT_PRECISION "varying vec2 mask_texture;\n"
	    "uniform sampler2D mask_sampler;\n" "vec4 get_mask()\n" "{\n"
	    "	return texture2D(mask_sampler, mask_texture);\n" "}\n";
	const char *mask_pixmap_fetch =
	    GLAMOR_DEFAULT_PRECISION "varying vec2 mask_texture;\n"
	    "uniform sampler2D mask_sampler;\n" "vec4 get_mask()\n" "{\n"
	    "       return vec4(texture2D(mask_sampler, mask_texture).rgb, 1);\n"
	    "}\n";
	const char *in_source_only =
	    GLAMOR_DEFAULT_PRECISION "void main()\n" "{\n"
	    "	gl_FragColor = get_source();\n" "}\n";
	const char *in_normal =
	    GLAMOR_DEFAULT_PRECISION "void main()\n" "{\n"
	    "	gl_FragColor = get_source() * get_mask().a;\n" "}\n";
	const char *in_ca_source =
	    GLAMOR_DEFAULT_PRECISION "void main()\n" "{\n"
	    "	gl_FragColor = get_source() * get_mask();\n" "}\n";
	const char *in_ca_alpha =
	    GLAMOR_DEFAULT_PRECISION "void main()\n" "{\n"
	    "	gl_FragColor = get_source().a * get_mask();\n" "}\n";
	char *source;
	const char *source_fetch;
	const char *mask_fetch = "";
	const char *in;
	GLuint prog;

	switch (key->source) {
	case SHADER_SOURCE_SOLID:
		source_fetch = source_solid_fetch;
		break;
	case SHADER_SOURCE_TEXTURE_ALPHA:
		source_fetch = source_alpha_pixmap_fetch;
		break;
	case SHADER_SOURCE_TEXTURE:
		source_fetch = source_pixmap_fetch;
		break;
	default:
		FatalError("Bad composite shader source");
	}

	switch (key->mask) {
	case SHADER_MASK_NONE:
		break;
	case SHADER_MASK_SOLID:
		mask_fetch = mask_solid_fetch;
		break;
	case SHADER_MASK_TEXTURE_ALPHA:
		mask_fetch = mask_alpha_pixmap_fetch;
		break;
	case SHADER_MASK_TEXTURE:
		mask_fetch = mask_pixmap_fetch;
		break;
	default:
		FatalError("Bad composite shader mask");
	}

	switch (key->in) {
	case SHADER_IN_SOURCE_ONLY:
		in = in_source_only;
		break;
	case SHADER_IN_NORMAL:
		in = in_normal;
		break;
	case SHADER_IN_CA_SOURCE:
		in = in_ca_source;
		break;
	case SHADER_IN_CA_ALPHA:
		in = in_ca_alpha;
		break;
	default:
		FatalError("Bad composite IN type");
	}

	XNFasprintf(&source, "%s%s%s", source_fetch, mask_fetch, in);


	prog = glamor_compile_glsl_prog(dispatch, GL_FRAGMENT_SHADER,
					source);
	free(source);

	return prog;
}

static GLuint
glamor_create_composite_vs(glamor_gl_dispatch * dispatch,
			   struct shader_key *key)
{
	const char *main_opening =
	    "attribute vec4 v_position;\n"
	    "attribute vec4 v_texcoord0;\n"
	    "attribute vec4 v_texcoord1;\n"
	    "varying vec2 source_texture;\n"
	    "varying vec2 mask_texture;\n"
	    "void main()\n" "{\n" "	gl_Position = v_position;\n";
	const char *source_coords =
	    "	source_texture = v_texcoord0.xy;\n";
	const char *mask_coords = "	mask_texture = v_texcoord1.xy;\n";
	const char *main_closing = "}\n";
	const char *source_coords_setup = "";
	const char *mask_coords_setup = "";
	char *source;
	GLuint prog;

	if (key->source != SHADER_SOURCE_SOLID)
		source_coords_setup = source_coords;

	if (key->mask != SHADER_MASK_NONE
	    && key->mask != SHADER_MASK_SOLID)
		mask_coords_setup = mask_coords;

	XNFasprintf(&source,
		    "%s%s%s%s",
		    main_opening,
		    source_coords_setup, mask_coords_setup, main_closing);

	prog =
	    glamor_compile_glsl_prog(dispatch, GL_VERTEX_SHADER, source);
	free(source);

	return prog;
}

static void
glamor_create_composite_shader(ScreenPtr screen, struct shader_key *key,
			       glamor_composite_shader * shader)
{
	GLuint vs, fs, prog;
	GLint source_sampler_uniform_location,
	    mask_sampler_uniform_location;
	glamor_screen_private *glamor = glamor_get_screen_private(screen);
	glamor_gl_dispatch *dispatch = &glamor->dispatch;

	vs = glamor_create_composite_vs(dispatch, key);
	if (vs == 0)
		return;
	fs = glamor_create_composite_fs(dispatch, key);
	if (fs == 0)
		return;

	prog = dispatch->glCreateProgram();
	dispatch->glAttachShader(prog, vs);
	dispatch->glAttachShader(prog, fs);

	dispatch->glBindAttribLocation(prog, GLAMOR_VERTEX_POS,
				       "v_position");
	dispatch->glBindAttribLocation(prog, GLAMOR_VERTEX_SOURCE,
				       "v_texcoord0");
	dispatch->glBindAttribLocation(prog, GLAMOR_VERTEX_MASK,
				       "v_texcoord1");

	glamor_link_glsl_prog(dispatch, prog);

	shader->prog = prog;

	dispatch->glUseProgram(prog);

	if (key->source == SHADER_SOURCE_SOLID) {
		shader->source_uniform_location =
		    dispatch->glGetUniformLocation(prog, "source");
	} else {
		source_sampler_uniform_location =
		    dispatch->glGetUniformLocation(prog, "source_sampler");
		dispatch->glUniform1i(source_sampler_uniform_location, 0);
	}

	if (key->mask != SHADER_MASK_NONE) {
		if (key->mask == SHADER_MASK_SOLID) {
			shader->mask_uniform_location =
			    dispatch->glGetUniformLocation(prog, "mask");
		} else {
			mask_sampler_uniform_location =
			    dispatch->glGetUniformLocation(prog,
							   "mask_sampler");
			dispatch->glUniform1i
			    (mask_sampler_uniform_location, 1);
		}
	}
}

static glamor_composite_shader *
glamor_lookup_composite_shader(ScreenPtr screen, struct
			       shader_key
			       *key)
{
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_composite_shader *shader;

	shader =
	    &glamor_priv->composite_shader[key->source][key->
							mask][key->in];
	if (shader->prog == 0)
		glamor_create_composite_shader(screen, key, shader);

	return shader;
}

#define GLAMOR_COMPOSITE_VBO_SIZE 8192

static void
glamor_reset_composite_vbo(ScreenPtr screen)
{
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_priv->vbo_offset = 0;
	glamor_priv->vbo_size = GLAMOR_COMPOSITE_VBO_SIZE;
	glamor_priv->render_nr_verts = 0;
}


void
glamor_init_composite_shaders(ScreenPtr screen)
{
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_priv->vb = malloc(GLAMOR_COMPOSITE_VBO_SIZE);
	assert(glamor_priv->vb != NULL);
	glamor_reset_composite_vbo(screen);
}

static Bool
glamor_set_composite_op(ScreenPtr screen,
			CARD8 op, PicturePtr dest, PicturePtr mask)
{
	GLenum source_blend, dest_blend;
	struct blendinfo *op_info;
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_gl_dispatch *dispatch = &glamor_priv->dispatch;

	if (op >= ARRAY_SIZE(composite_op_info)) {
		glamor_fallback("unsupported render op %d \n", op);
		return GL_FALSE;
	}
	op_info = &composite_op_info[op];

	source_blend = op_info->source_blend;
	dest_blend = op_info->dest_blend;

	/* If there's no dst alpha channel, adjust the blend op so that we'll treat
	 * it as always 1.
	 */
	if (PICT_FORMAT_A(dest->format) == 0 && op_info->dest_alpha) {
		if (source_blend == GL_DST_ALPHA)
			source_blend = GL_ONE;
		else if (source_blend == GL_ONE_MINUS_DST_ALPHA)
			source_blend = GL_ZERO;
	}

	/* Set up the source alpha value for blending in component alpha mode. */
	if (mask && mask->componentAlpha
	    && PICT_FORMAT_RGB(mask->format) != 0 && op_info->source_alpha)
	{
		if (source_blend != GL_ZERO) {
			glamor_fallback
			    ("Dual-source composite blending not supported\n");
			return GL_FALSE;
		}
		if (dest_blend == GL_SRC_ALPHA)
			dest_blend = GL_SRC_COLOR;
		else if (dest_blend == GL_ONE_MINUS_SRC_ALPHA)
			dest_blend = GL_ONE_MINUS_SRC_COLOR;
	}

	if (source_blend == GL_ONE && dest_blend == GL_ZERO) {
		dispatch->glDisable(GL_BLEND);
	} else {
		dispatch->glEnable(GL_BLEND);
		dispatch->glBlendFunc(source_blend, dest_blend);
	}
	return TRUE;
}

static void
glamor_set_composite_texture(ScreenPtr screen, int unit,
			     PicturePtr picture,
			     glamor_pixmap_private * pixmap_priv)
{
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_gl_dispatch *dispatch = &glamor_priv->dispatch;
	dispatch->glActiveTexture(GL_TEXTURE0 + unit);
	dispatch->glBindTexture(GL_TEXTURE_2D, pixmap_priv->tex);
	switch (picture->repeatType) {
	case RepeatNone:
#ifndef GLAMOR_GLES2
		/* XXX  GLES2 doesn't support GL_CLAMP_TO_BORDER. */
		dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
					  GL_CLAMP_TO_BORDER);
		dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
					  GL_CLAMP_TO_BORDER);
#endif
		break;
	case RepeatNormal:
		dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
					  GL_REPEAT);
		dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
					  GL_REPEAT);
		break;
	case RepeatPad:
		dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
					  GL_CLAMP_TO_EDGE);
		dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
					  GL_CLAMP_TO_EDGE);
		break;
	case RepeatReflect:
		dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
					  GL_MIRRORED_REPEAT);
		dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
					  GL_MIRRORED_REPEAT);
		break;
	}

	switch (picture->filter) {
	case PictFilterNearest:
		dispatch->glTexParameteri(GL_TEXTURE_2D,
					  GL_TEXTURE_MIN_FILTER,
					  GL_NEAREST);
		dispatch->glTexParameteri(GL_TEXTURE_2D,
					  GL_TEXTURE_MAG_FILTER,
					  GL_NEAREST);
		break;
	case PictFilterBilinear:
	default:
		dispatch->glTexParameteri(GL_TEXTURE_2D,
					  GL_TEXTURE_MIN_FILTER,
					  GL_LINEAR);
		dispatch->glTexParameteri(GL_TEXTURE_2D,
					  GL_TEXTURE_MAG_FILTER,
					  GL_LINEAR);
		break;
	}
#ifndef GLAMOR_GLES2
	dispatch->glEnable(GL_TEXTURE_2D);
#endif
}

static void
glamor_set_composite_solid(glamor_gl_dispatch * dispatch, float *color,
			   GLint uniform_location)
{
	dispatch->glUniform4fv(uniform_location, 1, color);
}

static int
compatible_formats(CARD8 op, PicturePtr dst, PicturePtr src)
{
	if (op == PictOpSrc) {
		if (src->format == dst->format)
			return 1;

		if (src->format == PICT_a8r8g8b8
		    && dst->format == PICT_x8r8g8b8)
			return 1;

		if (src->format == PICT_a8b8g8r8
		    && dst->format == PICT_x8b8g8r8)
			return 1;
	} else if (op == PictOpOver) {
		if (src->alphaMap || dst->alphaMap)
			return 0;

		if (src->format != dst->format)
			return 0;

		if (src->format == PICT_x8r8g8b8
		    || src->format == PICT_x8b8g8r8)
			return 1;
	}

	return 0;
}

static char
glamor_get_picture_location(PicturePtr picture)
{
	if (picture == NULL)
		return ' ';

	if (picture->pDrawable == NULL) {
		switch (picture->pSourcePict->type) {
		case SourcePictTypeSolidFill:
			return 'c';
		case SourcePictTypeLinear:
			return 'l';
		case SourcePictTypeRadial:
			return 'r';
		default:
			return '?';
		}
	}
	return glamor_get_drawable_location(picture->pDrawable);
}

static Bool
glamor_composite_with_copy(CARD8 op,
			   PicturePtr source,
			   PicturePtr dest,
			   INT16 x_source,
			   INT16 y_source,
			   INT16 x_dest,
			   INT16 y_dest, CARD16 width, CARD16 height)
{
	RegionRec region;

	if (!source->pDrawable)
		return FALSE;

	if (!compatible_formats(op, dest, source))
		return FALSE;

	if (source->repeat || source->transform)
		return FALSE;

	x_dest += dest->pDrawable->x;
	y_dest += dest->pDrawable->y;
	x_source += source->pDrawable->x;
	y_source += source->pDrawable->y;

	if (!miComputeCompositeRegion(&region,
				      source, NULL, dest,
				      x_source, y_source,
				      0, 0, x_dest, y_dest, width, height))
		return TRUE;

	glamor_copy_n_to_n(source->pDrawable,
			   dest->pDrawable, NULL,
			   REGION_RECTS(&region),
			   REGION_NUM_RECTS(&region),
			   x_source - x_dest, y_source - y_dest,
			   FALSE, FALSE, 0, NULL);
	REGION_UNINIT(dest->pDrawable->pScreen, &region);
	return TRUE;
}

static void
glamor_setup_composite_vbo(ScreenPtr screen)
{
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_gl_dispatch *dispatch = &glamor_priv->dispatch;

	glamor_priv->vb_stride = 2 * sizeof(float);
	if (glamor_priv->has_source_coords)
		glamor_priv->vb_stride += 2 * sizeof(float);
	if (glamor_priv->has_mask_coords)
		glamor_priv->vb_stride += 2 * sizeof(float);

	dispatch->glBindBuffer(GL_ARRAY_BUFFER, glamor_priv->vbo);

	dispatch->glVertexAttribPointer(GLAMOR_VERTEX_POS, 2, GL_FLOAT,
					GL_FALSE, glamor_priv->vb_stride,
					(void *) ((long)
						  glamor_priv->vbo_offset));
	dispatch->glEnableVertexAttribArray(GLAMOR_VERTEX_POS);

	if (glamor_priv->has_source_coords) {
		dispatch->glVertexAttribPointer(GLAMOR_VERTEX_SOURCE, 2,
						GL_FLOAT, GL_FALSE,
						glamor_priv->vb_stride,
						(void *) ((long)
							  glamor_priv->vbo_offset
							  +
							  2 *
							  sizeof(float)));
		dispatch->glEnableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
	}

	if (glamor_priv->has_mask_coords) {
		dispatch->glVertexAttribPointer(GLAMOR_VERTEX_MASK, 2,
						GL_FLOAT, GL_FALSE,
						glamor_priv->vb_stride,
						(void *) ((long)
							  glamor_priv->vbo_offset
							  +
							  (glamor_priv->has_source_coords
							   ? 4 : 2) *
							  sizeof(float)));
		dispatch->glEnableVertexAttribArray(GLAMOR_VERTEX_MASK);
	}
}

static void
glamor_emit_composite_vert(ScreenPtr screen,
			   const float *src_coords,
			   const float *mask_coords,
			   const float *dst_coords, int i)
{
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	float *vb = (float *) (glamor_priv->vb + glamor_priv->vbo_offset);
	int j = 0;

	vb[j++] = dst_coords[i * 2 + 0];
	vb[j++] = dst_coords[i * 2 + 1];
	if (glamor_priv->has_source_coords) {
		vb[j++] = src_coords[i * 2 + 0];
		vb[j++] = src_coords[i * 2 + 1];
	}
	if (glamor_priv->has_mask_coords) {
		vb[j++] = mask_coords[i * 2 + 0];
		vb[j++] = mask_coords[i * 2 + 1];
	}

	glamor_priv->render_nr_verts++;
	glamor_priv->vbo_offset += glamor_priv->vb_stride;
}

static void
glamor_flush_composite_rects(ScreenPtr screen)
{
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_gl_dispatch *dispatch = &glamor_priv->dispatch;
	if (!glamor_priv->render_nr_verts)
		return;
	dispatch->glBufferData(GL_ARRAY_BUFFER, glamor_priv->vbo_offset,
			       glamor_priv->vb, GL_STREAM_DRAW);

	dispatch->glDrawArrays(GL_TRIANGLES, 0,
			       glamor_priv->render_nr_verts);
	glamor_reset_composite_vbo(screen);
}

static void
glamor_emit_composite_rect(ScreenPtr screen,
			   const float *src_coords,
			   const float *mask_coords,
			   const float *dst_coords)
{
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_gl_dispatch *dispatch = &glamor_priv->dispatch;

	if (glamor_priv->vbo_offset + 6 * glamor_priv->vb_stride >
	    glamor_priv->vbo_size) {
		glamor_flush_composite_rects(screen);
	}

	if (glamor_priv->vbo_offset == 0) {
		if (glamor_priv->vbo == 0)
			dispatch->glGenBuffers(1, &glamor_priv->vbo);

		glamor_setup_composite_vbo(screen);
	}

	glamor_emit_composite_vert(screen, src_coords, mask_coords,
				   dst_coords, 0);
	glamor_emit_composite_vert(screen, src_coords, mask_coords,
				   dst_coords, 1);
	glamor_emit_composite_vert(screen, src_coords, mask_coords,
				   dst_coords, 2);
	glamor_emit_composite_vert(screen, src_coords, mask_coords,
				   dst_coords, 0);
	glamor_emit_composite_vert(screen, src_coords, mask_coords,
				   dst_coords, 2);
	glamor_emit_composite_vert(screen, src_coords, mask_coords,
				   dst_coords, 3);
}


int pict_format_combine_tab[][3] = {
	{PICT_TYPE_ARGB, PICT_TYPE_A, PICT_TYPE_ARGB},
	{PICT_TYPE_ABGR, PICT_TYPE_A, PICT_TYPE_ABGR},
};

static Bool
combine_pict_format(PictFormatShort * des, const PictFormatShort src,
		    const PictFormatShort mask, enum shader_in in_ca)
{
	PictFormatShort new_vis;
	int src_type, mask_type, src_bpp, mask_bpp;
	int i;
	if (src == mask) {
		*des = src;
		return TRUE;
	}
	src_bpp = PICT_FORMAT_BPP(src);
	mask_bpp = PICT_FORMAT_BPP(mask);

	assert(src_bpp == mask_bpp);

	new_vis = PICT_FORMAT_VIS(src) | PICT_FORMAT_VIS(mask);

	switch (in_ca) {
	case SHADER_IN_SOURCE_ONLY:
		return TRUE;
	case SHADER_IN_NORMAL:
		src_type = PICT_FORMAT_TYPE(src);
		mask_type = PICT_TYPE_A;
		break;
	case SHADER_IN_CA_SOURCE:
		src_type = PICT_FORMAT_TYPE(src);
		mask_type = PICT_FORMAT_TYPE(mask);
		break;
	case SHADER_IN_CA_ALPHA:
		src_type = PICT_TYPE_A;
		mask_type = PICT_FORMAT_TYPE(mask);
		break;
	default:
		return FALSE;
	}


	if (src_type == mask_type) {
		*des = PICT_VISFORMAT(src_bpp, src_type, new_vis);
		return TRUE;
	}

	for (i = 0;
	     i <
	     sizeof(pict_format_combine_tab) /
	     sizeof(pict_format_combine_tab[0]); i++) {
		if ((src_type == pict_format_combine_tab[i][0]
		     && mask_type == pict_format_combine_tab[i][1])
		    || (src_type == pict_format_combine_tab[i][1]
			&& mask_type == pict_format_combine_tab[i][0])) {
			*des = PICT_VISFORMAT(src_bpp,
					      pict_format_combine_tab[i]
					      [2], new_vis);
			return TRUE;
		}
	}
	return FALSE;
}

static Bool
glamor_composite_with_shader(CARD8 op,
			     PicturePtr source,
			     PicturePtr mask,
			     PicturePtr dest,
			     int nrect, glamor_composite_rect_t * rects)
{
	ScreenPtr screen = dest->pDrawable->pScreen;
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_gl_dispatch *dispatch = &glamor_priv->dispatch;
	PixmapPtr dest_pixmap =
	    glamor_get_drawable_pixmap(dest->pDrawable);
	PixmapPtr source_pixmap = NULL, mask_pixmap = NULL;
	glamor_pixmap_private *source_pixmap_priv = NULL;
	glamor_pixmap_private *mask_pixmap_priv = NULL;
	glamor_pixmap_private *dest_pixmap_priv = NULL;
	GLfloat dst_xscale, dst_yscale;
	GLfloat mask_xscale = 1, mask_yscale = 1, src_xscale =
	    1, src_yscale = 1;
	struct shader_key key;
	glamor_composite_shader *shader;
	RegionRec region;
	float vertices[8], source_texcoords[8], mask_texcoords[8];
	int i;
	BoxPtr box;
	int dest_x_off, dest_y_off;
	int source_x_off, source_y_off;
	int mask_x_off, mask_y_off;
	enum glamor_pixmap_status source_status = GLAMOR_NONE;
	enum glamor_pixmap_status mask_status = GLAMOR_NONE;
	PictFormatShort saved_source_format = 0;
	float src_matrix[9], mask_matrix[9];
	GLfloat source_solid_color[4], mask_solid_color[4];

	dest_pixmap_priv = glamor_get_pixmap_private(dest_pixmap);

	if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(dest_pixmap_priv)) {
		glamor_fallback("dest has no fbo.\n");
		goto fail;
	}
	memset(&key, 0, sizeof(key));
	if (!source->pDrawable) {
		if (source->pSourcePict->type == SourcePictTypeSolidFill) {
			key.source = SHADER_SOURCE_SOLID;
			glamor_get_rgba_from_pixel(source->
						   pSourcePict->solidFill.
						   color,
						   &source_solid_color[0],
						   &source_solid_color[1],
						   &source_solid_color[2],
						   &source_solid_color[3],
						   PICT_a8r8g8b8);
		} else {
			glamor_fallback("gradient source\n");
			goto fail;
		}
	} else {
		key.source = SHADER_SOURCE_TEXTURE_ALPHA;
	}
	if (mask) {
		if (!mask->pDrawable) {
			if (mask->pSourcePict->type ==
			    SourcePictTypeSolidFill) {
				key.mask = SHADER_MASK_SOLID;
				glamor_get_rgba_from_pixel
				    (mask->pSourcePict->solidFill.color,
				     &mask_solid_color[0],
				     &mask_solid_color[1],
				     &mask_solid_color[2],
				     &mask_solid_color[3], PICT_a8r8g8b8);
			} else {
				glamor_fallback("gradient mask\n");
				goto fail;
			}
		} else {
			key.mask = SHADER_MASK_TEXTURE_ALPHA;
		}

		if (!mask->componentAlpha) {
			key.in = SHADER_IN_NORMAL;
		} else {
			/* We only handle two CA modes. */
			if (op == PictOpAdd)
				key.in = SHADER_IN_CA_SOURCE;
			else if (op == PictOpOutReverse) {
				key.in = SHADER_IN_CA_ALPHA;
			} else {
				glamor_fallback
				    ("Unsupported component alpha op: %d\n",
				     op);
				goto fail;
			}
		}
	} else {
		key.mask = SHADER_MASK_NONE;
		key.in = SHADER_IN_SOURCE_ONLY;
	}

	if (source->alphaMap) {
		glamor_fallback("source alphaMap\n");
		goto fail;
	}
	if (mask && mask->alphaMap) {
		glamor_fallback("mask alphaMap\n");
		goto fail;
	}
	if (key.source == SHADER_SOURCE_TEXTURE ||
	    key.source == SHADER_SOURCE_TEXTURE_ALPHA) {
		source_pixmap =
		    glamor_get_drawable_pixmap(source->pDrawable);
		source_pixmap_priv =
		    glamor_get_pixmap_private(source_pixmap);
		if (source_pixmap == dest_pixmap) {
			glamor_fallback("source == dest\n");
			goto fail;
		}
		if (!source_pixmap_priv || source_pixmap_priv->gl_fbo == 0) {
			/* XXX in Xephyr, we may have gl_fbo equal to 1 but gl_tex 
			 * equal to zero when the pixmap is screen pixmap. Then we may
			 * refer the tex zero directly latter in the composition. 
			 * It seems that it works fine, but it may have potential problem*/
#ifdef GLAMOR_PIXMAP_DYNAMIC_UPLOAD
			source_status = GLAMOR_UPLOAD_PENDING;
#else
			glamor_fallback("no texture in source\n");
			goto fail;
#endif
		} else if (source_pixmap_priv->pending_op.type ==
			   GLAMOR_PENDING_FILL) {
			key.source = SHADER_SOURCE_SOLID;
			memcpy(source_solid_color,
			       source_pixmap_priv->pending_op.
			       fill.color4fv, 4 * sizeof(float));
		}
	}
	if (key.mask == SHADER_MASK_TEXTURE ||
	    key.mask == SHADER_MASK_TEXTURE_ALPHA) {
		mask_pixmap = glamor_get_drawable_pixmap(mask->pDrawable);
		mask_pixmap_priv = glamor_get_pixmap_private(mask_pixmap);
		if (mask_pixmap == dest_pixmap) {
			glamor_fallback("mask == dest\n");
			goto fail;
		}
		if (!mask_pixmap_priv || mask_pixmap_priv->gl_fbo == 0) {
#ifdef GLAMOR_PIXMAP_DYNAMIC_UPLOAD
			mask_status = GLAMOR_UPLOAD_PENDING;
#else
			glamor_fallback("no texture in mask\n");
			goto fail;
#endif
		} else if (mask_pixmap_priv->pending_op.type ==
			   GLAMOR_PENDING_FILL) {
			key.mask = SHADER_MASK_SOLID;
			memcpy(mask_solid_color,
			       mask_pixmap_priv->pending_op.fill.color4fv,
			       4 * sizeof(float));
		}
	}
#ifdef GLAMOR_PIXMAP_DYNAMIC_UPLOAD
	if (source_status == GLAMOR_UPLOAD_PENDING
	    && mask_status == GLAMOR_UPLOAD_PENDING
	    && source_pixmap == mask_pixmap) {

		if (source->format != mask->format) {
			saved_source_format = source->format;

			if (!combine_pict_format
			    (&source->format, source->format,
			     mask->format, key.in)) {
				glamor_fallback
				    ("combine source %x mask %x failed.\n",
				     source->format, mask->format);
				goto fail;
			}

			if (source->format != saved_source_format) {
				glamor_picture_format_fixup(source,
							    source_pixmap_priv);
			}
			/* XXX  
			 * By default, glamor_upload_picture_to_texture will wire alpha to 1
			 * if one picture doesn't have alpha. So we don't do that again in 
			 * rendering function. But here is a special case, as source and
			 * mask share the same texture but may have different formats. For 
			 * example, source doesn't have alpha, but mask has alpha. Then the
			 * texture will have the alpha value for the mask. And will not wire
			 * to 1 for the source. In this case, we have to use different shader
			 * to wire the source's alpha to 1.
			 *
			 * But this may cause a potential problem if the source's repeat mode 
			 * is REPEAT_NONE, and if the source is smaller than the dest, then
			 * for the region not covered by the source may be painted incorrectly.
			 * because we wire the alpha to 1.
			 *
			 **/
			if (!PICT_FORMAT_A(saved_source_format)
			    && PICT_FORMAT_A(mask->format))
				key.source = SHADER_SOURCE_TEXTURE;

			if (!PICT_FORMAT_A(mask->format)
			    && PICT_FORMAT_A(saved_source_format))
				key.mask = SHADER_MASK_TEXTURE;

			mask_status = GLAMOR_NONE;
		}
		source_status = glamor_upload_picture_to_texture(source);

		if (source_status != GLAMOR_UPLOAD_DONE) {
			glamor_fallback
			    ("Failed to upload source texture.\n");
			goto fail;
		}
	} else {

		if (source_status == GLAMOR_UPLOAD_PENDING) {
			source_status =
			    glamor_upload_picture_to_texture(source);
			if (source_status != GLAMOR_UPLOAD_DONE) {
				glamor_fallback
				    ("Failed to upload source texture.\n");
				goto fail;
			}
		}

		if (mask_status == GLAMOR_UPLOAD_PENDING) {
			mask_status =
			    glamor_upload_picture_to_texture(mask);
			if (mask_status != GLAMOR_UPLOAD_DONE) {
				glamor_fallback
				    ("Failed to upload mask texture.\n");
				goto fail;
			}
		}
	}
#endif
	glamor_set_destination_pixmap_priv_nc(dest_pixmap_priv);
	glamor_validate_pixmap(dest_pixmap);
	if (!glamor_set_composite_op(screen, op, dest, mask)) {
		goto fail;
	}

	shader = glamor_lookup_composite_shader(screen, &key);
	if (shader->prog == 0) {
		glamor_fallback
		    ("no shader program for this render acccel mode\n");
		goto fail;
	}

	dispatch->glUseProgram(shader->prog);


	if (key.source == SHADER_SOURCE_SOLID) {
		glamor_set_composite_solid(dispatch, source_solid_color,
					   shader->source_uniform_location);
	} else {
		glamor_set_composite_texture(screen, 0, source,
					     source_pixmap_priv);
	}
	if (key.mask != SHADER_MASK_NONE) {
		if (key.mask == SHADER_MASK_SOLID) {
			glamor_set_composite_solid(dispatch,
						   mask_solid_color,
						   shader->mask_uniform_location);
		} else {
			glamor_set_composite_texture(screen, 1, mask,
						     mask_pixmap_priv);
		}
	}

	glamor_priv->has_source_coords = key.source != SHADER_SOURCE_SOLID;
	glamor_priv->has_mask_coords = (key.mask != SHADER_MASK_NONE &&
					key.mask != SHADER_MASK_SOLID);

	glamor_get_drawable_deltas(dest->pDrawable, dest_pixmap,
				   &dest_x_off, &dest_y_off);
	pixmap_priv_get_scale(dest_pixmap_priv, &dst_xscale, &dst_yscale);



	if (glamor_priv->has_source_coords) {
		glamor_get_drawable_deltas(source->pDrawable,
					   source_pixmap, &source_x_off,
					   &source_y_off);
		pixmap_priv_get_scale(source_pixmap_priv, &src_xscale,
				      &src_yscale);
		glamor_picture_get_matrixf(source, src_matrix);
	}

	if (glamor_priv->has_mask_coords) {
		glamor_get_drawable_deltas(mask->pDrawable, mask_pixmap,
					   &mask_x_off, &mask_y_off);
		pixmap_priv_get_scale(mask_pixmap_priv, &mask_xscale,
				      &mask_yscale);
		glamor_picture_get_matrixf(mask, mask_matrix);
	}

	while (nrect--) {
		INT16 x_source;
		INT16 y_source;
		INT16 x_mask;
		INT16 y_mask;
		INT16 x_dest;
		INT16 y_dest;
		CARD16 width;
		CARD16 height;

		x_dest = rects->x_dst;
		y_dest = rects->y_dst;
		x_source = rects->x_src;
		y_source = rects->y_src;
		x_mask = rects->x_mask;
		y_mask = rects->y_mask;
		width = rects->width;
		height = rects->height;

		x_dest += dest->pDrawable->x;
		y_dest += dest->pDrawable->y;
		if (source->pDrawable) {
			x_source += source->pDrawable->x;
			y_source += source->pDrawable->y;
		}
		if (mask && mask->pDrawable) {
			x_mask += mask->pDrawable->x;
			y_mask += mask->pDrawable->y;
		}

		if (!miComputeCompositeRegion(&region,
					      source, mask, dest,
					      x_source, y_source,
					      x_mask, y_mask,
					      x_dest, y_dest, width,
					      height))
			continue;

		x_source += source_x_off;
		y_source += source_y_off;
		x_mask += mask_x_off;
		y_mask += mask_y_off;

		box = REGION_RECTS(&region);
		for (i = 0; i < REGION_NUM_RECTS(&region); i++) {
			int vx1 = box[i].x1 + dest_x_off;
			int vx2 = box[i].x2 + dest_x_off;
			int vy1 = box[i].y1 + dest_y_off;
			int vy2 = box[i].y2 + dest_y_off;
			glamor_set_normalize_vcoords(dst_xscale,
						     dst_yscale, vx1,
						     vy1, vx2, vy2,
						     glamor_priv->yInverted,
						     vertices);

			if (key.source != SHADER_SOURCE_SOLID) {
				int tx1 = box[i].x1 + x_source - x_dest;
				int ty1 = box[i].y1 + y_source - y_dest;
				int tx2 = box[i].x2 + x_source - x_dest;
				int ty2 = box[i].y2 + y_source - y_dest;
				if (source->transform)
					glamor_set_transformed_normalize_tcoords
					    (src_matrix, src_xscale,
					     src_yscale, tx1, ty1,
					     tx2, ty2,
					     glamor_priv->yInverted,
					     source_texcoords);
				else
					glamor_set_normalize_tcoords
					    (src_xscale, src_yscale,
					     tx1, ty1, tx2, ty2,
					     glamor_priv->yInverted,
					     source_texcoords);
			}

			if (key.mask != SHADER_MASK_NONE
			    && key.mask != SHADER_MASK_SOLID) {
				float tx1 = box[i].x1 + x_mask - x_dest;
				float ty1 = box[i].y1 + y_mask - y_dest;
				float tx2 = box[i].x2 + x_mask - x_dest;
				float ty2 = box[i].y2 + y_mask - y_dest;
				if (mask->transform)
					glamor_set_transformed_normalize_tcoords
					    (mask_matrix,
					     mask_xscale,
					     mask_yscale, tx1, ty1,
					     tx2, ty2,
					     glamor_priv->yInverted,
					     mask_texcoords);
				else
					glamor_set_normalize_tcoords
					    (mask_xscale,
					     mask_yscale, tx1, ty1,
					     tx2, ty2,
					     glamor_priv->yInverted,
					     mask_texcoords);
			}
			glamor_emit_composite_rect(screen,
						   source_texcoords,
						   mask_texcoords,
						   vertices);
		}
		rects++;
	}
	glamor_flush_composite_rects(screen);

	dispatch->glBindBuffer(GL_ARRAY_BUFFER, 0);
	dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
	dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
	dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_MASK);
	REGION_UNINIT(dst->pDrawable->pScreen, &region);
	dispatch->glDisable(GL_BLEND);
#ifndef GLAMOR_GLES2
	dispatch->glActiveTexture(GL_TEXTURE0);
	dispatch->glDisable(GL_TEXTURE_2D);
	dispatch->glActiveTexture(GL_TEXTURE1);
	dispatch->glDisable(GL_TEXTURE_2D);
#endif
	dispatch->glUseProgram(0);
	if (saved_source_format)
		source->format = saved_source_format;
	return TRUE;

      fail:
	if (saved_source_format)
		source->format = saved_source_format;

	dispatch->glDisable(GL_BLEND);
	dispatch->glUseProgram(0);
	return FALSE;
}

static PicturePtr
glamor_convert_gradient_picture(ScreenPtr screen,
				PicturePtr source,
				int x_source,
				int y_source, int width, int height)
{
	PixmapPtr pixmap;
	PicturePtr dst;
	int error;
	PictFormatShort format;

	if (!source->pDrawable)
		format = PICT_a8r8g8b8;
	else
		format = source->format;

	pixmap = screen->CreatePixmap(screen,
				      width,
				      height,
				      PIXMAN_FORMAT_DEPTH(format),
				      GLAMOR_CREATE_PIXMAP_CPU);

	if (!pixmap)
		return NULL;

	dst = CreatePicture(0,
			    &pixmap->drawable,
			    PictureMatchFormat(screen,
					       PIXMAN_FORMAT_DEPTH(format),
					       format),
			    0, 0, serverClient, &error);
	screen->DestroyPixmap(pixmap);
	if (!dst)
		return NULL;

	ValidatePicture(dst);

	fbComposite(PictOpSrc, source, NULL, dst, x_source, y_source,
		    0, 0, 0, 0, width, height);
	return dst;
}

void
glamor_composite(CARD8 op,
		 PicturePtr source,
		 PicturePtr mask,
		 PicturePtr dest,
		 INT16 x_source,
		 INT16 y_source,
		 INT16 x_mask,
		 INT16 y_mask,
		 INT16 x_dest, INT16 y_dest, CARD16 width, CARD16 height)
{
	ScreenPtr screen = dest->pDrawable->pScreen;
	glamor_pixmap_private *dest_pixmap_priv;
	glamor_pixmap_private *source_pixmap_priv =
	    NULL, *mask_pixmap_priv = NULL;
	PixmapPtr dest_pixmap =
	    glamor_get_drawable_pixmap(dest->pDrawable);
	PixmapPtr source_pixmap = NULL, mask_pixmap = NULL;
	PicturePtr temp_src = source, temp_mask = mask;
	int x_temp_src, y_temp_src, x_temp_mask, y_temp_mask;
	glamor_composite_rect_t rect;
	glamor_screen_private *glamor_priv =
	    glamor_get_screen_private(screen);
	glamor_gl_dispatch *dispatch = &glamor_priv->dispatch;

	x_temp_src = x_source;
	y_temp_src = y_source;
	x_temp_mask = x_mask;
	y_temp_mask = y_mask;

	dest_pixmap_priv = glamor_get_pixmap_private(dest_pixmap);
	/* Currently. Always fallback to cpu if destination is in CPU memory. */
	if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(dest_pixmap_priv)) {
		goto fail;
	}

	if (source->pDrawable) {
		source_pixmap =
		    glamor_get_drawable_pixmap(source->pDrawable);
		source_pixmap_priv =
		    glamor_get_pixmap_private(source_pixmap);
	}

	if (mask && mask->pDrawable) {
		mask_pixmap = glamor_get_drawable_pixmap(mask->pDrawable);
		mask_pixmap_priv = glamor_get_pixmap_private(mask_pixmap);
	}

	if ((!source->pDrawable
	     && (source->pSourcePict->type != SourcePictTypeSolidFill))
	    || (source->pDrawable
		&& !GLAMOR_PIXMAP_PRIV_HAS_FBO(source_pixmap_priv)
		&&
		((width * height * 4 <
		  (source_pixmap->drawable.width *
		   source_pixmap->drawable.height))
		 ||
		 !(glamor_check_fbo_size
		   (glamor_priv, source_pixmap->drawable.width,
		    source_pixmap->drawable.height))))) {
		temp_src =
		    glamor_convert_gradient_picture(screen, source,
						    x_source, y_source,
						    width, height);
		if (!temp_src) {
			temp_src = source;
			goto fail;
		}
		x_temp_src = y_temp_src = 0;
	}

	if (mask
	    &&
	    ((!mask->pDrawable
	      && (mask->pSourcePict->type != SourcePictTypeSolidFill))
	     || (mask->pDrawable
		 && (!GLAMOR_PIXMAP_PRIV_HAS_FBO(mask_pixmap_priv))
		 &&
		 ((width * height * 4 <
		   (mask_pixmap->drawable.width *
		    mask_pixmap->drawable.height))
		  ||
		  !(glamor_check_fbo_size
		    (glamor_priv, mask_pixmap->drawable.width,
		     mask_pixmap->drawable.height)))))) {
		/* XXX if mask->pDrawable is the same as source->pDrawable, we have an opportunity
		 * to do reduce one convertion. */
		temp_mask =
		    glamor_convert_gradient_picture(screen, mask,
						    x_mask, y_mask,
						    width, height);
		if (!temp_mask) {
			temp_mask = mask;
			goto fail;
		}
		x_temp_mask = y_temp_mask = 0;
	}
	/* Do two-pass PictOpOver componentAlpha, until we enable
	 * dual source color blending.
	 */

	if (mask && mask->componentAlpha) {
		if (op == PictOpOver) {
			glamor_composite(PictOpOutReverse,
					 temp_src, temp_mask, dest,
					 x_temp_src, y_temp_src,
					 x_temp_mask, y_temp_mask,
					 x_dest, y_dest, width, height);
			glamor_composite(PictOpAdd,
					 temp_src, temp_mask, dest,
					 x_temp_src, y_temp_src,
					 x_temp_mask, y_temp_mask,
					 x_dest, y_dest, width, height);
			goto done;

		} else if (op != PictOpAdd && op != PictOpOutReverse) {
			glamor_fallback
			    ("glamor_composite(): component alpha\n");
			goto fail;
		}
	}

	if (!mask) {
		if (glamor_composite_with_copy(op, temp_src, dest,
					       x_temp_src, y_temp_src,
					       x_dest, y_dest, width,
					       height))
			goto done;
	}

	rect.x_src = x_temp_src;
	rect.y_src = y_temp_src;
	rect.x_mask = x_temp_mask;
	rect.y_mask = y_temp_mask;
	rect.x_dst = x_dest;
	rect.y_dst = y_dest;
	rect.width = width;
	rect.height = height;
	if (glamor_composite_with_shader
	    (op, temp_src, temp_mask, dest, 1, &rect))
		goto done;

      fail:

	glamor_fallback
	    ("from picts %p:%p %dx%d / %p:%p %d x %d (%c,%c)  to pict %p:%p %dx%d (%c)\n",
	     source, source->pDrawable,
	     source->pDrawable ? source->pDrawable->width : 0,
	     source->pDrawable ? source->pDrawable->height : 0, mask,
	     (!mask) ? NULL : mask->pDrawable, (!mask
						|| !mask->pDrawable) ? 0 :
	     mask->pDrawable->width, (!mask
				      || !mask->
				      pDrawable) ? 0 : mask->pDrawable->
	     height, glamor_get_picture_location(source),
	     glamor_get_picture_location(mask), dest, dest->pDrawable,
	     dest->pDrawable->width, dest->pDrawable->height,
	     glamor_get_picture_location(dest));

	dispatch->glUseProgram(0);
	dispatch->glDisable(GL_BLEND);
	if (glamor_prepare_access_picture(dest, GLAMOR_ACCESS_RW)) {
		if (glamor_prepare_access_picture
		    (source, GLAMOR_ACCESS_RO)) {
			if (!mask
			    || glamor_prepare_access_picture(mask,
							     GLAMOR_ACCESS_RO))
			{
				fbComposite(op,
					    source, mask, dest,
					    x_source, y_source,
					    x_mask, y_mask, x_dest,
					    y_dest, width, height);
				if (mask)
					glamor_finish_access_picture(mask);
			}
			glamor_finish_access_picture(source);
		}
		glamor_finish_access_picture(dest);
	}
      done:
	if (temp_src != source)
		FreePicture(temp_src, 0);
	if (temp_mask != mask)
		FreePicture(temp_mask, 0);
}


/**
 * Creates an appropriate picture to upload our alpha mask into (which
 * we calculated in system memory)
 */
static PicturePtr
glamor_create_mask_picture(ScreenPtr screen,
			   PicturePtr dst,
			   PictFormatPtr pict_format,
			   CARD16 width, CARD16 height)
{
	PixmapPtr pixmap;
	PicturePtr picture;
	int error;

	if (!pict_format) {
		if (dst->polyEdge == PolyEdgeSharp)
			pict_format =
			    PictureMatchFormat(screen, 1, PICT_a1);
		else
			pict_format =
			    PictureMatchFormat(screen, 8, PICT_a8);
		if (!pict_format)
			return 0;
	}

	pixmap = screen->CreatePixmap(screen, 0, 0,
				      pict_format->depth,
				      GLAMOR_CREATE_PIXMAP_CPU);
	if (!pixmap)
		return 0;
	picture = CreatePicture(0, &pixmap->drawable, pict_format,
				0, 0, serverClient, &error);
	screen->DestroyPixmap(pixmap);
	return picture;
}

/**
 * glamor_trapezoids is a copy of miTrapezoids that does all the trapezoid
 * accumulation in system memory.
 */
void
glamor_trapezoids(CARD8 op,
		  PicturePtr src, PicturePtr dst,
		  PictFormatPtr mask_format, INT16 x_src, INT16 y_src,
		  int ntrap, xTrapezoid * traps)
{
	ScreenPtr screen = dst->pDrawable->pScreen;
	BoxRec bounds;
	PicturePtr picture;
	INT16 x_dst, y_dst;
	INT16 x_rel, y_rel;
	int width, height, stride;
	PixmapPtr pixmap;
	pixman_image_t *image;

	/* If a mask format wasn't provided, we get to choose, but behavior should
	 * be as if there was no temporary mask the traps were accumulated into.
	 */
	if (!mask_format) {
		if (dst->polyEdge == PolyEdgeSharp)
			mask_format =
			    PictureMatchFormat(screen, 1, PICT_a1);
		else
			mask_format =
			    PictureMatchFormat(screen, 8, PICT_a8);
		for (; ntrap; ntrap--, traps++)
			glamor_trapezoids(op, src, dst, mask_format, x_src,
					  y_src, 1, traps);
		return;
	}

	miTrapezoidBounds(ntrap, traps, &bounds);

	if (bounds.y1 >= bounds.y2 || bounds.x1 >= bounds.x2)
		return;

	x_dst = traps[0].left.p1.x >> 16;
	y_dst = traps[0].left.p1.y >> 16;

	width = bounds.x2 - bounds.x1;
	height = bounds.y2 - bounds.y1;
	stride = PixmapBytePad(width, mask_format->depth);
	picture = glamor_create_mask_picture(screen, dst, mask_format,
					     width, height);
	if (!picture)
		return;

	image = pixman_image_create_bits(picture->format,
					 width, height, NULL, stride);
	if (!image) {
		FreePicture(picture, 0);
		return;
	}

	for (; ntrap; ntrap--, traps++)
		pixman_rasterize_trapezoid(image,
					   (pixman_trapezoid_t *) traps,
					   -bounds.x1, -bounds.y1);

	pixmap = glamor_get_drawable_pixmap(picture->pDrawable);

	screen->ModifyPixmapHeader(pixmap, width, height,
				   mask_format->depth,
				   BitsPerPixel(mask_format->depth),
				   PixmapBytePad(width,
						 mask_format->depth),
				   pixman_image_get_data(image));

	x_rel = bounds.x1 + x_src - x_dst;
	y_rel = bounds.y1 + y_src - y_dst;
	CompositePicture(op, src, picture, dst,
			 x_rel, y_rel,
			 0, 0,
			 bounds.x1, bounds.y1,
			 bounds.x2 - bounds.x1, bounds.y2 - bounds.y1);

	pixman_image_unref(image);

	FreePicture(picture, 0);
}

void
glamor_composite_rects(CARD8 op,
		       PicturePtr src, PicturePtr mask, PicturePtr dst,
		       int nrect, glamor_composite_rect_t * rects)
{
	int n;
	glamor_composite_rect_t *r;

	ValidatePicture(src);
	ValidatePicture(dst);

	if (glamor_composite_with_shader(op, src, mask, dst, nrect, rects))
		return;

	n = nrect;
	r = rects;

	while (n--) {
		CompositePicture(op,
				 src,
				 mask,
				 dst,
				 r->x_src, r->y_src,
				 r->x_mask, r->y_mask,
				 r->x_dst, r->y_dst, r->width, r->height);
		r++;
	}
}

#endif				/* RENDER */