2009-08-25 21:10:32 +02:00
|
|
|
/*
|
|
|
|
* 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"
|
2010-02-08 11:23:14 +01:00
|
|
|
#include "fbpict.h"
|
2009-08-25 21:10:32 +02:00
|
|
|
|
|
|
|
#include "glu3/glu3.h"
|
|
|
|
|
|
|
|
struct shader_key {
|
2009-09-05 03:43:52 +02:00
|
|
|
Bool solid_source;
|
2009-08-25 21:10:32 +02:00
|
|
|
Bool has_mask;
|
2009-09-05 03:43:52 +02:00
|
|
|
Bool solid_mask;
|
2009-08-25 21:10:32 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
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},
|
|
|
|
};
|
|
|
|
|
2009-09-05 03:43:52 +02:00
|
|
|
#define SOLID_SOURCE_INDEX 1
|
|
|
|
#define HAS_MASK_INDEX 2
|
|
|
|
#define SOLID_MASK_INDEX 3
|
2009-08-25 21:10:32 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2009-09-05 03:43:52 +02:00
|
|
|
if (key->solid_source)
|
|
|
|
index += SOLID_SOURCE_INDEX;
|
|
|
|
if (key->has_mask) {
|
2009-08-25 21:10:32 +02:00
|
|
|
index += HAS_MASK_INDEX;
|
2009-09-05 03:43:52 +02:00
|
|
|
if (key->solid_mask)
|
|
|
|
index += SOLID_MASK_INDEX;
|
|
|
|
}
|
2009-08-25 21:10:32 +02:00
|
|
|
|
|
|
|
assert(index < ARRAY_SIZE(glamor_priv->composite_shader));
|
|
|
|
|
|
|
|
return &glamor_priv->composite_shader[index];
|
|
|
|
}
|
|
|
|
|
|
|
|
static GLuint
|
|
|
|
glamor_create_composite_fs(struct shader_key *key)
|
|
|
|
{
|
2009-09-05 03:43:52 +02:00
|
|
|
const char *source_pixmap_header =
|
2009-08-25 21:10:32 +02:00
|
|
|
"uniform sampler2D source_sampler;\n"
|
|
|
|
"varying vec4 source_coords;\n";
|
2009-09-05 03:43:52 +02:00
|
|
|
const char *source_solid_header =
|
|
|
|
"uniform vec4 source;\n";
|
|
|
|
const char *mask_pixmap_header =
|
2009-08-25 21:10:32 +02:00
|
|
|
"uniform sampler2D mask_sampler;\n"
|
|
|
|
"varying vec4 mask_coords;\n";
|
2009-09-05 03:43:52 +02:00
|
|
|
const char *mask_solid_header =
|
|
|
|
"uniform vec4 mask;\n";
|
2009-08-25 21:10:32 +02:00
|
|
|
const char *main_opening =
|
|
|
|
"void main()\n"
|
2009-09-05 03:43:52 +02:00
|
|
|
"{\n";
|
|
|
|
const char *source_pixmap_fetch =
|
|
|
|
" vec4 source = texture2DProj(source_sampler, "
|
|
|
|
" source_coords.xyw);\n";
|
|
|
|
const char *mask_pixmap_fetch =
|
|
|
|
" vec4 mask = texture2DProj(mask_sampler, mask_coords.xyw);\n";
|
2009-08-25 21:10:32 +02:00
|
|
|
const char *source_in_mask =
|
2009-09-05 03:43:52 +02:00
|
|
|
" gl_FragColor = source * mask.w;\n";
|
|
|
|
const char *source_only =
|
|
|
|
" gl_FragColor = source;\n";
|
2009-08-25 21:10:32 +02:00
|
|
|
const char *main_closing =
|
|
|
|
"}\n";
|
|
|
|
char *source;
|
2009-09-05 03:43:52 +02:00
|
|
|
const char *source_setup = "";
|
|
|
|
const char *source_fetch = "";
|
|
|
|
const char *mask_setup = "";
|
|
|
|
const char *mask_fetch = "";
|
2009-08-25 21:10:32 +02:00
|
|
|
GLuint prog;
|
|
|
|
|
2009-09-05 03:43:52 +02:00
|
|
|
if (key->solid_source) {
|
|
|
|
source_setup = source_solid_header;
|
|
|
|
} else {
|
|
|
|
source_setup = source_pixmap_header;
|
|
|
|
source_fetch = source_pixmap_fetch;
|
|
|
|
}
|
|
|
|
if (key->has_mask) {
|
|
|
|
if (key->solid_mask) {
|
|
|
|
mask_setup = mask_solid_header;
|
|
|
|
} else {
|
|
|
|
mask_setup = mask_pixmap_header;
|
|
|
|
mask_fetch = mask_pixmap_fetch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
source = XNFprintf("%s%s%s%s%s%s%s",
|
|
|
|
source_setup,
|
|
|
|
mask_setup,
|
2009-08-25 21:10:32 +02:00
|
|
|
main_opening,
|
2009-09-05 03:43:52 +02:00
|
|
|
source_fetch,
|
|
|
|
mask_fetch,
|
|
|
|
key->has_mask ? source_in_mask : source_only,
|
2009-08-25 21:10:32 +02:00
|
|
|
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;
|
2009-09-05 03:43:52 +02:00
|
|
|
Bool compute_mask_coords = key->has_mask && !key->solid_mask;
|
2009-08-25 21:10:32 +02:00
|
|
|
|
|
|
|
source = XNFprintf("%s%s%s%s%s",
|
|
|
|
header,
|
2009-09-05 03:43:52 +02:00
|
|
|
compute_mask_coords ? mask_header : "",
|
2009-08-25 21:10:32 +02:00
|
|
|
main_opening,
|
2009-09-05 03:43:52 +02:00
|
|
|
compute_mask_coords ? mask_coords : "",
|
2009-08-25 21:10:32 +02:00
|
|
|
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);
|
|
|
|
shader->dest_to_dest_uniform_location =
|
|
|
|
glGetUniformLocationARB(prog, "dest_to_dest");
|
2009-09-05 03:43:52 +02:00
|
|
|
|
|
|
|
if (key->solid_source) {
|
|
|
|
shader->source_uniform_location = glGetUniformLocationARB(prog,
|
|
|
|
"source");
|
|
|
|
} else {
|
|
|
|
source_sampler_uniform_location = glGetUniformLocationARB(prog,
|
|
|
|
"source_sampler");
|
|
|
|
shader->dest_to_source_uniform_location =
|
|
|
|
glGetUniformLocationARB(prog, "dest_to_source");
|
|
|
|
glUniform1i(source_sampler_uniform_location, 0);
|
|
|
|
}
|
2009-08-25 21:10:32 +02:00
|
|
|
|
|
|
|
if (key->has_mask) {
|
2009-09-05 03:43:52 +02:00
|
|
|
if (key->solid_mask) {
|
|
|
|
shader->mask_uniform_location = glGetUniformLocationARB(prog,
|
|
|
|
"mask");
|
|
|
|
} else {
|
|
|
|
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");
|
|
|
|
}
|
2009-08-25 21:10:32 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
glamor_init_composite_shaders(ScreenPtr screen)
|
|
|
|
{
|
|
|
|
struct shader_key key;
|
|
|
|
|
2009-09-05 03:43:52 +02:00
|
|
|
memset(&key, 0, sizeof(key));
|
|
|
|
key.has_mask = FALSE;
|
|
|
|
glamor_create_composite_shader(screen, &key);
|
|
|
|
key.has_mask = TRUE;
|
|
|
|
glamor_create_composite_shader(screen, &key);
|
|
|
|
key.solid_mask = TRUE;
|
|
|
|
glamor_create_composite_shader(screen, &key);
|
|
|
|
|
|
|
|
key.solid_source = TRUE;
|
2009-08-25 21:10:32 +02:00
|
|
|
key.has_mask = FALSE;
|
|
|
|
glamor_create_composite_shader(screen, &key);
|
|
|
|
key.has_mask = TRUE;
|
|
|
|
glamor_create_composite_shader(screen, &key);
|
2009-09-05 03:43:52 +02:00
|
|
|
key.solid_mask = TRUE;
|
|
|
|
glamor_create_composite_shader(screen, &key);
|
2009-08-25 21:10:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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,
|
2009-09-05 03:43:52 +02:00
|
|
|
glamor_pixmap_private *pixmap_priv,
|
|
|
|
GLint transform_uniform_location,
|
|
|
|
int x_translate, int y_translate)
|
2009-08-25 21:10:32 +02:00
|
|
|
{
|
2009-09-05 03:43:52 +02:00
|
|
|
GLUmat4 transform;
|
|
|
|
|
2009-08-25 21:10:32 +02:00
|
|
|
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);
|
2009-09-05 03:43:52 +02:00
|
|
|
|
|
|
|
glamor_set_composite_transform_matrix(&transform,
|
|
|
|
picture,
|
|
|
|
x_translate,
|
|
|
|
y_translate);
|
|
|
|
glUniformMatrix4fvARB(transform_uniform_location, 1, 0,
|
|
|
|
(float *)&transform);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
glamor_set_composite_solid(PicturePtr picture, GLint uniform_location)
|
|
|
|
{
|
|
|
|
CARD32 c = picture->pSourcePict->solidFill.color; /* a8r8g8b8 */
|
|
|
|
float color[4]; /* rgba */
|
|
|
|
|
|
|
|
color[0] = ((c >> 16) & 0xff) / 255.0;
|
|
|
|
color[1] = ((c >> 8) & 0xff) / 255.0;
|
|
|
|
color[2] = ((c >> 0) & 0xff) / 255.0;
|
|
|
|
color[3] = ((c >> 24) & 0xff) / 255.0;
|
|
|
|
|
|
|
|
glUniform4fvARB(uniform_location, 1, color);
|
2009-08-25 21:10:32 +02:00
|
|
|
}
|
|
|
|
|
2010-02-08 21:46:49 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-02-08 21:52:35 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2010-02-08 22:05:51 +01:00
|
|
|
static Bool
|
|
|
|
glamor_composite_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 (!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(®ion,
|
|
|
|
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(®ion),
|
|
|
|
REGION_NUM_RECTS(®ion),
|
|
|
|
x_source - x_dest, y_source - y_dest,
|
|
|
|
FALSE, FALSE, 0, NULL);
|
|
|
|
REGION_UNINIT(dest->pDrawable->pScreen,
|
|
|
|
®ion);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2009-08-25 21:10:32 +02:00
|
|
|
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;
|
2009-09-05 03:43:52 +02:00
|
|
|
glamor_pixmap_private *source_pixmap_priv = NULL;
|
|
|
|
glamor_pixmap_private *mask_pixmap_priv = NULL;
|
2009-08-25 21:10:32 +02:00
|
|
|
struct shader_key key;
|
|
|
|
glamor_composite_shader *shader;
|
2009-09-05 03:43:52 +02:00
|
|
|
GLUmat4 dest_to_dest;
|
2009-08-25 21:10:32 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-02-08 21:46:49 +01:00
|
|
|
if (!mask) {
|
2010-02-08 22:05:51 +01:00
|
|
|
if (glamor_composite_copy(op, source, dest,
|
|
|
|
x_source, y_source,
|
|
|
|
x_dest, y_dest,
|
|
|
|
width, height))
|
|
|
|
return;
|
2010-02-08 21:46:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
goto fail;
|
|
|
|
|
2009-09-05 03:43:52 +02:00
|
|
|
memset(&key, 0, sizeof(key));
|
2009-08-25 21:10:32 +02:00
|
|
|
key.has_mask = (mask != NULL);
|
|
|
|
if (!source->pDrawable) {
|
2009-09-05 03:43:52 +02:00
|
|
|
if (source->pSourcePict->type == SourcePictTypeSolidFill) {
|
|
|
|
key.solid_source = TRUE;
|
|
|
|
} else {
|
|
|
|
ErrorF("gradient source\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
2009-08-25 21:10:32 +02:00
|
|
|
}
|
|
|
|
if (mask && !mask->pDrawable) {
|
2009-09-05 03:43:52 +02:00
|
|
|
if (mask->pSourcePict->type == SourcePictTypeSolidFill) {
|
|
|
|
key.solid_mask = TRUE;
|
|
|
|
} else {
|
|
|
|
ErrorF("gradient mask\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
2009-08-25 21:10:32 +02:00
|
|
|
}
|
|
|
|
if (source->alphaMap) {
|
|
|
|
ErrorF("source alphaMap\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (mask && mask->alphaMap) {
|
|
|
|
ErrorF("mask alphaMap\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2009-09-05 03:43:52 +02:00
|
|
|
if (!key.solid_source) {
|
|
|
|
source_pixmap = glamor_get_drawable_pixmap(source->pDrawable);
|
|
|
|
source_pixmap_priv = glamor_get_pixmap_private(source_pixmap);
|
|
|
|
if (source_pixmap == dest_pixmap) {
|
2010-02-08 11:23:14 +01:00
|
|
|
glamor_fallback("glamor_composite(): source == dest\n");
|
2009-09-05 03:43:52 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (!source_pixmap_priv || source_pixmap_priv->tex == 0) {
|
2010-02-08 11:23:14 +01:00
|
|
|
glamor_fallback("glamor_composite(): no FBO in source\n");
|
2009-09-05 03:43:52 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
2009-08-25 21:10:32 +02:00
|
|
|
}
|
2009-09-05 03:43:52 +02:00
|
|
|
if (mask && !key.solid_mask) {
|
2009-08-25 21:10:32 +02:00
|
|
|
mask_pixmap = glamor_get_drawable_pixmap(mask->pDrawable);
|
|
|
|
mask_pixmap_priv = glamor_get_pixmap_private(mask_pixmap);
|
|
|
|
if (mask_pixmap == dest_pixmap) {
|
2010-02-08 11:23:14 +01:00
|
|
|
glamor_fallback("glamor_composite(): mask == dest\n");
|
2009-08-25 21:10:32 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (!mask_pixmap_priv || mask_pixmap_priv->tex == 0) {
|
2010-02-08 11:23:14 +01:00
|
|
|
glamor_fallback("glamor_composite(): no FBO in mask\n");
|
2009-08-25 21:10:32 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
shader = glamor_lookup_composite_shader(screen, &key);
|
|
|
|
if (shader->prog == 0) {
|
2010-02-08 11:23:14 +01:00
|
|
|
glamor_fallback("glamor_composite(): "
|
|
|
|
"no shader program for this render acccel mode\n");
|
2009-08-25 21:10:32 +02:00
|
|
|
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);
|
|
|
|
|
2009-09-05 03:43:52 +02:00
|
|
|
if (key.solid_source) {
|
|
|
|
glamor_set_composite_solid(source, shader->source_uniform_location);
|
|
|
|
} else {
|
|
|
|
glamor_set_composite_texture(screen, 0, source, source_pixmap_priv,
|
|
|
|
shader->dest_to_source_uniform_location,
|
|
|
|
x_source - x_dest, y_source - y_dest);
|
|
|
|
}
|
|
|
|
if (key.has_mask) {
|
|
|
|
if (key.solid_mask) {
|
|
|
|
glamor_set_composite_solid(mask, shader->mask_uniform_location);
|
|
|
|
} else {
|
|
|
|
glamor_set_composite_texture(screen, 1, mask, mask_pixmap_priv,
|
|
|
|
shader->dest_to_mask_uniform_location,
|
|
|
|
x_mask - x_dest, y_mask - y_dest);
|
|
|
|
}
|
|
|
|
}
|
2009-08-25 21:10:32 +02:00
|
|
|
|
|
|
|
if (!miComputeCompositeRegion(®ion,
|
|
|
|
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(®ion); i++) {
|
|
|
|
BoxPtr box = ®ION_RECTS(®ion)[i];
|
|
|
|
glVertex2i(box->x1, box->y1);
|
|
|
|
glVertex2i(box->x2, box->y1);
|
|
|
|
glVertex2i(box->x2, box->y2);
|
|
|
|
glVertex2i(box->x1, box->y2);
|
|
|
|
}
|
|
|
|
glEnd();
|
|
|
|
|
2009-09-05 03:43:52 +02:00
|
|
|
glDisable(GL_BLEND);
|
2009-08-25 21:10:32 +02:00
|
|
|
glUseProgramObjectARB(0);
|
2009-09-05 03:43:52 +02:00
|
|
|
REGION_UNINIT(pDst->pDrawable->pScreen, ®ion);
|
2009-08-25 21:10:32 +02:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
2010-02-08 11:23:14 +01:00
|
|
|
glamor_fallback("glamor_composite(): "
|
2010-02-08 21:52:35 +01:00
|
|
|
"from picts %p/%p(%c,%c) to pict %p (%c)\n",
|
|
|
|
source, mask,
|
|
|
|
glamor_get_picture_location(source),
|
|
|
|
glamor_get_picture_location(mask),
|
|
|
|
dest,
|
|
|
|
glamor_get_picture_location(dest));
|
2010-02-08 11:23:14 +01:00
|
|
|
|
2009-08-25 21:10:32 +02:00
|
|
|
glUseProgramObjectARB(0);
|
2010-02-08 11:23:14 +01:00
|
|
|
if (glamor_prepare_access(dest->pDrawable, GLAMOR_ACCESS_RW)) {
|
|
|
|
if (source->pDrawable == NULL ||
|
|
|
|
glamor_prepare_access(source->pDrawable, GLAMOR_ACCESS_RO))
|
|
|
|
{
|
|
|
|
if (!mask || mask->pDrawable == NULL ||
|
|
|
|
glamor_prepare_access(mask->pDrawable, GLAMOR_ACCESS_RO))
|
|
|
|
{
|
|
|
|
fbComposite(op,
|
|
|
|
source, mask, dest,
|
|
|
|
x_source, y_source,
|
|
|
|
x_mask, y_mask,
|
|
|
|
x_dest, y_dest,
|
|
|
|
width, height);
|
|
|
|
if (mask && mask->pDrawable != NULL)
|
|
|
|
glamor_finish_access(mask->pDrawable);
|
|
|
|
}
|
|
|
|
if (source->pDrawable != NULL)
|
|
|
|
glamor_finish_access(source->pDrawable);
|
|
|
|
}
|
|
|
|
glamor_finish_access(dest->pDrawable);
|
|
|
|
}
|
2009-08-25 21:10:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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++)
|
|
|
|
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 = (width * BitsPerPixel(mask_format->depth) + 7) / 8;
|
|
|
|
|
|
|
|
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 = GetScratchPixmapHeader(screen, width, height,
|
|
|
|
mask_format->depth,
|
|
|
|
BitsPerPixel(mask_format->depth),
|
|
|
|
PixmapBytePad(width, mask_format->depth),
|
|
|
|
pixman_image_get_data(image));
|
|
|
|
if (!pixmap) {
|
|
|
|
FreePicture(picture, 0);
|
|
|
|
pixman_image_unref(image);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
gc = GetScratchGC(picture->pDrawable->depth, screen);
|
|
|
|
if (!gc) {
|
|
|
|
FreeScratchPixmapHeader(pixmap);
|
|
|
|
pixman_image_unref (image);
|
|
|
|
FreePicture(picture, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ValidateGC(picture->pDrawable, gc);
|
|
|
|
|
|
|
|
gc->ops->CopyArea(&pixmap->drawable, picture->pDrawable,
|
|
|
|
gc, 0, 0, width, height, 0, 0);
|
|
|
|
|
|
|
|
FreeScratchGC(gc);
|
|
|
|
FreeScratchPixmapHeader(pixmap);
|
|
|
|
pixman_image_unref(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);
|
|
|
|
FreePicture(picture, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* RENDER */
|