glamor: Start adding render acceleration support.

This brings in idr's glu3 code.  We'll probably want to move to linking to
it as a library, once an ABI-stable release is out.

configure.ac

@@ -2147,6 +2147,7 @@ Xi/Makefile
 xfixes/Makefile
 exa/Makefile
 glamor/Makefile
+glamor/glu3/Makefile
 hw/Makefile
 hw/xfree86/Makefile
 hw/xfree86/common/Makefile

glamor/Makefile.am

@@ -4,6 +4,8 @@ noinst_LTLIBRARIES = libglamor.la
 # built (in hw/xfree86/os-support/solaris) until after glamor is built
 SOLARIS_ASM_CFLAGS=""
 
+SUBDIRS = glu3
+
 if XORG
 sdk_HEADERS = glamor.h
 endif
@@ -24,3 +26,5 @@ libglamor_la_SOURCES = \
 	glamor_render.c \
 	glamor_tile.c \
 	glamor.h
+libglamor_la_LIBADD = \
+	glu3/libglu3.la

glamor/glamor.c

@@ -208,6 +208,7 @@ glamor_init(ScreenPtr screen)
 
     glamor_init_solid_shader(screen);
     glamor_init_tile_shader(screen);
+    glamor_init_composite_shaders(screen);
 
     return TRUE;
 

glamor/glamor_priv.h

@@ -38,6 +38,13 @@ typedef struct glamor_transform_uniforms {
     GLint y_scale;
 } glamor_transform_uniforms;
 
+typedef struct glamor_composite_shader {
+    GLuint prog;
+    GLint dest_to_dest_uniform_location;
+    GLint dest_to_source_uniform_location;
+    GLint dest_to_mask_uniform_location;
+} glamor_composite_shader;
+
 typedef struct glamor_screen_private {
     CreateGCProcPtr saved_create_gc;
     CreatePixmapProcPtr saved_create_pixmap;
@@ -52,8 +59,12 @@ typedef struct glamor_screen_private {
     GLint solid_color_uniform_location;
     glamor_transform_uniforms solid_transform;
 
+    /* glamor_tile */
     GLint tile_prog;
     glamor_transform_uniforms tile_transform;
+
+    /* glamor_composite */
+    glamor_composite_shader composite_shader[2];
 } glamor_screen_private;
 
 typedef struct glamor_pixmap_private {
@@ -75,6 +86,10 @@ glamor_get_pixmap_private(PixmapPtr pixmap)
     return dixLookupPrivate(&pixmap->devPrivates, glamor_pixmap_private_key);
 }
 
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
+#define ALIGN(i,m)	(((i) + (m) - 1) & ~((m) - 1))
+#define MIN(a,b)	((a) < (b) ? (a) : (b))
+
 /**
  * Returns TRUE if the given planemask covers all the significant bits in the
  * pixel values for pDrawable.
@@ -166,6 +181,7 @@ void glamor_trapezoids(CARD8 op,
 		       PicturePtr src, PicturePtr dst,
 		       PictFormatPtr mask_format, INT16 x_src, INT16 y_src,
 		       int ntrap, xTrapezoid *traps);
+void glamor_init_composite_shaders(ScreenPtr screen);
 
 /* glamor_tile.c */
 void glamor_tile(PixmapPtr pixmap, PixmapPtr tile,

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 "glu3/glu3.h"
+
+struct shader_key {
+    Bool has_mask;
+};
+
+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},
+};
+
+#define HAS_MASK_INDEX    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);
+    int index = 0;
+
+    if (key->has_mask)
+	index += HAS_MASK_INDEX;
+
+    assert(index < ARRAY_SIZE(glamor_priv->composite_shader));
+
+    return &glamor_priv->composite_shader[index];
+}
+
+static GLuint
+glamor_create_composite_fs(struct shader_key *key)
+{
+    const char *header =
+	"uniform sampler2D source_sampler;\n"
+	"varying vec4 source_coords;\n";
+    const char *mask_header =
+	"uniform sampler2D mask_sampler;\n"
+	"varying vec4 mask_coords;\n";
+    const char *main_opening =
+	"void main()\n"
+	"{\n"
+	"	vec4 result;\n"
+	"	result = texture2DProj(source_sampler, source_coords.xyw);\n";
+    const char *source_in_mask =
+	"	vec4 mask = texture2DProj(mask_sampler, mask_coords.xyw);\n"
+	"	result = result * mask.w;\n";
+    const char *main_closing =
+	"	gl_FragColor = result;\n"
+	"}\n";
+    char *source;
+    GLuint prog;
+
+    source = XNFprintf("%s%s%s%s%s",
+		       header,
+		       key->has_mask ? mask_header : "",
+		       main_opening,
+		       key->has_mask ? source_in_mask : "",
+		       main_closing);
+
+    prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER_ARB, source);
+    xfree(source);
+
+    return prog;
+}
+
+static GLuint
+glamor_create_composite_vs(struct shader_key *key)
+{
+    const char *header =
+	"uniform mat4 dest_to_dest;\n"
+	"uniform mat4 dest_to_source;\n"
+	"varying vec4 source_coords;\n";
+    const char *mask_header =
+	"uniform mat4 dest_to_mask;\n"
+	"varying vec4 mask_coords;\n";
+    const char *main_opening =
+	"void main()\n"
+	"{\n"
+	"	vec4 incoming_dest_coords = vec4(gl_Vertex.xy, 0, 1);\n"
+	"	gl_Position = dest_to_dest * incoming_dest_coords;\n"
+	"	source_coords = dest_to_source * incoming_dest_coords;\n";
+    const char *mask_coords =
+	"	mask_coords = dest_to_mask * incoming_dest_coords;\n";
+    const char *main_closing =
+	"}\n";
+    char *source;
+    GLuint prog;
+
+    source = XNFprintf("%s%s%s%s%s",
+		       header,
+		       key->has_mask ? mask_header : "",
+		       main_opening,
+		       key->has_mask ? mask_coords : "",
+		       main_closing);
+
+    prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER_ARB, source);
+    xfree(source);
+
+    return prog;
+}
+
+static void
+glamor_create_composite_shader(ScreenPtr screen, struct shader_key *key)
+{
+    GLuint vs, fs, prog;
+    GLint source_sampler_uniform_location, mask_sampler_uniform_location;
+    glamor_composite_shader *shader;
+
+    shader = glamor_lookup_composite_shader(screen, key);
+
+    vs = glamor_create_composite_vs(key);
+    if (vs == 0)
+	return;
+    fs = glamor_create_composite_fs(key);
+    if (fs == 0)
+	return;
+
+    prog = glCreateProgramObjectARB();
+    glAttachObjectARB(prog, vs);
+    glAttachObjectARB(prog, fs);
+    glamor_link_glsl_prog(prog);
+
+    shader->prog = prog;
+
+    glUseProgramObjectARB(prog);
+    source_sampler_uniform_location = glGetUniformLocationARB(prog,
+							      "source_sampler");
+    shader->dest_to_dest_uniform_location =
+	glGetUniformLocationARB(prog, "dest_to_dest");
+    shader->dest_to_source_uniform_location =
+	glGetUniformLocationARB(prog, "dest_to_source");
+    glUniform1i(source_sampler_uniform_location, 0);
+
+    if (key->has_mask) {
+	mask_sampler_uniform_location = glGetUniformLocationARB(prog,
+								"mask_sampler");
+	glUniform1i(mask_sampler_uniform_location, 1);
+	shader->dest_to_mask_uniform_location =
+	    glGetUniformLocationARB(prog, "dest_to_mask");
+    }
+}
+
+void
+glamor_init_composite_shaders(ScreenPtr screen)
+{
+    struct shader_key key;
+
+    key.has_mask = FALSE;
+    glamor_create_composite_shader(screen, &key);
+    key.has_mask = TRUE;
+    glamor_create_composite_shader(screen, &key);
+}
+
+static void
+glamor_set_composite_transform_matrix(GLUmat4 *m,
+				      PicturePtr picture,
+				      float x_source,
+				      float y_source)
+{
+    GLUmat4 temp;
+    DrawablePtr drawable = picture->pDrawable;
+    GLUvec4 scale = {{1.0f / drawable->width,
+		      1.0f / drawable->height,
+		      1.0,
+		      1.0}};
+
+    gluTranslate3f(m, -x_source, -y_source, 0.0);
+    gluScale4v(&temp, &scale);
+    gluMult4m_4m(m, &temp, m);
+}
+
+static Bool
+glamor_set_composite_op(ScreenPtr screen,
+			CARD8 op, PicturePtr dest, PicturePtr mask)
+{
+    GLenum source_blend, dest_blend;
+    struct blendinfo *op_info;
+
+    if (op >= ARRAY_SIZE(composite_op_info)) {
+	ErrorF("unsupported render op\n");
+	return GL_FALSE;
+    }
+    op_info = &composite_op_info[op];
+
+    source_blend = op_info->source_blend;
+    dest_blend = op_info->dest_blend;
+
+    if (mask && mask->componentAlpha && PICT_FORMAT_RGB(mask->format) != 0 &&
+	op_info->source_alpha && source_blend != GL_ZERO) {
+    }
+
+    /* 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) {
+	    ErrorF("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) {
+	glDisable(GL_BLEND);
+    } else {
+	glEnable(GL_BLEND);
+	glBlendFunc(source_blend, dest_blend);
+    }
+    return TRUE;
+}
+
+static void
+glamor_set_composite_texture(ScreenPtr screen, int unit, PicturePtr picture,
+			     glamor_pixmap_private *pixmap_priv)
+{
+    glActiveTexture(GL_TEXTURE0 + unit);
+    glBindTexture(GL_TEXTURE_2D, pixmap_priv->tex);
+    switch (picture->repeatType) {
+    case RepeatNone:
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+	break;
+    case RepeatNormal:
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+	break;
+    case RepeatPad:
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	break;
+    case RepeatReflect:
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
+	break;
+    }
+
+    switch (picture->filter) {
+    case PictFilterNearest:
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        break;
+    case PictFilterBilinear:
+    default:
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        break;
+    }
+
+    glEnable(GL_TEXTURE_2D);
+}
+
+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;
+    PixmapPtr dest_pixmap = glamor_get_drawable_pixmap(dest->pDrawable);
+    PixmapPtr source_pixmap, mask_pixmap = NULL;
+    glamor_pixmap_private *source_pixmap_priv, *mask_pixmap_priv = NULL;
+    struct shader_key key;
+    glamor_composite_shader *shader;
+    GLUmat4 dest_to_dest, dest_to_source, dest_to_mask;
+    RegionRec region;
+    int i;
+
+    /* Do two-pass PictOpOver componentAlpha, until we enable
+     * dual source color blending.
+     */
+    if (mask && mask->componentAlpha && op == PictOpOver) {
+	glamor_composite(PictOpOutReverse,
+			 source, mask, dest,
+			 x_source, y_source,
+			 x_mask, y_mask,
+			 x_dest, y_dest,
+			 width, height);
+	glamor_composite(PictOpAdd,
+			 source, mask, dest,
+			 x_source, y_source,
+			 x_mask, y_mask,
+			 x_dest, y_dest,
+			 width, height);
+	return;
+    }
+
+    key.has_mask = (mask != NULL);
+    if (!source->pDrawable) {
+	ErrorF("source-only source\n");
+	goto fail;
+    }
+    if (mask && !mask->pDrawable) {
+	ErrorF("source-only mask\n");
+	goto fail;
+    }
+    if (source->alphaMap) {
+	ErrorF("source alphaMap\n");
+	goto fail;
+    }
+    if (mask && mask->alphaMap) {
+	ErrorF("mask alphaMap\n");
+	goto fail;
+    }
+
+    source_pixmap = glamor_get_drawable_pixmap(source->pDrawable);
+    source_pixmap_priv = glamor_get_pixmap_private(source_pixmap);
+    if (source_pixmap == dest_pixmap) {
+	ErrorF("source == dest\n");
+	goto fail;
+    }
+    if (!source_pixmap_priv || source_pixmap_priv->tex == 0) {
+	ErrorF("no FBO in source\n");
+	goto fail;
+    }
+    if (mask) {
+	mask_pixmap = glamor_get_drawable_pixmap(mask->pDrawable);
+	mask_pixmap_priv = glamor_get_pixmap_private(mask_pixmap);
+	if (mask_pixmap == dest_pixmap) {
+	    ErrorF("mask == dest\n");
+	    goto fail;
+	}
+	if (!mask_pixmap_priv || mask_pixmap_priv->tex == 0) {
+	    ErrorF("no FBO in mask\n");
+	    goto fail;
+	}
+    }
+
+    shader = glamor_lookup_composite_shader(screen, &key);
+    if (shader->prog == 0) {
+	ErrorF("No program compiled for this render accel mode\n");
+	goto fail;
+    }
+
+    glUseProgramObjectARB(shader->prog);
+
+    if (!glamor_set_destination_pixmap(dest_pixmap))
+	goto fail;
+
+    if (!glamor_set_composite_op(screen, op, dest, mask)) {
+	goto fail;
+    }
+
+    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;
+    }
+
+    gluOrtho6f(&dest_to_dest,
+	       dest_pixmap->screen_x, dest_pixmap->screen_x + width,
+	       dest_pixmap->screen_y, dest_pixmap->screen_y + height,
+	       -1, 1);
+    glUniformMatrix4fvARB(shader->dest_to_dest_uniform_location, 1, 0,
+			  (float *)&dest_to_dest);
+    glamor_set_composite_transform_matrix(&dest_to_source,
+					  source,
+					  x_source - x_dest,
+					  y_source - x_dest);
+    glUniformMatrix4fvARB(shader->dest_to_source_uniform_location, 1, 0,
+			  (float *)&dest_to_source);
+
+    if (mask) {
+	glamor_set_composite_transform_matrix(&dest_to_mask,
+					      mask,
+					      x_mask - x_dest,
+					      y_mask - x_dest);
+	glUniformMatrix4fvARB(shader->dest_to_mask_uniform_location, 1, 0,
+			      (float *)&dest_to_mask);
+    }
+
+    glamor_set_composite_texture(screen, 0, source, source_pixmap_priv);
+    if (mask)
+	glamor_set_composite_texture(screen, 1, mask, mask_pixmap_priv);
+
+    if (!miComputeCompositeRegion(&region,
+				  source, mask, dest,
+				  x_source, y_source,
+				  x_mask, y_mask,
+				  x_dest, y_dest,
+				  width, height))
+	return;
+
+    glBegin(GL_QUADS);
+    for (i = 0; i < REGION_NUM_RECTS(&region); i++) {
+	BoxPtr box = &REGION_RECTS(&region)[i];
+	glVertex2i(box->x1, box->y1);
+	glVertex2i(box->x2, box->y1);
+	glVertex2i(box->x2, box->y2);
+	glVertex2i(box->x1, box->y2);
+    }
+    glEnd();
+
+    glamor_set_composite_op(screen, PictOpSrc, dest, mask);
+    glUseProgramObjectARB(0);
+		REGION_UNINIT(pDst->pDrawable->pScreen, &region);
+
+    return;
+
+fail:
+    glamor_set_composite_op(screen, PictOpSrc, dest, mask);
+    glUseProgramObjectARB(0);
+    glamor_solid_fail_region(dest_pixmap, x_dest, y_dest, width, height);
+}
+
+
+/**
+ * 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, width, height,
+				  pict_format->depth,
+				  0);
+    if (!pixmap)
+	return 0;
+    picture = CreatePicture(0, &pixmap->drawable, pict_format,
+			    0, 0, serverClient, &error);
+    screen->DestroyPixmap(pixmap);
+    return picture;