a228effbeb
As glVertexPointer is not supported by GLES2, I totally replaced it by VertexAttribArray. This commit remove those old code. Signed-off-by: Zhigang Gong <zhigang.gong@gmail.com>
879 lines
24 KiB
C
879 lines
24 KiB
C
/*
|
|
* Copyright © 2008 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>
|
|
*
|
|
*/
|
|
#ifndef GLAMOR_PRIV_H
|
|
#define GLAMOR_PRIV_H
|
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
#include <dix-config.h>
|
|
#include <xorg-config.h>
|
|
#endif
|
|
|
|
|
|
#include "glamor.h"
|
|
|
|
#ifdef GLAMOR_GLES2
|
|
|
|
#define GL_BGRA GL_BGRA_EXT
|
|
#define GL_COLOR_INDEX 0x1900
|
|
#define GL_BITMAP 0x1A00
|
|
#define GL_UNSIGNED_INT_8_8_8_8 0x8035
|
|
#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
|
|
#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
|
|
#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
|
|
#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
|
|
#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
|
|
|
|
#define GL_PIXEL_PACK_BUFFER 0x88EB
|
|
#define GL_PIXEL_UNPACK_BUFFER 0x88EC
|
|
#define GL_CLAMP_TO_BORDER 0x812D
|
|
|
|
#define GL_READ_WRITE 0x88BA
|
|
#define GL_READ_ONLY 0x88B8
|
|
#define GL_WRITE_ONLY 0x88B9
|
|
#define GL_STREAM_DRAW 0x88E0
|
|
#define GL_STREAM_READ 0x88E1
|
|
#define GL_PACK_ROW_LENGTH 0x0D02
|
|
#define GL_UNPACK_ROW_LENGTH 0x0CF2
|
|
|
|
#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
|
|
#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
|
|
#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
|
|
|
|
#define GL_PACK_INVERT_MESA 0x8758
|
|
|
|
#define glMapBuffer(x, y) NULL
|
|
#define glUnmapBuffer(x)
|
|
#define glRasterPos2i(x,y)
|
|
#define glDrawPixels(x,y,z,a,b)
|
|
|
|
#endif
|
|
|
|
#define GL_GLEXT_PROTOTYPES
|
|
#ifdef GLAMOR_GLES2
|
|
#include <GLES2/gl2.h>
|
|
#include <GLES2/gl2ext.h>
|
|
#else
|
|
#include <GL/gl.h>
|
|
#include <GL/glext.h>
|
|
#endif
|
|
|
|
|
|
#ifdef RENDER
|
|
#include "glyphstr.h"
|
|
#endif
|
|
|
|
|
|
#include "glamor_debug.h"
|
|
|
|
#define glamor_check_fbo_size(_glamor_,_w_, _h_) ((_w_) > 0 && (_h_) > 0 \
|
|
&& (_w_) < _glamor_->max_fbo_size \
|
|
&& (_h_) < _glamor_->max_fbo_size)
|
|
|
|
#define glamor_check_fbo_depth(_depth_) ( \
|
|
_depth_ == 8 \
|
|
|| _depth_ == 15 \
|
|
|| _depth_ == 16 \
|
|
|| _depth_ == 24 \
|
|
|| _depth_ == 30 \
|
|
|| _depth_ == 32)
|
|
|
|
|
|
#define GLAMOR_PIXMAP_PRIV_IS_PICTURE(pixmap_priv) (pixmap_priv->is_picture == 1)
|
|
#define GLAMOR_PIXMAP_PRIV_HAS_FBO(pixmap_priv) (pixmap_priv->gl_fbo == 1)
|
|
|
|
typedef struct glamor_transform_uniforms {
|
|
GLint x_bias;
|
|
GLint x_scale;
|
|
GLint y_bias;
|
|
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;
|
|
GLint source_uniform_location;
|
|
GLint mask_uniform_location;
|
|
} glamor_composite_shader;
|
|
|
|
typedef struct {
|
|
INT16 x_src;
|
|
INT16 y_src;
|
|
INT16 x_mask;
|
|
INT16 y_mask;
|
|
INT16 x_dst;
|
|
INT16 y_dst;
|
|
INT16 width;
|
|
INT16 height;
|
|
} glamor_composite_rect_t;
|
|
|
|
typedef struct {
|
|
unsigned char sha1[20];
|
|
} glamor_cached_glyph_t;
|
|
|
|
typedef struct {
|
|
/* The identity of the cache, statically configured at initialization */
|
|
unsigned int format;
|
|
int glyph_width;
|
|
int glyph_height;
|
|
|
|
/* Size of cache; eventually this should be dynamically determined */
|
|
int size;
|
|
|
|
/* Hash table mapping from glyph sha1 to position in the glyph; we use
|
|
* open addressing with a hash table size determined based on size and large
|
|
* enough so that we always have a good amount of free space, so we can
|
|
* use linear probing. (Linear probing is preferrable to double hashing
|
|
* here because it allows us to easily remove entries.)
|
|
*/
|
|
int *hash_entries;
|
|
int hash_size;
|
|
|
|
glamor_cached_glyph_t *glyphs;
|
|
int glyph_count; /* Current number of glyphs */
|
|
|
|
PicturePtr picture; /* Where the glyphs of the cache are stored */
|
|
int y_offset; /* y location within the picture where the cache starts */
|
|
int columns; /* Number of columns the glyphs are layed out in */
|
|
int eviction_position; /* Next random position to evict a glyph */
|
|
} glamor_glyph_cache_t;
|
|
|
|
#define GLAMOR_NUM_GLYPH_CACHES 4
|
|
|
|
enum glamor_vertex_type {
|
|
GLAMOR_VERTEX_POS,
|
|
GLAMOR_VERTEX_SOURCE,
|
|
GLAMOR_VERTEX_MASK
|
|
};
|
|
|
|
enum shader_source {
|
|
SHADER_SOURCE_SOLID,
|
|
SHADER_SOURCE_TEXTURE,
|
|
SHADER_SOURCE_TEXTURE_ALPHA,
|
|
SHADER_SOURCE_COUNT,
|
|
};
|
|
|
|
enum shader_mask {
|
|
SHADER_MASK_NONE,
|
|
SHADER_MASK_SOLID,
|
|
SHADER_MASK_TEXTURE,
|
|
SHADER_MASK_TEXTURE_ALPHA,
|
|
SHADER_MASK_COUNT,
|
|
};
|
|
|
|
enum shader_in {
|
|
SHADER_IN_SOURCE_ONLY,
|
|
SHADER_IN_NORMAL,
|
|
SHADER_IN_CA_SOURCE,
|
|
SHADER_IN_CA_ALPHA,
|
|
SHADER_IN_COUNT,
|
|
};
|
|
|
|
struct glamor_screen_private;
|
|
struct glamor_pixmap_private;
|
|
typedef void (*glamor_pixmap_validate_function_t)(struct glamor_screen_private*,
|
|
struct glamor_pixmap_private*);
|
|
|
|
enum glamor_gl_flavor {
|
|
GLAMOR_GL_DESKTOP, // OPENGL API
|
|
GLAMOR_GL_ES2 // OPENGL ES2.0 API
|
|
};
|
|
|
|
#define GLAMOR_CREATE_PIXMAP_CPU 0x100
|
|
typedef struct glamor_screen_private {
|
|
CloseScreenProcPtr saved_close_screen;
|
|
CreateGCProcPtr saved_create_gc;
|
|
CreatePixmapProcPtr saved_create_pixmap;
|
|
DestroyPixmapProcPtr saved_destroy_pixmap;
|
|
GetSpansProcPtr saved_get_spans;
|
|
GetImageProcPtr saved_get_image;
|
|
CompositeProcPtr saved_composite;
|
|
TrapezoidsProcPtr saved_trapezoids;
|
|
GlyphsProcPtr saved_glyphs;
|
|
ChangeWindowAttributesProcPtr saved_change_window_attributes;
|
|
CopyWindowProcPtr saved_copy_window;
|
|
BitmapToRegionProcPtr saved_bitmap_to_region;
|
|
TrianglesProcPtr saved_triangles;
|
|
CreatePictureProcPtr saved_create_picture;
|
|
DestroyPictureProcPtr saved_destroy_picture;
|
|
|
|
int yInverted;
|
|
int screen_fbo;
|
|
GLuint vbo;
|
|
int vbo_offset;
|
|
int vbo_size;
|
|
char *vb;
|
|
int vb_stride;
|
|
enum glamor_gl_flavor gl_flavor;
|
|
int has_pack_invert;
|
|
int has_fbo_blit;
|
|
int max_fbo_size;
|
|
|
|
/* glamor_finishaccess */
|
|
GLint finish_access_prog[2];
|
|
|
|
/* glamor_solid */
|
|
GLint solid_prog;
|
|
GLint solid_color_uniform_location;
|
|
|
|
/* glamor_tile */
|
|
GLint tile_prog;
|
|
|
|
/* glamor_putimage */
|
|
GLint put_image_xybitmap_prog;
|
|
glamor_transform_uniforms put_image_xybitmap_transform;
|
|
GLint put_image_xybitmap_fg_uniform_location;
|
|
GLint put_image_xybitmap_bg_uniform_location;
|
|
|
|
/* glamor_composite */
|
|
glamor_composite_shader composite_shader[SHADER_SOURCE_COUNT]
|
|
[SHADER_MASK_COUNT]
|
|
[SHADER_IN_COUNT];
|
|
Bool has_source_coords, has_mask_coords;
|
|
int render_nr_verts;
|
|
glamor_pixmap_validate_function_t *pixmap_validate_funcs;
|
|
glamor_glyph_cache_t glyph_caches[GLAMOR_NUM_GLYPH_CACHES];
|
|
char delayed_fallback_string[GLAMOR_DELAYED_STRING_MAX + 1];
|
|
int delayed_fallback_pending;
|
|
} glamor_screen_private;
|
|
|
|
typedef enum glamor_access {
|
|
GLAMOR_ACCESS_RO,
|
|
GLAMOR_ACCESS_RW,
|
|
GLAMOR_ACCESS_WO,
|
|
} glamor_access_t;
|
|
|
|
/*
|
|
* glamor_pixmap_private - glamor pixmap's private structure.
|
|
* @gl_fbo: The pixmap is attached to a fbo originally.
|
|
* @gl_tex: The pixmap is in a gl texture originally.
|
|
* @pbo_valid: The pbo has a valid copy of the pixmap's data.
|
|
* @is_picture: The drawable is attached to a picture.
|
|
* @tex: attached texture.
|
|
* @fb: attached fbo.
|
|
* @pbo: attached pbo.
|
|
* @access_mode: access mode during the prepare/finish pair.
|
|
* @pict_format: the corresponding picture's format.
|
|
* #pending_op: currently only support pending filling.
|
|
* @container: The corresponding pixmap's pointer.
|
|
**/
|
|
|
|
#define GLAMOR_PIXMAP_PRIV_NEED_VALIDATE(pixmap_priv) \
|
|
(GLAMOR_PIXMAP_PRIV_HAS_FBO(pixmap_priv) \
|
|
&& (pixmap_priv->pending_op.type != GLAMOR_PENDING_NONE))
|
|
|
|
#define GLAMOR_PIXMAP_PRIV_NO_PENDING(pixmap_priv) \
|
|
(pixmap_priv->pending_op.type == GLAMOR_PENDING_NONE)
|
|
|
|
enum _glamor_pending_op_type{
|
|
GLAMOR_PENDING_NONE,
|
|
GLAMOR_PENDING_FILL
|
|
};
|
|
|
|
typedef struct _glamor_pending_fill {
|
|
unsigned int type;
|
|
GLfloat color4fv[4];
|
|
CARD32 colori;
|
|
} glamor_pending_fill;
|
|
|
|
typedef union _glamor_pending_op {
|
|
unsigned int type;
|
|
glamor_pending_fill fill;
|
|
} glamor_pending_op;
|
|
|
|
|
|
typedef struct glamor_pixmap_private {
|
|
unsigned char gl_fbo:1;
|
|
unsigned char gl_tex:1;
|
|
unsigned char pbo_valid:1;
|
|
unsigned char is_picture:1;
|
|
GLuint tex;
|
|
GLuint fb;
|
|
GLuint pbo;
|
|
glamor_access_t access_mode;
|
|
PictFormatShort pict_format;
|
|
glamor_pending_op pending_op;
|
|
PixmapPtr container;
|
|
} glamor_pixmap_private;
|
|
|
|
#define GLAMOR_CHECK_PENDING_FILL(_glamor_priv_, _pixmap_priv_) do \
|
|
{ \
|
|
if (_pixmap_priv_->pending_op.type == GLAMOR_PENDING_FILL) { \
|
|
glUseProgram(_glamor_priv_->solid_prog); \
|
|
glUniform4fv(_glamor_priv_->solid_color_uniform_location, 1, \
|
|
_pixmap_priv_->pending_op.fill.color4fv); \
|
|
} \
|
|
} while(0)
|
|
|
|
|
|
/*
|
|
* Pixmap dynamic status, used by dynamic upload feature.
|
|
*
|
|
* GLAMOR_NONE: initial status, don't need to do anything.
|
|
* GLAMOR_UPLOAD_PENDING: marked as need to be uploaded to gl texture.
|
|
* GLAMOR_UPLOAD_DONE: the pixmap has been uploaded successfully.
|
|
* GLAMOR_UPLOAD_FAILED: fail to upload the pixmap.
|
|
*
|
|
* */
|
|
typedef enum glamor_pixmap_status {
|
|
GLAMOR_NONE,
|
|
GLAMOR_UPLOAD_PENDING,
|
|
GLAMOR_UPLOAD_DONE,
|
|
GLAMOR_UPLOAD_FAILED
|
|
} glamor_pixmap_status_t;
|
|
|
|
|
|
extern DevPrivateKey glamor_screen_private_key;
|
|
extern DevPrivateKey glamor_pixmap_private_key;
|
|
static inline glamor_screen_private *
|
|
glamor_get_screen_private(ScreenPtr screen)
|
|
{
|
|
return (glamor_screen_private *)dixLookupPrivate(&screen->devPrivates,
|
|
glamor_screen_private_key);
|
|
}
|
|
static inline glamor_pixmap_private *
|
|
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))
|
|
|
|
/**
|
|
* Borrow from uxa.
|
|
*/
|
|
static inline CARD32
|
|
format_for_depth(int depth)
|
|
{
|
|
switch (depth) {
|
|
case 1: return PICT_a1;
|
|
case 4: return PICT_a4;
|
|
case 8: return PICT_a8;
|
|
case 15: return PICT_x1r5g5b5;
|
|
case 16: return PICT_r5g6b5;
|
|
default:
|
|
case 24: return PICT_x8r8g8b8;
|
|
#if XORG_VERSION_CURRENT >= 10699900
|
|
case 30: return PICT_x2r10g10b10;
|
|
#endif
|
|
case 32: return PICT_a8r8g8b8;
|
|
}
|
|
}
|
|
|
|
static inline CARD32
|
|
format_for_pixmap(PixmapPtr pixmap)
|
|
{
|
|
glamor_pixmap_private *pixmap_priv;
|
|
PictFormatShort pict_format;
|
|
|
|
pixmap_priv = glamor_get_pixmap_private(pixmap);
|
|
if (GLAMOR_PIXMAP_PRIV_IS_PICTURE(pixmap_priv))
|
|
pict_format = pixmap_priv->pict_format;
|
|
else
|
|
pict_format = format_for_depth(pixmap->drawable.depth);
|
|
|
|
return pict_format;
|
|
}
|
|
|
|
/*
|
|
* Map picture's format to the correct gl texture format and type.
|
|
* no_alpha is used to indicate whehter we need to wire alpha to 1.
|
|
*
|
|
* Return 0 if find a matched texture type. Otherwise return -1.
|
|
**/
|
|
static inline int
|
|
glamor_get_tex_format_type_from_pictformat(PictFormatShort format,
|
|
GLenum *tex_format,
|
|
GLenum *tex_type,
|
|
int *no_alpha)
|
|
{
|
|
*no_alpha = 0;
|
|
switch (format) {
|
|
case PICT_a1:
|
|
*tex_format = GL_COLOR_INDEX;
|
|
*tex_type = GL_BITMAP;
|
|
break;
|
|
case PICT_b8g8r8x8:
|
|
*no_alpha = 1;
|
|
case PICT_b8g8r8a8:
|
|
*tex_format = GL_BGRA;
|
|
*tex_type = GL_UNSIGNED_INT_8_8_8_8;
|
|
break;
|
|
|
|
case PICT_x8r8g8b8:
|
|
*no_alpha = 1;
|
|
case PICT_a8r8g8b8:
|
|
*tex_format = GL_BGRA;
|
|
*tex_type = GL_UNSIGNED_INT_8_8_8_8_REV;
|
|
break;
|
|
case PICT_x8b8g8r8:
|
|
*no_alpha = 1;
|
|
case PICT_a8b8g8r8:
|
|
*tex_format = GL_RGBA;
|
|
*tex_type = GL_UNSIGNED_INT_8_8_8_8_REV;
|
|
break;
|
|
case PICT_x2r10g10b10:
|
|
*no_alpha = 1;
|
|
case PICT_a2r10g10b10:
|
|
*tex_format = GL_BGRA;
|
|
*tex_type = GL_UNSIGNED_INT_2_10_10_10_REV;
|
|
break;
|
|
case PICT_x2b10g10r10:
|
|
*no_alpha = 1;
|
|
case PICT_a2b10g10r10:
|
|
*tex_format = GL_RGBA;
|
|
*tex_type = GL_UNSIGNED_INT_2_10_10_10_REV;
|
|
break;
|
|
|
|
case PICT_r5g6b5:
|
|
*tex_format = GL_RGB;
|
|
*tex_type = GL_UNSIGNED_SHORT_5_6_5;
|
|
break;
|
|
case PICT_b5g6r5:
|
|
*tex_format = GL_RGB;
|
|
*tex_type = GL_UNSIGNED_SHORT_5_6_5_REV;
|
|
break;
|
|
case PICT_x1b5g5r5:
|
|
*no_alpha = 1;
|
|
case PICT_a1b5g5r5:
|
|
*tex_format = GL_RGBA;
|
|
*tex_type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
|
|
break;
|
|
|
|
case PICT_x1r5g5b5:
|
|
*no_alpha = 1;
|
|
case PICT_a1r5g5b5:
|
|
*tex_format = GL_BGRA;
|
|
*tex_type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
|
|
break;
|
|
case PICT_a8:
|
|
*tex_format = GL_ALPHA;
|
|
*tex_type = GL_UNSIGNED_BYTE;
|
|
break;
|
|
case PICT_x4r4g4b4:
|
|
*no_alpha = 1;
|
|
case PICT_a4r4g4b4:
|
|
*tex_format = GL_BGRA;
|
|
*tex_type = GL_UNSIGNED_SHORT_4_4_4_4_REV;
|
|
break;
|
|
|
|
case PICT_x4b4g4r4:
|
|
*no_alpha = 1;
|
|
case PICT_a4b4g4r4:
|
|
*tex_format = GL_RGBA;
|
|
*tex_type = GL_UNSIGNED_SHORT_4_4_4_4_REV;
|
|
break;
|
|
|
|
default:
|
|
LogMessageVerb(X_INFO, 0, "fail to get matched format for %x \n", format);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static inline int
|
|
glamor_get_tex_format_type_from_pixmap(PixmapPtr pixmap,
|
|
GLenum *format,
|
|
GLenum *type,
|
|
int *ax)
|
|
{
|
|
glamor_pixmap_private *pixmap_priv;
|
|
PictFormatShort pict_format;
|
|
|
|
pixmap_priv = glamor_get_pixmap_private(pixmap);
|
|
if (GLAMOR_PIXMAP_PRIV_IS_PICTURE(pixmap_priv))
|
|
pict_format = pixmap_priv->pict_format;
|
|
else
|
|
pict_format = format_for_depth(pixmap->drawable.depth);
|
|
|
|
return glamor_get_tex_format_type_from_pictformat(pict_format,
|
|
format, type, ax);
|
|
}
|
|
|
|
|
|
/* borrowed from uxa */
|
|
static inline Bool
|
|
glamor_get_rgba_from_pixel(CARD32 pixel,
|
|
float * red,
|
|
float * green,
|
|
float * blue,
|
|
float * alpha,
|
|
CARD32 format)
|
|
{
|
|
int rbits, bbits, gbits, abits;
|
|
int rshift, bshift, gshift, ashift;
|
|
|
|
rbits = PICT_FORMAT_R(format);
|
|
gbits = PICT_FORMAT_G(format);
|
|
bbits = PICT_FORMAT_B(format);
|
|
abits = PICT_FORMAT_A(format);
|
|
|
|
if (PICT_FORMAT_TYPE(format) == PICT_TYPE_A) {
|
|
rshift = gshift = bshift = ashift = 0;
|
|
} else if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ARGB) {
|
|
bshift = 0;
|
|
gshift = bbits;
|
|
rshift = gshift + gbits;
|
|
ashift = rshift + rbits;
|
|
} else if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ABGR) {
|
|
rshift = 0;
|
|
gshift = rbits;
|
|
bshift = gshift + gbits;
|
|
ashift = bshift + bbits;
|
|
#if XORG_VERSION_CURRENT >= 10699900
|
|
} else if (PICT_FORMAT_TYPE(format) == PICT_TYPE_BGRA) {
|
|
ashift = 0;
|
|
rshift = abits;
|
|
if (abits == 0)
|
|
rshift = PICT_FORMAT_BPP(format) - (rbits+gbits+bbits);
|
|
gshift = rshift + rbits;
|
|
bshift = gshift + gbits;
|
|
#endif
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
#define COLOR_INT_TO_FLOAT(_fc_, _p_, _s_, _bits_) \
|
|
*_fc_ = (((_p_) >> (_s_)) & (( 1 << (_bits_)) - 1)) \
|
|
/ (float)((1<<(_bits_)) - 1)
|
|
|
|
if (rbits)
|
|
COLOR_INT_TO_FLOAT(red, pixel, rshift, rbits);
|
|
else
|
|
*red = 0;
|
|
|
|
if (gbits)
|
|
COLOR_INT_TO_FLOAT(green, pixel, gshift, gbits);
|
|
else
|
|
*green = 0;
|
|
|
|
if (bbits)
|
|
COLOR_INT_TO_FLOAT(blue, pixel, bshift, bbits);
|
|
else
|
|
*blue = 0;
|
|
|
|
if (abits)
|
|
COLOR_INT_TO_FLOAT(alpha, pixel, ashift, abits);
|
|
else
|
|
*alpha = 1;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns TRUE if the given planemask covers all the significant bits in the
|
|
* pixel values for pDrawable.
|
|
*/
|
|
static inline Bool
|
|
glamor_pm_is_solid(DrawablePtr drawable, unsigned long planemask)
|
|
{
|
|
return (planemask & FbFullMask(drawable->depth)) ==
|
|
FbFullMask(drawable->depth);
|
|
}
|
|
|
|
extern int glamor_debug_level;
|
|
|
|
/* glamor.c */
|
|
PixmapPtr glamor_get_drawable_pixmap(DrawablePtr drawable);
|
|
|
|
Bool glamor_close_screen(int idx, ScreenPtr screen);
|
|
|
|
|
|
/* glamor_copyarea.c */
|
|
RegionPtr
|
|
glamor_copy_area(DrawablePtr src, DrawablePtr dst, GCPtr gc,
|
|
int srcx, int srcy, int width, int height, int dstx, int dsty);
|
|
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_copywindow.c */
|
|
void glamor_copy_window(WindowPtr win, DDXPointRec old_origin,
|
|
RegionPtr src_region);
|
|
|
|
/* glamor_core.c */
|
|
Bool glamor_prepare_access(DrawablePtr drawable, glamor_access_t access);
|
|
void glamor_finish_access(DrawablePtr drawable);
|
|
Bool glamor_prepare_access_window(WindowPtr window);
|
|
void glamor_finish_access_window(WindowPtr window);
|
|
Bool glamor_prepare_access_gc(GCPtr gc);
|
|
void glamor_finish_access_gc(GCPtr gc);
|
|
void glamor_init_finish_access_shaders(ScreenPtr screen);
|
|
const Bool glamor_get_drawable_location(const DrawablePtr drawable);
|
|
void glamor_get_drawable_deltas(DrawablePtr drawable, PixmapPtr pixmap,
|
|
int *x, int *y);
|
|
Bool glamor_create_gc(GCPtr gc);
|
|
Bool glamor_stipple(PixmapPtr pixmap, PixmapPtr stipple,
|
|
int x, int y, int width, int height,
|
|
unsigned char alu, unsigned long planemask,
|
|
unsigned long fg_pixel, unsigned long bg_pixel,
|
|
int stipple_x, int stipple_y);
|
|
GLint glamor_compile_glsl_prog(GLenum type, const char *source);
|
|
void glamor_link_glsl_prog(GLint prog);
|
|
void glamor_get_color_4f_from_pixel(PixmapPtr pixmap, unsigned long fg_pixel,
|
|
GLfloat *color);
|
|
|
|
int glamor_set_destination_pixmap(PixmapPtr pixmap);
|
|
int glamor_set_destination_pixmap_priv(glamor_pixmap_private *pixmap_priv);
|
|
|
|
/* nc means no check. caller must ensure this pixmap has valid fbo.
|
|
* usually use the GLAMOR_PIXMAP_PRIV_HAS_FBO firstly.
|
|
* */
|
|
void glamor_set_destination_pixmap_priv_nc(glamor_pixmap_private *pixmap_priv);
|
|
|
|
void glamor_set_alu(unsigned char alu);
|
|
Bool glamor_set_planemask(PixmapPtr pixmap, unsigned long planemask);
|
|
void glamor_get_transform_uniform_locations(GLint prog,
|
|
glamor_transform_uniforms *uniform_locations);
|
|
void glamor_set_transform_for_pixmap(PixmapPtr pixmap,
|
|
glamor_transform_uniforms *uniform_locations);
|
|
Bool glamor_change_window_attributes(WindowPtr pWin, unsigned long mask);
|
|
RegionPtr glamor_bitmap_to_region(PixmapPtr pixmap);
|
|
Bool glamor_gl_has_extension(char *extension);
|
|
int glamor_gl_get_version(void);
|
|
|
|
#define GLAMOR_GL_VERSION_ENCODE(major, minor) ( \
|
|
((major) * 256) \
|
|
+ ((minor) * 1))
|
|
|
|
|
|
|
|
|
|
/* glamor_fill.c */
|
|
void glamor_fill(DrawablePtr drawable,
|
|
GCPtr gc,
|
|
int x,
|
|
int y,
|
|
int width,
|
|
int height);
|
|
Bool glamor_solid(PixmapPtr pixmap, int x, int y, int width, int height,
|
|
unsigned char alu, unsigned long planemask,
|
|
unsigned long fg_pixel);
|
|
void glamor_solid_fail_region(PixmapPtr pixmap,
|
|
int x, int y, int width, int height);
|
|
|
|
/* glamor_fillspans.c */
|
|
void glamor_fill_spans(DrawablePtr drawable,
|
|
GCPtr gc,
|
|
int n,
|
|
DDXPointPtr points,
|
|
int *widths,
|
|
int sorted);
|
|
|
|
void glamor_init_solid_shader(ScreenPtr screen);
|
|
|
|
/* glamor_getspans.c */
|
|
void
|
|
glamor_get_spans(DrawablePtr drawable,
|
|
int wmax,
|
|
DDXPointPtr points,
|
|
int *widths,
|
|
int nspans,
|
|
char *dst_start);
|
|
|
|
/* glamor_glyphs.c */
|
|
void glamor_glyphs_init(ScreenPtr screen);
|
|
void glamor_glyphs_fini(ScreenPtr screen);
|
|
void glamor_glyphs(CARD8 op,
|
|
PicturePtr pSrc,
|
|
PicturePtr pDst,
|
|
PictFormatPtr maskFormat,
|
|
INT16 xSrc,
|
|
INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs);
|
|
|
|
/* glamor_setspans.c */
|
|
void glamor_set_spans(DrawablePtr drawable, GCPtr gc, char *src,
|
|
DDXPointPtr points, int *widths, int n, int sorted);
|
|
|
|
/* glamor_polyfillrect.c */
|
|
void
|
|
glamor_poly_fill_rect(DrawablePtr drawable,
|
|
GCPtr gc,
|
|
int nrect,
|
|
xRectangle *prect);
|
|
|
|
/* glamor_polylines.c */
|
|
void
|
|
glamor_poly_lines(DrawablePtr drawable, GCPtr gc, int mode, int n,
|
|
DDXPointPtr points);
|
|
|
|
/* glamor_putimage.c */
|
|
void
|
|
glamor_put_image(DrawablePtr drawable, GCPtr gc, int depth, int x, int y,
|
|
int w, int h, int leftPad, int format, char *bits);
|
|
void glamor_init_putimage_shaders(ScreenPtr screen);
|
|
|
|
/* glamor_render.c */
|
|
void glamor_composite(CARD8 op,
|
|
PicturePtr pSrc,
|
|
PicturePtr pMask,
|
|
PicturePtr pDst,
|
|
INT16 xSrc,
|
|
INT16 ySrc,
|
|
INT16 xMask,
|
|
INT16 yMask,
|
|
INT16 xDst,
|
|
INT16 yDst,
|
|
CARD16 width,
|
|
CARD16 height);
|
|
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);
|
|
void glamor_composite_rects(CARD8 op,
|
|
PicturePtr src, PicturePtr dst,
|
|
int nrect, glamor_composite_rect_t *rects);
|
|
|
|
/* glamor_tile.c */
|
|
Bool glamor_tile(PixmapPtr pixmap, PixmapPtr tile,
|
|
int x, int y, int width, int height,
|
|
unsigned char alu, unsigned long planemask,
|
|
int tile_x, int tile_y);
|
|
void glamor_init_tile_shader(ScreenPtr screen);
|
|
|
|
/* glamor_triangles.c */
|
|
void
|
|
glamor_triangles (CARD8 op,
|
|
PicturePtr pSrc,
|
|
PicturePtr pDst,
|
|
PictFormatPtr maskFormat,
|
|
INT16 xSrc,
|
|
INT16 ySrc,
|
|
int ntris,
|
|
xTriangle *tris);
|
|
|
|
/* glamor_pixmap.c */
|
|
|
|
void
|
|
glamor_pixmap_init(ScreenPtr screen);
|
|
/**
|
|
* Download a pixmap's texture to cpu memory. If success,
|
|
* One copy of current pixmap's texture will be put into
|
|
* the pixmap->devPrivate.ptr. Will use pbo to map to
|
|
* the pointer if possible.
|
|
* The pixmap must be a gl texture pixmap. gl_fbo and
|
|
* gl_tex must be 1. Used by glamor_prepare_access.
|
|
*
|
|
*/
|
|
Bool
|
|
glamor_download_pixmap_to_cpu(PixmapPtr pixmap, glamor_access_t access);
|
|
|
|
/**
|
|
* Restore a pixmap's data which is downloaded by
|
|
* glamor_download_pixmap_to_cpu to its original
|
|
* gl texture. Used by glamor_finish_access.
|
|
*
|
|
* The pixmap must be
|
|
* in texture originally. In other word, the gl_fbo
|
|
* must be 1.
|
|
**/
|
|
void
|
|
glamor_restore_pixmap_to_texture(PixmapPtr pixmap);
|
|
/**
|
|
* Ensure to have a fbo attached to the pixmap.
|
|
* If the pixmap already has one fbo then do nothing.
|
|
* Otherwise, it will generate a new fbo, and bind
|
|
* the pixmap's texture to the fbo.
|
|
* The pixmap must has a valid texture before call this
|
|
* API, othersie, it will trigger a assert.
|
|
*/
|
|
void
|
|
glamor_pixmap_ensure_fb(PixmapPtr pixmap);
|
|
|
|
/**
|
|
* Upload a pixmap to gl texture. Used by dynamic pixmap
|
|
* uploading feature. The pixmap must be a software pixmap.
|
|
* This function will change current FBO and current shaders.
|
|
*/
|
|
enum glamor_pixmap_status
|
|
glamor_upload_pixmap_to_texture(PixmapPtr pixmap);
|
|
|
|
/**
|
|
* Upload a picture to gl texture. Similar to the
|
|
* glamor_upload_pixmap_to_texture. Used in rendering.
|
|
**/
|
|
enum glamor_pixmap_status
|
|
glamor_upload_picture_to_texture(PicturePtr picture);
|
|
|
|
/**
|
|
* Destroy all the resources allocated on the uploading
|
|
* phase, includs the tex and fbo.
|
|
**/
|
|
void
|
|
glamor_destroy_upload_pixmap(PixmapPtr pixmap);
|
|
|
|
void
|
|
glamor_validate_pixmap(PixmapPtr pixmap);
|
|
|
|
int
|
|
glamor_create_picture(PicturePtr picture);
|
|
|
|
Bool
|
|
glamor_prepare_access_picture(PicturePtr picture, glamor_access_t access);
|
|
|
|
void
|
|
glamor_finish_access_picture(PicturePtr picture);
|
|
|
|
void
|
|
glamor_destroy_picture(PicturePtr picture);
|
|
|
|
enum glamor_pixmap_status
|
|
glamor_upload_picture_to_texture(PicturePtr picture);
|
|
|
|
void
|
|
glamor_picture_format_fixup(PicturePtr picture, glamor_pixmap_private *pixmap_priv);
|
|
|
|
/* Dynamic pixmap upload to texture if needed.
|
|
* Sometimes, the target is a gl texture pixmap/picture,
|
|
* but the source or mask is in cpu memory. In that case,
|
|
* upload the source/mask to gl texture and then avoid
|
|
* fallback the whole process to cpu. Most of the time,
|
|
* this will increase performance obviously. */
|
|
|
|
|
|
#define GLAMOR_PIXMAP_DYNAMIC_UPLOAD
|
|
#define GLAMOR_DELAYED_FILLING
|
|
|
|
|
|
#include"glamor_utils.h"
|
|
|
|
#endif /* GLAMOR_PRIV_H */
|