2012-01-18 12:21:36 +01:00
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
|
|
#include "glamor_priv.h"
|
|
|
|
|
|
2012-01-21 07:41:44 +01:00
|
|
|
#define GLAMOR_CACHE_EXPIRE_MAX 100
|
2012-01-19 13:47:55 +01:00
|
|
|
|
|
|
|
|
#define GLAMOR_CACHE_DEFAULT 0
|
|
|
|
|
#define GLAMOR_CACHE_EXACT_SIZE 1
|
2012-01-20 13:38:29 +01:00
|
|
|
#define GLAMOR_CACHE_TEXTURE 2
|
2012-01-19 13:47:55 +01:00
|
|
|
|
2012-03-16 09:42:46 +01:00
|
|
|
//#define NO_FBO_CACHE 1
|
|
|
|
|
|
2012-01-19 13:47:55 +01:00
|
|
|
/* Loop from the tail to the head. */
|
2012-03-05 01:24:20 +01:00
|
|
|
#define xorg_list_for_each_entry_reverse(pos, head, member) \
|
2012-01-19 13:47:55 +01:00
|
|
|
for (pos = __container_of((head)->prev, pos, member); \
|
|
|
|
|
&pos->member != (head); \
|
|
|
|
|
pos = __container_of(pos->member.prev, pos, member))
|
|
|
|
|
|
|
|
|
|
|
2012-03-05 01:24:20 +01:00
|
|
|
#define xorg_list_for_each_entry_safe_reverse(pos, tmp, head, member) \
|
2012-01-19 13:47:55 +01:00
|
|
|
for (pos = __container_of((head)->prev, pos, member), \
|
|
|
|
|
tmp = __container_of(pos->member.prev, pos, member); \
|
|
|
|
|
&pos->member != (head); \
|
|
|
|
|
pos = tmp, tmp = __container_of(pos->member.prev, tmp, member))
|
|
|
|
|
|
|
|
|
|
#ifdef __i386__
|
|
|
|
|
static inline unsigned long __fls(unsigned long x)
|
|
|
|
|
{
|
|
|
|
|
asm("bsr %1,%0"
|
|
|
|
|
: "=r" (x)
|
|
|
|
|
: "rm" (x));
|
|
|
|
|
return x;
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
static inline unsigned long __fls(unsigned long x)
|
|
|
|
|
{
|
|
|
|
|
int n;
|
|
|
|
|
|
|
|
|
|
if (x == 0) return(0);
|
|
|
|
|
n = 0;
|
|
|
|
|
if (x <= 0x0000FFFF) {n = n +16; x = x <<16;}
|
|
|
|
|
if (x <= 0x00FFFFFF) {n = n + 8; x = x << 8;}
|
|
|
|
|
if (x <= 0x0FFFFFFF) {n = n + 4; x = x << 4;}
|
|
|
|
|
if (x <= 0x3FFFFFFF) {n = n + 2; x = x << 2;}
|
|
|
|
|
if (x <= 0x7FFFFFFF) {n = n + 1;}
|
|
|
|
|
return 31 - n;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
inline static int cache_wbucket(int size)
|
|
|
|
|
{
|
2012-01-21 07:41:44 +01:00
|
|
|
int order = __fls(size / 32);
|
2012-01-19 13:47:55 +01:00
|
|
|
if (order >= CACHE_BUCKET_WCOUNT)
|
|
|
|
|
order = CACHE_BUCKET_WCOUNT - 1;
|
|
|
|
|
return order;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline static int cache_hbucket(int size)
|
|
|
|
|
{
|
2012-01-21 07:41:44 +01:00
|
|
|
int order = __fls(size / 32);
|
2012-01-19 13:47:55 +01:00
|
|
|
if (order >= CACHE_BUCKET_HCOUNT)
|
|
|
|
|
order = CACHE_BUCKET_HCOUNT - 1;
|
|
|
|
|
return order;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
glamor_pixmap_fbo *
|
|
|
|
|
glamor_pixmap_fbo_cache_get(glamor_screen_private *glamor_priv,
|
|
|
|
|
int w, int h, GLenum format, int flag)
|
|
|
|
|
{
|
2012-03-05 01:24:20 +01:00
|
|
|
struct xorg_list *cache;
|
2012-01-19 13:47:55 +01:00
|
|
|
glamor_pixmap_fbo *fbo_entry;
|
|
|
|
|
int size;
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
int n_format;
|
2012-03-16 09:42:46 +01:00
|
|
|
#ifdef NO_FBO_CACHE
|
|
|
|
|
return NULL;
|
|
|
|
|
#else
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
n_format = cache_format(format);
|
|
|
|
|
if (n_format == -1)
|
|
|
|
|
return NULL;
|
2012-01-20 13:38:29 +01:00
|
|
|
if (!(flag & GLAMOR_CACHE_TEXTURE))
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
cache = &glamor_priv->fbo_cache[n_format]
|
2012-01-20 13:38:29 +01:00
|
|
|
[cache_wbucket(w)]
|
|
|
|
|
[cache_hbucket(h)];
|
|
|
|
|
else
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
cache = &glamor_priv->tex_cache[n_format]
|
2012-01-20 13:38:29 +01:00
|
|
|
[cache_wbucket(w)]
|
|
|
|
|
[cache_hbucket(h)];
|
|
|
|
|
if (!(flag & GLAMOR_CACHE_EXACT_SIZE)) {
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_for_each_entry(fbo_entry, cache, list) {
|
2012-01-20 02:59:44 +01:00
|
|
|
if (fbo_entry->width >= w && fbo_entry->height >= h) {
|
2012-01-19 13:47:55 +01:00
|
|
|
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
DEBUGF("Request w %d h %d format %x \n", w, h, format);
|
|
|
|
|
DEBUGF("got cache entry %p w %d h %d fbo %d tex %d format %x\n",
|
2012-01-19 13:47:55 +01:00
|
|
|
fbo_entry, fbo_entry->width, fbo_entry->height,
|
|
|
|
|
fbo_entry->fb, fbo_entry->tex);
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_del(&fbo_entry->list);
|
2012-01-19 13:47:55 +01:00
|
|
|
return fbo_entry;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_for_each_entry(fbo_entry, cache, list) {
|
2012-01-19 13:47:55 +01:00
|
|
|
if (fbo_entry->width == w && fbo_entry->height == h) {
|
|
|
|
|
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
DEBUGF("Request w %d h %d format %x \n", w, h, format);
|
|
|
|
|
DEBUGF("got cache entry %p w %d h %d fbo %d tex %d format %x\n",
|
2012-01-19 13:47:55 +01:00
|
|
|
fbo_entry, fbo_entry->width, fbo_entry->height,
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
fbo_entry->fb, fbo_entry->tex, fbo_entry->format);
|
|
|
|
|
assert(format == fbo_entry->format);
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_del(&fbo_entry->list);
|
2012-01-19 13:47:55 +01:00
|
|
|
return fbo_entry;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
2012-03-16 09:42:46 +01:00
|
|
|
#endif
|
2012-01-19 13:47:55 +01:00
|
|
|
}
|
|
|
|
|
|
2012-01-31 11:16:58 +01:00
|
|
|
void
|
2012-01-20 13:38:29 +01:00
|
|
|
glamor_purge_fbo(glamor_pixmap_fbo *fbo)
|
|
|
|
|
{
|
2012-02-10 13:54:44 +01:00
|
|
|
glamor_gl_dispatch *dispatch = glamor_get_dispatch(fbo->glamor_priv);
|
2012-01-20 13:38:29 +01:00
|
|
|
if (fbo->fb)
|
|
|
|
|
dispatch->glDeleteFramebuffers(1, &fbo->fb);
|
|
|
|
|
if (fbo->tex)
|
|
|
|
|
dispatch->glDeleteTextures(1, &fbo->tex);
|
|
|
|
|
if (fbo->pbo)
|
|
|
|
|
dispatch->glDeleteBuffers(1, &fbo->pbo);
|
2012-02-10 13:54:44 +01:00
|
|
|
glamor_put_dispatch(fbo->glamor_priv);
|
2012-01-20 13:38:29 +01:00
|
|
|
|
|
|
|
|
free(fbo);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-03-16 09:42:46 +01:00
|
|
|
static void
|
2012-01-19 13:47:55 +01:00
|
|
|
glamor_pixmap_fbo_cache_put(glamor_pixmap_fbo *fbo)
|
|
|
|
|
{
|
2012-03-05 01:24:20 +01:00
|
|
|
struct xorg_list *cache;
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
int n_format;
|
|
|
|
|
|
2012-03-16 09:42:46 +01:00
|
|
|
#ifdef NO_FBO_CACHE
|
|
|
|
|
glamor_purge_fbo(fbo);
|
|
|
|
|
return;
|
|
|
|
|
#else
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
n_format = cache_format(fbo->format);
|
|
|
|
|
|
|
|
|
|
if (fbo->fb == 0 || n_format == -1) {
|
2012-01-20 13:38:29 +01:00
|
|
|
glamor_purge_fbo(fbo);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fbo->fb)
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
cache = &fbo->glamor_priv->fbo_cache[n_format]
|
2012-01-20 13:38:29 +01:00
|
|
|
[cache_wbucket(fbo->width)]
|
|
|
|
|
[cache_hbucket(fbo->height)];
|
|
|
|
|
else
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
cache = &fbo->glamor_priv->tex_cache[n_format]
|
2012-01-20 13:38:29 +01:00
|
|
|
[cache_wbucket(fbo->width)]
|
|
|
|
|
[cache_hbucket(fbo->height)];
|
2012-01-19 13:47:55 +01:00
|
|
|
DEBUGF("Put cache entry %p to cache %p w %d h %d format %x fbo %d tex %d \n", fbo, cache,
|
|
|
|
|
fbo->width, fbo->height, fbo->format, fbo->fb, fbo->tex);
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_add(&fbo->list, cache);
|
2012-01-19 13:47:55 +01:00
|
|
|
fbo->expire = fbo->glamor_priv->tick + GLAMOR_CACHE_EXPIRE_MAX;
|
2012-03-16 09:42:46 +01:00
|
|
|
#endif
|
2012-01-19 13:47:55 +01:00
|
|
|
}
|
|
|
|
|
|
2012-01-18 12:21:36 +01:00
|
|
|
glamor_pixmap_fbo *
|
|
|
|
|
glamor_create_fbo_from_tex(glamor_screen_private *glamor_priv,
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
int w, int h, GLenum format, GLint tex, int flag)
|
2012-01-18 12:21:36 +01:00
|
|
|
{
|
|
|
|
|
glamor_pixmap_fbo *fbo;
|
|
|
|
|
|
|
|
|
|
fbo = calloc(1, sizeof(*fbo));
|
|
|
|
|
if (fbo == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_init(&fbo->list);
|
2012-01-18 12:21:36 +01:00
|
|
|
|
|
|
|
|
fbo->tex = tex;
|
|
|
|
|
fbo->width = w;
|
|
|
|
|
fbo->height = h;
|
|
|
|
|
fbo->format = format;
|
|
|
|
|
fbo->glamor_priv = glamor_priv;
|
|
|
|
|
|
2012-01-20 13:38:29 +01:00
|
|
|
if (flag != GLAMOR_CREATE_FBO_NO_FBO)
|
|
|
|
|
glamor_pixmap_ensure_fb(fbo);
|
2012-01-18 12:21:36 +01:00
|
|
|
|
|
|
|
|
return fbo;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-01-19 13:47:55 +01:00
|
|
|
void
|
|
|
|
|
glamor_fbo_expire(glamor_screen_private *glamor_priv)
|
|
|
|
|
{
|
2012-03-05 01:24:20 +01:00
|
|
|
struct xorg_list *cache;
|
2012-01-19 13:47:55 +01:00
|
|
|
glamor_pixmap_fbo *fbo_entry, *tmp;
|
|
|
|
|
int i,j,k;
|
|
|
|
|
int empty_cache = TRUE;
|
|
|
|
|
|
|
|
|
|
for(i = 0; i < CACHE_FORMAT_COUNT; i++)
|
|
|
|
|
for(j = 0; j < CACHE_BUCKET_WCOUNT; j++)
|
|
|
|
|
for(k = 0; k < CACHE_BUCKET_HCOUNT; k++) {
|
|
|
|
|
cache = &glamor_priv->fbo_cache[i][j][k];
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_for_each_entry_safe_reverse(fbo_entry, tmp, cache, list) {
|
2012-01-19 13:47:55 +01:00
|
|
|
if (GLAMOR_TICK_AFTER(fbo_entry->expire, glamor_priv->tick)) {
|
|
|
|
|
empty_cache = FALSE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_del(&fbo_entry->list);
|
2012-01-19 13:47:55 +01:00
|
|
|
DEBUGF("cache %p fbo %p expired %d current %d \n", cache, fbo_entry,
|
|
|
|
|
fbo_entry->expire, glamor_priv->tick);
|
|
|
|
|
glamor_purge_fbo(fbo_entry);
|
|
|
|
|
}
|
2012-01-20 13:38:29 +01:00
|
|
|
#if 0
|
|
|
|
|
cache = &glamor_priv->tex_cache[i][j][k];
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_for_each_entry_safe_reverse(fbo_entry, tmp, cache, list) {
|
2012-01-20 13:38:29 +01:00
|
|
|
if (GLAMOR_TICK_AFTER(fbo_entry->expire, glamor_priv->tick)) {
|
|
|
|
|
empty_cache = FALSE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_del(&fbo_entry->list);
|
2012-01-20 13:38:29 +01:00
|
|
|
DEBUGF("cache %p fbo %p expired %d current %d \n", cache, fbo_entry,
|
|
|
|
|
fbo_entry->expire, glamor_priv->tick);
|
|
|
|
|
glamor_purge_fbo(fbo_entry);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2012-01-19 13:47:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
glamor_init_pixmap_fbo(ScreenPtr screen)
|
|
|
|
|
{
|
|
|
|
|
glamor_screen_private *glamor_priv;
|
|
|
|
|
int i,j,k;
|
|
|
|
|
|
|
|
|
|
glamor_priv = glamor_get_screen_private(screen);
|
|
|
|
|
for(i = 0; i < CACHE_FORMAT_COUNT; i++)
|
|
|
|
|
for(j = 0; j < CACHE_BUCKET_WCOUNT; j++)
|
|
|
|
|
for(k = 0; k < CACHE_BUCKET_HCOUNT; k++)
|
|
|
|
|
{
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_init(&glamor_priv->fbo_cache[i][j][k]);
|
|
|
|
|
xorg_list_init(&glamor_priv->tex_cache[i][j][k]);
|
2012-01-19 13:47:55 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
glamor_fini_pixmap_fbo(ScreenPtr screen)
|
|
|
|
|
{
|
2012-03-05 01:24:20 +01:00
|
|
|
struct xorg_list *cache;
|
2012-01-19 13:47:55 +01:00
|
|
|
glamor_screen_private *glamor_priv;
|
|
|
|
|
glamor_pixmap_fbo *fbo_entry, *tmp;
|
|
|
|
|
int i,j,k;
|
|
|
|
|
|
|
|
|
|
glamor_priv = glamor_get_screen_private(screen);
|
|
|
|
|
for(i = 0; i < CACHE_FORMAT_COUNT; i++)
|
|
|
|
|
for(j = 0; j < CACHE_BUCKET_WCOUNT; j++)
|
|
|
|
|
for(k = 0; k < CACHE_BUCKET_HCOUNT; k++)
|
|
|
|
|
{
|
|
|
|
|
cache = &glamor_priv->fbo_cache[i][j][k];
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_for_each_entry_safe_reverse(fbo_entry, tmp, cache, list) {
|
|
|
|
|
xorg_list_del(&fbo_entry->list);
|
2012-01-19 13:47:55 +01:00
|
|
|
glamor_purge_fbo(fbo_entry);
|
|
|
|
|
}
|
2012-01-20 13:38:29 +01:00
|
|
|
#if 0
|
|
|
|
|
cache = &glamor_priv->tex_cache[i][j][k];
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_for_each_entry_safe_reverse(fbo_entry, tmp, cache, list) {
|
|
|
|
|
xorg_list_del(&fbo_entry->list);
|
2012-01-20 13:38:29 +01:00
|
|
|
glamor_purge_fbo(fbo_entry);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2012-01-19 13:47:55 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
glamor_destroy_fbo(glamor_pixmap_fbo *fbo)
|
|
|
|
|
{
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_del(&fbo->list);
|
2012-01-19 13:47:55 +01:00
|
|
|
glamor_pixmap_fbo_cache_put(fbo);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-20 13:38:29 +01:00
|
|
|
glamor_pixmap_fbo *
|
|
|
|
|
glamor_create_tex_obj(glamor_screen_private *glamor_priv,
|
|
|
|
|
int w, int h, GLenum format, int flag)
|
|
|
|
|
{
|
|
|
|
|
glamor_gl_dispatch *dispatch;
|
|
|
|
|
glamor_pixmap_fbo *fbo;
|
|
|
|
|
int cache_flag = GLAMOR_CACHE_TEXTURE;
|
|
|
|
|
GLuint tex;
|
|
|
|
|
|
|
|
|
|
if (flag == GLAMOR_CREATE_TEXTURE_EXACT_SIZE)
|
|
|
|
|
cache_flag |= GLAMOR_CACHE_EXACT_SIZE;
|
|
|
|
|
|
|
|
|
|
fbo = glamor_pixmap_fbo_cache_get(glamor_priv, w, h,
|
|
|
|
|
format, cache_flag);
|
|
|
|
|
if (fbo)
|
|
|
|
|
return fbo;
|
|
|
|
|
fbo = calloc(1, sizeof(*fbo));
|
|
|
|
|
if (fbo == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_init(&fbo->list);
|
2012-01-20 13:38:29 +01:00
|
|
|
|
2012-02-10 13:54:44 +01:00
|
|
|
dispatch = glamor_get_dispatch(glamor_priv);
|
2012-01-20 13:38:29 +01:00
|
|
|
dispatch->glGenTextures(1, &tex);
|
|
|
|
|
dispatch->glBindTexture(GL_TEXTURE_2D, tex);
|
|
|
|
|
dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
|
|
|
|
|
GL_NEAREST);
|
|
|
|
|
dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
|
|
|
|
|
GL_NEAREST);
|
|
|
|
|
dispatch->glTexImage2D(GL_TEXTURE_2D, 0, format, w, h, 0, format,
|
|
|
|
|
GL_UNSIGNED_BYTE, NULL);
|
2012-02-10 13:54:44 +01:00
|
|
|
glamor_put_dispatch(glamor_priv);
|
|
|
|
|
|
2012-01-20 13:38:29 +01:00
|
|
|
fbo->tex = tex;
|
|
|
|
|
fbo->width = w;
|
|
|
|
|
fbo->height = h;
|
|
|
|
|
fbo->format = format;
|
|
|
|
|
fbo->glamor_priv = glamor_priv;
|
|
|
|
|
|
|
|
|
|
return fbo;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
glamor_destroy_tex_obj(glamor_pixmap_fbo * tex_obj)
|
|
|
|
|
{
|
|
|
|
|
assert(tex_obj->fb == 0);
|
2012-03-05 01:24:20 +01:00
|
|
|
xorg_list_del(&tex_obj->list);
|
2012-01-20 13:38:29 +01:00
|
|
|
glamor_pixmap_fbo_cache_put(tex_obj);
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-18 12:21:36 +01:00
|
|
|
glamor_pixmap_fbo *
|
|
|
|
|
glamor_create_fbo(glamor_screen_private *glamor_priv,
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
int w, int h,
|
|
|
|
|
GLenum format,
|
|
|
|
|
int flag)
|
2012-01-18 12:21:36 +01:00
|
|
|
{
|
|
|
|
|
glamor_gl_dispatch *dispatch;
|
|
|
|
|
glamor_pixmap_fbo *fbo;
|
|
|
|
|
GLint tex;
|
2012-01-19 13:47:55 +01:00
|
|
|
int cache_flag;
|
|
|
|
|
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
if (!glamor_check_fbo_size(glamor_priv, w, h))
|
2012-01-21 06:22:14 +01:00
|
|
|
return NULL;
|
|
|
|
|
|
2012-01-20 13:38:29 +01:00
|
|
|
if (flag == GLAMOR_CREATE_FBO_NO_FBO)
|
|
|
|
|
goto new_fbo;
|
|
|
|
|
|
2012-01-19 13:47:55 +01:00
|
|
|
if (flag == GLAMOR_CREATE_PIXMAP_FIXUP)
|
|
|
|
|
cache_flag = GLAMOR_CACHE_EXACT_SIZE;
|
|
|
|
|
else
|
|
|
|
|
cache_flag = 0;
|
2012-01-18 12:21:36 +01:00
|
|
|
|
2012-01-19 13:47:55 +01:00
|
|
|
fbo = glamor_pixmap_fbo_cache_get(glamor_priv, w, h,
|
2012-01-20 02:59:44 +01:00
|
|
|
format, cache_flag);
|
2012-01-19 13:47:55 +01:00
|
|
|
if (fbo)
|
|
|
|
|
return fbo;
|
2012-01-20 13:38:29 +01:00
|
|
|
new_fbo:
|
2012-02-10 13:54:44 +01:00
|
|
|
dispatch = glamor_get_dispatch(glamor_priv);
|
2012-01-18 12:21:36 +01:00
|
|
|
dispatch->glGenTextures(1, &tex);
|
|
|
|
|
dispatch->glBindTexture(GL_TEXTURE_2D, tex);
|
|
|
|
|
dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
|
|
|
|
|
GL_NEAREST);
|
|
|
|
|
dispatch->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
|
|
|
|
|
GL_NEAREST);
|
|
|
|
|
dispatch->glTexImage2D(GL_TEXTURE_2D, 0, format, w, h, 0, format,
|
|
|
|
|
GL_UNSIGNED_BYTE, NULL);
|
|
|
|
|
|
gles2: Fixed color conversion for the formats except 1555 and 2101010.
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>
2012-04-05 15:53:44 +02:00
|
|
|
fbo = glamor_create_fbo_from_tex(glamor_priv, w, h, format, tex, flag);
|
2012-02-10 13:54:44 +01:00
|
|
|
glamor_put_dispatch(glamor_priv);
|
2012-01-18 12:21:36 +01:00
|
|
|
|
|
|
|
|
return fbo;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
glamor_pixmap_fbo *
|
|
|
|
|
glamor_pixmap_detach_fbo(glamor_pixmap_private *pixmap_priv)
|
|
|
|
|
{
|
|
|
|
|
glamor_pixmap_fbo *fbo;
|
|
|
|
|
|
|
|
|
|
if (pixmap_priv == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
fbo = pixmap_priv->fbo;
|
|
|
|
|
if (fbo == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
pixmap_priv->fbo = NULL;
|
|
|
|
|
return fbo;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The pixmap must not be attached to another fbo. */
|
|
|
|
|
void
|
|
|
|
|
glamor_pixmap_attach_fbo(PixmapPtr pixmap, glamor_pixmap_fbo *fbo)
|
|
|
|
|
{
|
|
|
|
|
glamor_pixmap_private *pixmap_priv;
|
|
|
|
|
|
|
|
|
|
pixmap_priv = glamor_get_pixmap_private(pixmap);
|
|
|
|
|
|
|
|
|
|
if (pixmap_priv == NULL) {
|
|
|
|
|
glamor_screen_private *glamor_priv;
|
|
|
|
|
glamor_priv = glamor_get_screen_private(pixmap->drawable.pScreen);
|
|
|
|
|
pixmap_priv = calloc(1, sizeof(*pixmap_priv));
|
|
|
|
|
dixSetPrivate(&pixmap->devPrivates,
|
|
|
|
|
glamor_pixmap_private_key, pixmap_priv);
|
|
|
|
|
pixmap_priv->container = pixmap;
|
|
|
|
|
pixmap_priv->glamor_priv = glamor_priv;
|
|
|
|
|
pixmap_priv->type = GLAMOR_MEMORY;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (pixmap_priv->fbo)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
pixmap_priv->fbo = fbo;
|
|
|
|
|
|
|
|
|
|
switch (pixmap_priv->type) {
|
|
|
|
|
case GLAMOR_TEXTURE_ONLY:
|
|
|
|
|
case GLAMOR_TEXTURE_DRM:
|
|
|
|
|
pixmap_priv->gl_fbo = 1;
|
|
|
|
|
if (fbo->tex != 0)
|
|
|
|
|
pixmap_priv->gl_tex = 1;
|
|
|
|
|
else {
|
|
|
|
|
/* XXX For the Xephyr only, may be broken now.*/
|
|
|
|
|
pixmap_priv->gl_tex = 0;
|
|
|
|
|
}
|
|
|
|
|
pixmap->devPrivate.ptr = NULL;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-02-17 09:56:05 +01:00
|
|
|
/*
|
|
|
|
|
* XXX how to handle those pending OPs.
|
|
|
|
|
* By default, pending OP is disabled. Maybe we will give up the pending
|
|
|
|
|
* OP latter.
|
|
|
|
|
*
|
|
|
|
|
* */
|
|
|
|
|
|
|
|
|
|
_X_EXPORT void
|
|
|
|
|
glamor_pixmap_exchange_fbos(PixmapPtr front, PixmapPtr back)
|
|
|
|
|
{
|
|
|
|
|
glamor_pixmap_private *front_priv, *back_priv;
|
|
|
|
|
glamor_pixmap_fbo *temp_fbo;
|
|
|
|
|
|
|
|
|
|
front_priv = glamor_get_pixmap_private(front);
|
|
|
|
|
back_priv = glamor_get_pixmap_private(back);
|
|
|
|
|
temp_fbo = front_priv->fbo;
|
|
|
|
|
front_priv->fbo = back_priv->fbo;
|
|
|
|
|
back_priv->fbo = temp_fbo;
|
|
|
|
|
}
|
