Commit aa133069 authored by Eric Anholt's avatar Eric Anholt Committed by Zhigang Gong

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.
parent 4a51cc04
......@@ -2147,6 +2147,7 @@ Xi/Makefile
xfixes/Makefile
exa/Makefile
glamor/Makefile
glamor/glu3/Makefile
hw/Makefile
hw/xfree86/Makefile
hw/xfree86/common/Makefile
......
......@@ -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
......@@ -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;
......
......@@ -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,
......
/*
* 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;
}
/**
* 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;
GCPtr gc;
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++)