3add375065
This patch fixed two major problems when we do the color convesion with
GLES2.
1. lack of necessary formats in FBO pool.
GLES2 has three different possible texture formats, GL_RGBA,
GL_BGRA and GL_ALPHA. Previous implementation only has one bucket
for all the three formats which may reuse a incorrect texture format
when do the cache lookup. After this fix, we can enable fbo safely
when running with GLES2.
2. Refine the format matching method in
glamor_get_tex_format_type_from_pictformat.
If both revertion and swap_rb are needed, for example use GL_RGBA
to represent PICT_b8g8r8a8. Then the downloading and uploading should
be handled differently.
The picture's format is PICT_b8g8r8a8,
Then the expecting color layout is as below (little endian):
0 1 2 3 : address
a r g b
Now the in GLES2 the supported color format is GL_RGBA, type is
GL_UNSIGNED_TYPE, then we need to shuffle the fragment
color as :
frag_color = sample(texture).argb;
before we use glReadPixel to get it back.
For the uploading process, the shuffle is a revert shuffle.
We still use GL_RGBA, GL_UNSIGNED_BYTE to upload the color
to a texture, then let's see
0 1 2 3 : address
a r g b : correct colors
R G B A : GL_RGBA with GL_UNSIGNED_BYTE
Now we need to shuffle again, the mapping rule is
r = G, g = B, b = A, a = R. Then the uploading shuffle is as
below:
frag_color = sample(texture).gbar;
After this commit, gles2 version can pass render check with all
the formats except those 1555/2101010.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
491 lines
14 KiB
C
491 lines
14 KiB
C
/*
|
|
* Copyright © 2008 Intel Corporation
|
|
* Copyright © 1998 Keith Packard
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of Keith Packard not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. Keith Packard makes no
|
|
* representations about the suitability of this software for any purpose. It
|
|
* is provided "as is" without express or implied warranty.
|
|
*
|
|
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include "glamor_priv.h"
|
|
|
|
/** @file glamor_copyarea.c
|
|
*
|
|
* GC CopyArea implementation
|
|
*/
|
|
#ifndef GLAMOR_GLES2
|
|
static Bool
|
|
glamor_copy_n_to_n_fbo_blit(DrawablePtr src,
|
|
DrawablePtr dst,
|
|
GCPtr gc, BoxPtr box, int nbox, int dx, int dy)
|
|
{
|
|
ScreenPtr screen = dst->pScreen;
|
|
PixmapPtr dst_pixmap = glamor_get_drawable_pixmap(dst);
|
|
PixmapPtr src_pixmap = glamor_get_drawable_pixmap(src);
|
|
glamor_pixmap_private *src_pixmap_priv;
|
|
glamor_screen_private *glamor_priv =
|
|
glamor_get_screen_private(screen);
|
|
glamor_gl_dispatch *dispatch;
|
|
int dst_x_off, dst_y_off, src_x_off, src_y_off, i;
|
|
|
|
if (!glamor_priv->has_fbo_blit) {
|
|
glamor_delayed_fallback(screen,
|
|
"no EXT_framebuffer_blit\n");
|
|
return FALSE;
|
|
}
|
|
src_pixmap_priv = glamor_get_pixmap_private(src_pixmap);
|
|
|
|
if (src_pixmap_priv->pending_op.type == GLAMOR_PENDING_FILL)
|
|
return FALSE;
|
|
|
|
if (gc) {
|
|
if (gc->alu != GXcopy) {
|
|
glamor_delayed_fallback(screen, "non-copy ALU\n");
|
|
return FALSE;
|
|
}
|
|
if (!glamor_pm_is_solid(dst, gc->planemask)) {
|
|
glamor_delayed_fallback(screen,
|
|
"non-solid planemask\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(src_pixmap_priv)) {
|
|
glamor_delayed_fallback(screen, "no src fbo\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if (glamor_set_destination_pixmap(dst_pixmap)) {
|
|
return FALSE;
|
|
}
|
|
glamor_validate_pixmap(dst_pixmap);
|
|
|
|
dispatch = glamor_get_dispatch(glamor_priv);
|
|
dispatch->glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT,
|
|
src_pixmap_priv->fbo->fb);
|
|
glamor_get_drawable_deltas(dst, dst_pixmap, &dst_x_off,
|
|
&dst_y_off);
|
|
glamor_get_drawable_deltas(src, src_pixmap, &src_x_off,
|
|
&src_y_off);
|
|
src_y_off += dy;
|
|
|
|
for (i = 0; i < nbox; i++) {
|
|
if (glamor_priv->yInverted) {
|
|
dispatch->glBlitFramebuffer((box[i].x1 + dx +
|
|
src_x_off),
|
|
(box[i].y1 +
|
|
src_y_off),
|
|
(box[i].x2 + dx +
|
|
src_x_off),
|
|
(box[i].y2 +
|
|
src_y_off),
|
|
(box[i].x1 +
|
|
dst_x_off),
|
|
(box[i].y1 +
|
|
dst_y_off),
|
|
(box[i].x2 +
|
|
dst_x_off),
|
|
(box[i].y2 +
|
|
dst_y_off),
|
|
GL_COLOR_BUFFER_BIT,
|
|
GL_NEAREST);
|
|
} else {
|
|
int flip_dst_y1 =
|
|
dst_pixmap->drawable.height - (box[i].y2 +
|
|
dst_y_off);
|
|
int flip_dst_y2 =
|
|
dst_pixmap->drawable.height - (box[i].y1 +
|
|
dst_y_off);
|
|
int flip_src_y1 =
|
|
src_pixmap->drawable.height - (box[i].y2 +
|
|
src_y_off);
|
|
int flip_src_y2 =
|
|
src_pixmap->drawable.height - (box[i].y1 +
|
|
src_y_off);
|
|
|
|
dispatch->glBlitFramebuffer(box[i].x1 + dx +
|
|
src_x_off,
|
|
flip_src_y1,
|
|
box[i].x2 + dx +
|
|
src_x_off,
|
|
flip_src_y2,
|
|
box[i].x1 +
|
|
dst_x_off,
|
|
flip_dst_y1,
|
|
box[i].x2 +
|
|
dst_x_off,
|
|
flip_dst_y2,
|
|
GL_COLOR_BUFFER_BIT,
|
|
GL_NEAREST);
|
|
}
|
|
}
|
|
glamor_put_dispatch(glamor_priv);
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
static Bool
|
|
glamor_copy_n_to_n_textured(DrawablePtr src,
|
|
DrawablePtr dst,
|
|
GCPtr gc, BoxPtr box, int nbox, int dx, int dy)
|
|
{
|
|
glamor_screen_private *glamor_priv =
|
|
glamor_get_screen_private(dst->pScreen);
|
|
glamor_gl_dispatch *dispatch;
|
|
PixmapPtr src_pixmap = glamor_get_drawable_pixmap(src);
|
|
PixmapPtr dst_pixmap = glamor_get_drawable_pixmap(dst);
|
|
int i;
|
|
float vertices[8], texcoords[8];
|
|
glamor_pixmap_private *src_pixmap_priv;
|
|
glamor_pixmap_private *dst_pixmap_priv;
|
|
int src_x_off, src_y_off, dst_x_off, dst_y_off;
|
|
enum glamor_pixmap_status src_status = GLAMOR_NONE;
|
|
GLfloat dst_xscale, dst_yscale, src_xscale, src_yscale;
|
|
int flush_needed = 0;
|
|
int alu = GXcopy;
|
|
|
|
src_pixmap_priv = glamor_get_pixmap_private(src_pixmap);
|
|
dst_pixmap_priv = glamor_get_pixmap_private(dst_pixmap);
|
|
|
|
if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(dst_pixmap_priv)) {
|
|
glamor_delayed_fallback(dst->pScreen, "dst has no fbo.\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!src_pixmap_priv || !src_pixmap_priv->gl_fbo) {
|
|
#ifndef GLAMOR_PIXMAP_DYNAMIC_UPLOAD
|
|
glamor_delayed_fallback(dst->pScreen, "src has no fbo.\n");
|
|
return FALSE;
|
|
#else
|
|
src_status = glamor_upload_pixmap_to_texture(src_pixmap);
|
|
if (src_status != GLAMOR_UPLOAD_DONE)
|
|
return FALSE;
|
|
|
|
src_pixmap_priv = glamor_get_pixmap_private(src_pixmap);
|
|
#endif
|
|
} else
|
|
flush_needed = 1;
|
|
|
|
if (gc) {
|
|
if (!glamor_set_planemask(dst_pixmap, gc->planemask))
|
|
return FALSE;
|
|
alu = gc->alu;
|
|
}
|
|
|
|
pixmap_priv_get_scale(dst_pixmap_priv, &dst_xscale, &dst_yscale);
|
|
pixmap_priv_get_scale(src_pixmap_priv, &src_xscale, &src_yscale);
|
|
|
|
glamor_get_drawable_deltas(dst, dst_pixmap, &dst_x_off,
|
|
&dst_y_off);
|
|
|
|
dispatch = glamor_get_dispatch(glamor_priv);
|
|
|
|
glamor_set_alu(dispatch, alu);
|
|
if (alu != GXcopy) {
|
|
glamor_set_destination_pixmap_priv_nc (src_pixmap_priv);
|
|
glamor_validate_pixmap(src_pixmap);
|
|
}
|
|
glamor_set_destination_pixmap_priv_nc(dst_pixmap_priv);
|
|
glamor_validate_pixmap(dst_pixmap);
|
|
dispatch->glVertexAttribPointer(GLAMOR_VERTEX_POS, 2, GL_FLOAT,
|
|
GL_FALSE, 2 * sizeof(float),
|
|
vertices);
|
|
dispatch->glEnableVertexAttribArray(GLAMOR_VERTEX_POS);
|
|
|
|
if (GLAMOR_PIXMAP_PRIV_NO_PENDING(src_pixmap_priv)) {
|
|
glamor_get_drawable_deltas(src, src_pixmap, &src_x_off,
|
|
&src_y_off);
|
|
dx += src_x_off;
|
|
dy += src_y_off;
|
|
pixmap_priv_get_scale(src_pixmap_priv, &src_xscale,
|
|
&src_yscale);
|
|
|
|
dispatch->glActiveTexture(GL_TEXTURE0);
|
|
dispatch->glBindTexture(GL_TEXTURE_2D,
|
|
src_pixmap_priv->fbo->tex);
|
|
#ifndef GLAMOR_GLES2
|
|
dispatch->glEnable(GL_TEXTURE_2D);
|
|
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
|
|
dispatch->glTexParameteri(GL_TEXTURE_2D,
|
|
GL_TEXTURE_MIN_FILTER,
|
|
GL_NEAREST);
|
|
dispatch->glTexParameteri(GL_TEXTURE_2D,
|
|
GL_TEXTURE_MAG_FILTER,
|
|
GL_NEAREST);
|
|
|
|
dispatch->glVertexAttribPointer(GLAMOR_VERTEX_SOURCE, 2,
|
|
GL_FLOAT, GL_FALSE,
|
|
2 * sizeof(float),
|
|
texcoords);
|
|
dispatch->glEnableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
|
|
dispatch->glUseProgram(glamor_priv->finish_access_prog[0]);
|
|
dispatch->glUniform1i(glamor_priv->finish_access_revert[0],
|
|
REVERT_NONE);
|
|
dispatch->glUniform1i(glamor_priv->finish_access_swap_rb[0],
|
|
SWAP_NONE_UPLOADING);
|
|
} else {
|
|
GLAMOR_CHECK_PENDING_FILL(dispatch, glamor_priv,
|
|
src_pixmap_priv);
|
|
}
|
|
|
|
for (i = 0; i < nbox; i++) {
|
|
|
|
glamor_set_normalize_vcoords(dst_xscale, dst_yscale,
|
|
box[i].x1 + dst_x_off,
|
|
box[i].y1 + dst_y_off,
|
|
box[i].x2 + dst_x_off,
|
|
box[i].y2 + dst_y_off,
|
|
glamor_priv->yInverted,
|
|
vertices);
|
|
|
|
if (GLAMOR_PIXMAP_PRIV_NO_PENDING(src_pixmap_priv))
|
|
glamor_set_normalize_tcoords(src_xscale,
|
|
src_yscale,
|
|
box[i].x1 + dx,
|
|
box[i].y1 + dy,
|
|
box[i].x2 + dx,
|
|
box[i].y2 + dy,
|
|
glamor_priv->yInverted,
|
|
texcoords);
|
|
|
|
dispatch->glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
|
}
|
|
|
|
dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
|
|
if (GLAMOR_PIXMAP_PRIV_NO_PENDING(src_pixmap_priv)) {
|
|
dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
|
|
#ifndef GLAMOR_GLES2
|
|
dispatch->glDisable(GL_TEXTURE_2D);
|
|
#endif
|
|
}
|
|
dispatch->glUseProgram(0);
|
|
/* The source texture is bound to a fbo, we have to flush it here. */
|
|
if (flush_needed)
|
|
dispatch->glFlush();
|
|
glamor_put_dispatch(glamor_priv);
|
|
return TRUE;
|
|
}
|
|
|
|
static Bool
|
|
_glamor_copy_n_to_n(DrawablePtr src,
|
|
DrawablePtr dst,
|
|
GCPtr gc,
|
|
BoxPtr box,
|
|
int nbox,
|
|
int dx,
|
|
int dy,
|
|
Bool reverse,
|
|
Bool upsidedown, Pixel bitplane,
|
|
void *closure, Bool fallback)
|
|
{
|
|
glamor_access_t dst_access;
|
|
PixmapPtr dst_pixmap, src_pixmap, temp_pixmap = NULL;
|
|
DrawablePtr temp_src = src;
|
|
glamor_pixmap_private *dst_pixmap_priv, *src_pixmap_priv;
|
|
glamor_screen_private *glamor_priv;
|
|
BoxRec bound;
|
|
ScreenPtr screen;
|
|
int temp_dx = dx;
|
|
int temp_dy = dy;
|
|
int src_x_off, src_y_off, dst_x_off, dst_y_off;
|
|
int i;
|
|
int overlaped = 0;
|
|
Bool ret = FALSE;
|
|
|
|
dst_pixmap = glamor_get_drawable_pixmap(dst);
|
|
dst_pixmap_priv = glamor_get_pixmap_private(dst_pixmap);
|
|
src_pixmap = glamor_get_drawable_pixmap(src);
|
|
src_pixmap_priv = glamor_get_pixmap_private(src_pixmap);
|
|
screen = dst_pixmap->drawable.pScreen;
|
|
|
|
glamor_priv = glamor_get_screen_private(dst->pScreen);
|
|
|
|
if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(dst_pixmap_priv)) {
|
|
glamor_fallback("dest pixmap %p has no fbo. \n",
|
|
dst_pixmap);
|
|
goto fail;
|
|
}
|
|
|
|
if (!src_pixmap_priv) {
|
|
glamor_set_pixmap_type(src_pixmap, GLAMOR_MEMORY);
|
|
src_pixmap_priv = glamor_get_pixmap_private(src_pixmap);
|
|
}
|
|
|
|
glamor_get_drawable_deltas(src, src_pixmap, &src_x_off,
|
|
&src_y_off);
|
|
glamor_get_drawable_deltas(dst, dst_pixmap, &dst_x_off,
|
|
&dst_y_off);
|
|
|
|
if (src_pixmap_priv->fbo && src_pixmap_priv->fbo->fb == dst_pixmap_priv->fbo->fb) {
|
|
int x_shift = abs(src_x_off - dx - dst_x_off);
|
|
int y_shift = abs(src_y_off - dy - dst_y_off);
|
|
for (i = 0; i < nbox; i++) {
|
|
if (x_shift < abs(box[i].x2 - box[i].x1)
|
|
&& y_shift < abs(box[i].y2 - box[i].y1)) {
|
|
overlaped = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/* XXX need revisit to handle overlapped area copying. */
|
|
#ifndef GLAMOR_GLES2
|
|
if ((overlaped
|
|
|| !src_pixmap_priv->gl_tex || !dst_pixmap_priv->gl_tex)
|
|
&& glamor_copy_n_to_n_fbo_blit(src, dst, gc, box, nbox, dx,
|
|
dy)) {
|
|
ret = TRUE;
|
|
goto done;
|
|
}
|
|
#endif
|
|
glamor_calculate_boxes_bound(&bound, box, nbox);
|
|
|
|
/* Overlaped indicate the src and dst are the same pixmap. */
|
|
if (overlaped || (!GLAMOR_PIXMAP_PRIV_HAS_FBO(src_pixmap_priv)
|
|
&& ((bound.x2 - bound.x1) * (bound.y2 - bound.y1)
|
|
* 4 >
|
|
src_pixmap->drawable.width *
|
|
src_pixmap->drawable.height))) {
|
|
|
|
temp_pixmap = glamor_create_pixmap(screen,
|
|
bound.x2 - bound.x1,
|
|
bound.y2 - bound.y1,
|
|
src_pixmap->
|
|
drawable.depth,
|
|
overlaped ? 0 :
|
|
GLAMOR_CREATE_PIXMAP_CPU);
|
|
if (!temp_pixmap)
|
|
goto fail;
|
|
glamor_transform_boxes(box, nbox, -bound.x1, -bound.y1);
|
|
temp_src = &temp_pixmap->drawable;
|
|
|
|
if (overlaped)
|
|
glamor_copy_n_to_n_textured(src, temp_src, gc, box,
|
|
nbox,
|
|
temp_dx + bound.x1,
|
|
temp_dy + bound.y1);
|
|
else
|
|
fbCopyNtoN(src, temp_src, gc, box, nbox,
|
|
temp_dx + bound.x1, temp_dy + bound.y1,
|
|
reverse, upsidedown, bitplane, closure);
|
|
glamor_transform_boxes(box, nbox, bound.x1, bound.y1);
|
|
temp_dx = -bound.x1;
|
|
temp_dy = -bound.y1;
|
|
} else {
|
|
temp_dx = dx;
|
|
temp_dy = dy;
|
|
temp_src = src;
|
|
}
|
|
|
|
if (glamor_copy_n_to_n_textured
|
|
(temp_src, dst, gc, box, nbox, temp_dx, temp_dy)) {
|
|
ret = TRUE;
|
|
goto done;
|
|
}
|
|
|
|
|
|
fail:
|
|
|
|
if (!fallback
|
|
&& glamor_ddx_fallback_check_pixmap(src)
|
|
&& glamor_ddx_fallback_check_pixmap(dst))
|
|
goto done;
|
|
|
|
glamor_report_delayed_fallbacks(src->pScreen);
|
|
glamor_report_delayed_fallbacks(dst->pScreen);
|
|
|
|
glamor_fallback("from %p to %p (%c,%c)\n", src, dst,
|
|
glamor_get_drawable_location(src),
|
|
glamor_get_drawable_location(dst));
|
|
|
|
if (gc && gc->alu != GXcopy)
|
|
dst_access = GLAMOR_ACCESS_RW;
|
|
else
|
|
dst_access = GLAMOR_ACCESS_WO;
|
|
|
|
if (glamor_prepare_access(dst, GLAMOR_ACCESS_RW)) {
|
|
if (dst == src
|
|
|| glamor_prepare_access(src, GLAMOR_ACCESS_RO)) {
|
|
fbCopyNtoN(src, dst, gc, box, nbox,
|
|
dx, dy, reverse, upsidedown, bitplane,
|
|
closure);
|
|
if (dst != src)
|
|
glamor_finish_access(src, GLAMOR_ACCESS_RO);
|
|
}
|
|
glamor_finish_access(dst, GLAMOR_ACCESS_RW);
|
|
}
|
|
ret = TRUE;
|
|
|
|
done:
|
|
glamor_clear_delayed_fallbacks(src->pScreen);
|
|
glamor_clear_delayed_fallbacks(dst->pScreen);
|
|
if (temp_src != src)
|
|
glamor_destroy_pixmap(temp_pixmap);
|
|
return ret;
|
|
}
|
|
|
|
RegionPtr
|
|
glamor_copy_area(DrawablePtr src, DrawablePtr dst, GCPtr gc,
|
|
int srcx, int srcy, int width, int height, int dstx,
|
|
int dsty)
|
|
{
|
|
RegionPtr region;
|
|
region = miDoCopy(src, dst, gc,
|
|
srcx, srcy, width, height,
|
|
dstx, dsty, glamor_copy_n_to_n, 0, NULL);
|
|
|
|
return region;
|
|
}
|
|
|
|
void
|
|
glamor_copy_n_to_n(DrawablePtr src,
|
|
DrawablePtr dst,
|
|
GCPtr gc,
|
|
BoxPtr box,
|
|
int nbox,
|
|
int dx,
|
|
int dy,
|
|
Bool reverse,
|
|
Bool upsidedown, Pixel bitplane,
|
|
void *closure)
|
|
{
|
|
_glamor_copy_n_to_n(src, dst, gc, box, nbox, dx,
|
|
dy, reverse, upsidedown, bitplane, closure, TRUE);
|
|
}
|
|
|
|
Bool
|
|
glamor_copy_n_to_n_nf(DrawablePtr src,
|
|
DrawablePtr dst,
|
|
GCPtr gc,
|
|
BoxPtr box,
|
|
int nbox,
|
|
int dx,
|
|
int dy,
|
|
Bool reverse,
|
|
Bool upsidedown, Pixel bitplane,
|
|
void *closure)
|
|
{
|
|
return _glamor_copy_n_to_n(src, dst, gc, box, nbox, dx,
|
|
dy, reverse, upsidedown, bitplane, closure, FALSE);
|
|
}
|
|
|