andreacavalli
/
xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
xserver-multidpi/glamor/glamor_picture.c

379 lines
12 KiB
C
Raw Permalink Blame History

/*
* Copyright © 2016 Broadcom
* Copyright © 2009 Intel Corporation
* Copyright © 1998 Keith Packard
*
* 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.
*/
/**
* @file glamor_picture.c
*
* Implements temporary uploads of GL_MEMORY Pixmaps to a texture that
* is swizzled appropriately for a given Render picture format.
* laid *
*
* This is important because GTK likes to use SHM Pixmaps for Render
* blending operations, and we don't want a blend operation to fall
* back to software (readback is more expensive than the upload we do
* here, and you'd have to re-upload the fallback output anyway).
*/
#include <stdlib.h>
#include "glamor_priv.h"
#include "mipict.h"
static void byte_swap_swizzle(GLenum *swizzle)
{
GLenum temp;
temp = swizzle[0];
swizzle[0] = swizzle[3];
swizzle[3] = temp;
temp = swizzle[1];
swizzle[1] = swizzle[2];
swizzle[2] = temp;
}
/**
* Returns the GL format and type for uploading our bits to a given PictFormat.
*
* We may need to tell the caller to translate the bits to another
* format, as in PICT_a1 (which GL doesn't support). We may also need
* to tell the GL to swizzle the texture on sampling, because GLES3
* doesn't support the GL_UNSIGNED_INT_8_8_8_8{,_REV} types, so we
* don't have enough channel reordering options at upload time without
* it.
*/
static Bool
glamor_get_tex_format_type_from_pictformat(ScreenPtr pScreen,
PictFormatShort format,
PictFormatShort *temp_format,
GLenum *tex_format,
GLenum *tex_type,
GLenum *swizzle)
{
glamor_screen_private *glamor_priv = glamor_get_screen_private(pScreen);
Bool is_little_endian = IMAGE_BYTE_ORDER == LSBFirst;
*temp_format = format;
swizzle[0] = GL_RED;
swizzle[1] = GL_GREEN;
swizzle[2] = GL_BLUE;
swizzle[3] = GL_ALPHA;
switch (format) {
case PICT_a1:
*tex_format = glamor_priv->formats[1].format;
*tex_type = GL_UNSIGNED_BYTE;
*temp_format = PICT_a8;
break;
case PICT_b8g8r8x8:
case PICT_b8g8r8a8:
if (!glamor_priv->is_gles) {
*tex_format = GL_BGRA;
*tex_type = GL_UNSIGNED_INT_8_8_8_8;
} else {
*tex_format = GL_RGBA;
*tex_type = GL_UNSIGNED_BYTE;
swizzle[0] = GL_GREEN;
swizzle[1] = GL_BLUE;
swizzle[2] = GL_ALPHA;
swizzle[3] = GL_RED;
if (!is_little_endian)
byte_swap_swizzle(swizzle);
}
break;
case PICT_x8r8g8b8:
case PICT_a8r8g8b8:
if (!glamor_priv->is_gles) {
*tex_format = GL_BGRA;
*tex_type = GL_UNSIGNED_INT_8_8_8_8_REV;
} else {
*tex_format = GL_RGBA;
*tex_type = GL_UNSIGNED_BYTE;
swizzle[0] = GL_BLUE;
swizzle[2] = GL_RED;
if (!is_little_endian)
byte_swap_swizzle(swizzle);
break;
}
break;
case PICT_x8b8g8r8:
case PICT_a8b8g8r8:
*tex_format = GL_RGBA;
if (!glamor_priv->is_gles) {
*tex_type = GL_UNSIGNED_INT_8_8_8_8_REV;
} else {
*tex_format = GL_RGBA;
*tex_type = GL_UNSIGNED_BYTE;
if (!is_little_endian)
byte_swap_swizzle(swizzle);
}
break;
case PICT_x2r10g10b10:
case PICT_a2r10g10b10:
if (!glamor_priv->is_gles) {
*tex_format = GL_BGRA;
*tex_type = GL_UNSIGNED_INT_2_10_10_10_REV;
} else {
return FALSE;
}
break;
case PICT_x2b10g10r10:
case PICT_a2b10g10r10:
if (!glamor_priv->is_gles) {
*tex_format = GL_RGBA;
*tex_type = GL_UNSIGNED_INT_2_10_10_10_REV;
} else {
return FALSE;
}
break;
case PICT_r5g6b5:
*tex_format = GL_RGB;
*tex_type = GL_UNSIGNED_SHORT_5_6_5;
break;
case PICT_b5g6r5:
*tex_format = GL_RGB;
if (!glamor_priv->is_gles) {
*tex_type = GL_UNSIGNED_SHORT_5_6_5_REV;
} else {
*tex_type = GL_UNSIGNED_SHORT_5_6_5;
swizzle[0] = GL_BLUE;
swizzle[2] = GL_RED;
}
break;
case PICT_x1b5g5r5:
case PICT_a1b5g5r5:
*tex_format = GL_RGBA;
if (!glamor_priv->is_gles) {
*tex_type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
} else {
return FALSE;
}
break;
case PICT_x1r5g5b5:
case PICT_a1r5g5b5:
if (!glamor_priv->is_gles) {
*tex_format = GL_BGRA;
*tex_type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
} else {
return FALSE;
}
break;
case PICT_a8:
*tex_format = glamor_priv->formats[8].format;
*tex_type = GL_UNSIGNED_BYTE;
break;
case PICT_x4r4g4b4:
case PICT_a4r4g4b4:
if (!glamor_priv->is_gles) {
*tex_format = GL_BGRA;
*tex_type = GL_UNSIGNED_SHORT_4_4_4_4_REV;
} else {
/* XXX */
*tex_format = GL_RGBA;
*tex_type = GL_UNSIGNED_SHORT_4_4_4_4;
}
break;
case PICT_x4b4g4r4:
case PICT_a4b4g4r4:
if (!glamor_priv->is_gles) {
*tex_format = GL_RGBA;
*tex_type = GL_UNSIGNED_SHORT_4_4_4_4_REV;
} else {
/* XXX */
*tex_format = GL_RGBA;
*tex_type = GL_UNSIGNED_SHORT_4_4_4_4;
}
break;
default:
return FALSE;
}
if (!PICT_FORMAT_A(format))
swizzle[3] = GL_ONE;
return TRUE;
}
/**
* Takes a set of source bits with a given format and returns an
* in-memory pixman image of those bits in a destination format.
*/
static pixman_image_t *
glamor_get_converted_image(PictFormatShort dst_format,
PictFormatShort src_format,
void *src_bits,
int src_stride,
int w, int h)
{
pixman_image_t *dst_image;
pixman_image_t *src_image;
dst_image = pixman_image_create_bits(dst_format, w, h, NULL, 0);
if (dst_image == NULL) {
return NULL;
}
src_image = pixman_image_create_bits(src_format, w, h, src_bits, src_stride);
if (src_image == NULL) {
pixman_image_unref(dst_image);
return NULL;
}
pixman_image_composite(PictOpSrc, src_image, NULL, dst_image,
0, 0, 0, 0, 0, 0, w, h);
pixman_image_unref(src_image);
return dst_image;
}
/**
* Uploads a picture based on a GLAMOR_MEMORY pixmap to a texture in a
* temporary FBO.
*/
Bool
glamor_upload_picture_to_texture(PicturePtr picture)
{
PixmapPtr pixmap = glamor_get_drawable_pixmap(picture->pDrawable);
ScreenPtr screen = pixmap->drawable.pScreen;
glamor_screen_private *glamor_priv = glamor_get_screen_private(screen);
glamor_pixmap_private *pixmap_priv = glamor_get_pixmap_private(pixmap);
PictFormatShort converted_format;
void *bits = pixmap->devPrivate.ptr;
int stride = pixmap->devKind;
GLenum format, type;
GLenum swizzle[4];
GLenum iformat;
Bool ret = TRUE;
Bool needs_swizzle;
pixman_image_t *converted_image = NULL;
const struct glamor_format *f = glamor_format_for_pixmap(pixmap);
assert(glamor_pixmap_is_memory(pixmap));
assert(!pixmap_priv->fbo);
glamor_make_current(glamor_priv);
/* No handling of large pixmap pictures here (would need to make
* an FBO array and split the uploads across it).
*/
if (!glamor_check_fbo_size(glamor_priv,
pixmap->drawable.width,
pixmap->drawable.height)) {
return FALSE;
}
if (!glamor_get_tex_format_type_from_pictformat(screen,
picture->format,
&converted_format,
&format,
&type,
swizzle)) {
glamor_fallback("Unknown pixmap depth %d.\n", pixmap->drawable.depth);
return FALSE;
}
needs_swizzle = (swizzle[0] != GL_RED ||
swizzle[1] != GL_GREEN ||
swizzle[2] != GL_BLUE ||
swizzle[3] != GL_ALPHA);
if (!glamor_priv->has_texture_swizzle && needs_swizzle) {
glamor_fallback("Couldn't upload temporary picture due to missing "
"GL_ARB_texture_swizzle.\n");
return FALSE;
}
if (converted_format != picture->format) {
converted_image = glamor_get_converted_image(converted_format,
picture->format,
bits, stride,
pixmap->drawable.width,
pixmap->drawable.height);
if (!converted_image)
return FALSE;
bits = pixman_image_get_data(converted_image);
stride = pixman_image_get_stride(converted_image);
}
if (!glamor_priv->is_gles)
iformat = f->internalformat;
else
iformat = format;
if (!glamor_pixmap_ensure_fbo(pixmap, GLAMOR_CREATE_FBO_NO_FBO)) {
ret = FALSE;
goto fail;
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glamor_priv->suppress_gl_out_of_memory_logging = true;
/* We can't use glamor_pixmap_loop() because GLAMOR_MEMORY pixmaps
* don't have initialized boxes.
*/
glBindTexture(GL_TEXTURE_2D, pixmap_priv->fbo->tex);
glTexImage2D(GL_TEXTURE_2D, 0, iformat,
pixmap->drawable.width, pixmap->drawable.height, 0,
format, type, bits);
if (needs_swizzle) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, swizzle[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, swizzle[1]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, swizzle[2]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, swizzle[3]);
}
glamor_priv->suppress_gl_out_of_memory_logging = false;
if (glGetError() == GL_OUT_OF_MEMORY) {
ret = FALSE;
}
fail:
if (converted_image)
pixman_image_unref(converted_image);
return ret;
}
Reference in New Issue View Git Blame Copy Permalink