brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cogl: Extend tests and fix RGB2101010 opaque formats

Browse Source 
Notably fix several cases where bitmap packing was broken, resulting in
visual corruption with the GLES2 backend. These were reproducible with
the gradient-test from
https://gitlab.freedesktop.org/jadahl/wayland-test-clients

Also extend testing similar to the RGB8888 formats.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/3065>
This commit is contained in:
Robert Mader 2023-06-21 12:23:13 +02:00 committed by Marge Bot
parent f04209dcbf
commit 4097cbbb53
4 changed files with 270 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
cogl/cogl/cogl-bitmap-packing.h
View File

@ -329,7 +329,7 @@ G_PASTE (_cogl_unpack_rgba_1010102_, component_size) (const uint8_t *src,
dst[2] = UNPACK_10 ((v >> 2) & 0x3ff); dst[2] = UNPACK_10 ((v >> 2) & 0x3ff);
dst[3] = UNPACK_2 (v & 3); dst[3] = UNPACK_2 (v & 3);
dst += 4; dst += 4;
src += 2; src += 4;
} }
} }
@ -347,7 +347,25 @@ G_PASTE (_cogl_unpack_bgra_1010102_, component_size) (const uint8_t *src,
dst[0] = UNPACK_10 ((v >> 2) & 0x3ff); dst[0] = UNPACK_10 ((v >> 2) & 0x3ff);
dst[3] = UNPACK_2 (v & 3); dst[3] = UNPACK_2 (v & 3);
dst += 4; dst += 4;
src += 2; src += 4;
}
}
inline static void
G_PASTE (_cogl_unpack_xrgb_2101010_, component_size) (const uint8_t *src,
component_type *dst,
int width)
{
while (width-- > 0)
{
uint32_t v = *(const uint32_t *) src;
dst[3] = UNPACK_2 (0x3);
dst[0] = UNPACK_10 ((v >> 20) & 0x3ff);
dst[1] = UNPACK_10 ((v >> 10) & 0x3ff);
dst[2] = UNPACK_10 (v & 0x3ff);
dst += 4;
src += 4;
} }
} }
@ -365,7 +383,25 @@ G_PASTE (_cogl_unpack_argb_2101010_, component_size) (const uint8_t *src,
dst[1] = UNPACK_10 ((v >> 10) & 0x3ff); dst[1] = UNPACK_10 ((v >> 10) & 0x3ff);
dst[2] = UNPACK_10 (v & 0x3ff); dst[2] = UNPACK_10 (v & 0x3ff);
dst += 4; dst += 4;
src += 2; src += 4;
}
}
inline static void
G_PASTE (_cogl_unpack_xbgr_2101010_, component_size) (const uint8_t *src,
component_type *dst,
int width)
{
while (width-- > 0)
{
uint32_t v = *(const uint32_t *) src;
dst[3] = UNPACK_2 (0x3);
dst[2] = UNPACK_10 ((v >> 20) & 0x3ff);
dst[1] = UNPACK_10 ((v >> 10) & 0x3ff);
dst[0] = UNPACK_10 (v & 0x3ff);
dst += 4;
src += 4;
} }
} }
@ -383,7 +419,7 @@ G_PASTE (_cogl_unpack_abgr_2101010_, component_size) (const uint8_t *src,
dst[1] = UNPACK_10 ((v >> 10) & 0x3ff); dst[1] = UNPACK_10 ((v >> 10) & 0x3ff);
dst[0] = UNPACK_10 (v & 0x3ff); dst[0] = UNPACK_10 (v & 0x3ff);
dst += 4; dst += 4;
src += 2; src += 4;
} }
} }
@ -473,11 +509,15 @@ G_PASTE (_cogl_unpack_, component_size) (CoglPixelFormat format,
G_PASTE (_cogl_unpack_bgra_1010102_, component_size) (src, dst, width); G_PASTE (_cogl_unpack_bgra_1010102_, component_size) (src, dst, width);
break; break;
case COGL_PIXEL_FORMAT_XRGB_2101010: case COGL_PIXEL_FORMAT_XRGB_2101010:
G_PASTE (_cogl_unpack_xrgb_2101010_, component_size) (src, dst, width);
break;
case COGL_PIXEL_FORMAT_ARGB_2101010: case COGL_PIXEL_FORMAT_ARGB_2101010:
case COGL_PIXEL_FORMAT_ARGB_2101010_PRE: case COGL_PIXEL_FORMAT_ARGB_2101010_PRE:
G_PASTE (_cogl_unpack_argb_2101010_, component_size) (src, dst, width); G_PASTE (_cogl_unpack_argb_2101010_, component_size) (src, dst, width);
break; break;
case COGL_PIXEL_FORMAT_XBGR_2101010: case COGL_PIXEL_FORMAT_XBGR_2101010:
G_PASTE (_cogl_unpack_xbgr_2101010_, component_size) (src, dst, width);
break;
case COGL_PIXEL_FORMAT_ABGR_2101010: case COGL_PIXEL_FORMAT_ABGR_2101010:
case COGL_PIXEL_FORMAT_ABGR_2101010_PRE: case COGL_PIXEL_FORMAT_ABGR_2101010_PRE:
G_PASTE (_cogl_unpack_abgr_2101010_, component_size) (src, dst, width); G_PASTE (_cogl_unpack_abgr_2101010_, component_size) (src, dst, width);
@ -809,6 +849,24 @@ G_PASTE (_cogl_pack_bgra_1010102_, component_size) (const component_type *src,
} }
} }
inline static void
G_PASTE (_cogl_pack_xrgb_2101010_, component_size) (const component_type *src,
uint8_t *dst,
int width)
{
while (width-- > 0)
{
uint32_t *v = (uint32_t *) dst;
*v = ((0x3 << 30) |
(PACK_10 (src[0]) << 20) |
(PACK_10 (src[1]) << 10) |
PACK_10 (src[2]));
src += 4;
dst += 4;
}
}
inline static void inline static void
G_PASTE (_cogl_pack_argb_2101010_, component_size) (const component_type *src, G_PASTE (_cogl_pack_argb_2101010_, component_size) (const component_type *src,
uint8_t *dst, uint8_t *dst,
@ -827,6 +885,24 @@ G_PASTE (_cogl_pack_argb_2101010_, component_size) (const component_type *src,
} }
} }
inline static void
G_PASTE (_cogl_pack_xbgr_2101010_, component_size) (const component_type *src,
uint8_t *dst,
int width)
{
while (width-- > 0)
{
uint32_t *v = (uint32_t *) dst;
*v = ((0x3 << 30) |
(PACK_10 (src[2]) << 20) |
(PACK_10 (src[1]) << 10) |
PACK_10 (src[0]));
src += 4;
dst += 4;
}
}
inline static void inline static void
G_PASTE (_cogl_pack_abgr_2101010_, component_size) (const component_type *src, G_PASTE (_cogl_pack_abgr_2101010_, component_size) (const component_type *src,
uint8_t *dst, uint8_t *dst,
@ -932,11 +1008,15 @@ G_PASTE (_cogl_pack_, component_size) (CoglPixelFormat format,
G_PASTE (_cogl_pack_bgra_1010102_, component_size) (src, dst, width); G_PASTE (_cogl_pack_bgra_1010102_, component_size) (src, dst, width);
break; break;
case COGL_PIXEL_FORMAT_XRGB_2101010: case COGL_PIXEL_FORMAT_XRGB_2101010:
G_PASTE (_cogl_pack_xrgb_2101010_, component_size) (src, dst, width);
break;
case COGL_PIXEL_FORMAT_ARGB_2101010: case COGL_PIXEL_FORMAT_ARGB_2101010:
case COGL_PIXEL_FORMAT_ARGB_2101010_PRE: case COGL_PIXEL_FORMAT_ARGB_2101010_PRE:
G_PASTE (_cogl_pack_argb_2101010_, component_size) (src, dst, width); G_PASTE (_cogl_pack_argb_2101010_, component_size) (src, dst, width);
break; break;
case COGL_PIXEL_FORMAT_XBGR_2101010: case COGL_PIXEL_FORMAT_XBGR_2101010:
G_PASTE (_cogl_pack_xbgr_2101010_, component_size) (src, dst, width);
break;
case COGL_PIXEL_FORMAT_ABGR_2101010: case COGL_PIXEL_FORMAT_ABGR_2101010:
case COGL_PIXEL_FORMAT_ABGR_2101010_PRE: case COGL_PIXEL_FORMAT_ABGR_2101010_PRE:
G_PASTE (_cogl_pack_abgr_2101010_, component_size) (src, dst, width); G_PASTE (_cogl_pack_abgr_2101010_, component_size) (src, dst, width);

2
cogl/cogl/cogl-pixel-format.h
View File

@ -160,7 +160,9 @@ G_BEGIN_DECLS
* @COGL_PIXEL_FORMAT_ABGR_8888: ABGR, 32 bits * @COGL_PIXEL_FORMAT_ABGR_8888: ABGR, 32 bits
* @COGL_PIXEL_FORMAT_RGBA_1010102 : RGBA, 32 bits, 10 bpc * @COGL_PIXEL_FORMAT_RGBA_1010102 : RGBA, 32 bits, 10 bpc
* @COGL_PIXEL_FORMAT_BGRA_1010102 : BGRA, 32 bits, 10 bpc * @COGL_PIXEL_FORMAT_BGRA_1010102 : BGRA, 32 bits, 10 bpc
* @COGL_PIXEL_FORMAT_XRGB_2101010 : XRGB, 32 bits, 10 bpc
* @COGL_PIXEL_FORMAT_ARGB_2101010 : ARGB, 32 bits, 10 bpc * @COGL_PIXEL_FORMAT_ARGB_2101010 : ARGB, 32 bits, 10 bpc
* @COGL_PIXEL_FORMAT_XBGR_2101010 : XBGR, 32 bits, 10 bpc
* @COGL_PIXEL_FORMAT_ABGR_2101010 : ABGR, 32 bits, 10 bpc * @COGL_PIXEL_FORMAT_ABGR_2101010 : ABGR, 32 bits, 10 bpc
* @COGL_PIXEL_FORMAT_RGBA_8888_PRE: Premultiplied RGBA, 32 bits * @COGL_PIXEL_FORMAT_RGBA_8888_PRE: Premultiplied RGBA, 32 bits
* @COGL_PIXEL_FORMAT_BGRA_8888_PRE: Premultiplied BGRA, 32 bits * @COGL_PIXEL_FORMAT_BGRA_8888_PRE: Premultiplied BGRA, 32 bits

8
cogl/cogl/driver/gl/gl/cogl-driver-gl.c
View File

@ -271,6 +271,10 @@ _cogl_driver_pixel_format_to_gl (CoglContext *context,
break; break;
case COGL_PIXEL_FORMAT_XBGR_2101010: case COGL_PIXEL_FORMAT_XBGR_2101010:
glintformat = GL_RGB;
glformat = GL_RGBA;
gltype = GL_UNSIGNED_INT_2_10_10_10_REV;
break;
case COGL_PIXEL_FORMAT_ABGR_2101010: case COGL_PIXEL_FORMAT_ABGR_2101010:
case COGL_PIXEL_FORMAT_ABGR_2101010_PRE: case COGL_PIXEL_FORMAT_ABGR_2101010_PRE:
glintformat = GL_RGBA; glintformat = GL_RGBA;
@ -279,6 +283,10 @@ _cogl_driver_pixel_format_to_gl (CoglContext *context,
break; break;
case COGL_PIXEL_FORMAT_XRGB_2101010: case COGL_PIXEL_FORMAT_XRGB_2101010:
glintformat = GL_RGB;
glformat = GL_BGRA;
gltype = GL_UNSIGNED_INT_2_10_10_10_REV;
break;
case COGL_PIXEL_FORMAT_ARGB_2101010: case COGL_PIXEL_FORMAT_ARGB_2101010:
case COGL_PIXEL_FORMAT_ARGB_2101010_PRE: case COGL_PIXEL_FORMAT_ARGB_2101010_PRE:
glintformat = GL_RGBA; glintformat = GL_RGBA;

263
src/tests/cogl/conform/test-offscreen-texture-formats.c
View File

@ -55,17 +55,19 @@ test_offscreen_texture_formats_store_rgb10 (void)
const int rgb10_red = 514; const int rgb10_red = 514;
const int rgb10_green = 258; const int rgb10_green = 258;
const int rgb10_blue = 18; const int rgb10_blue = 18;
const int rgb10_alpha = 2;
float red; float red;
float green; float green;
float blue; float blue;
float alpha;
GError *error = NULL; GError *error = NULL;
CoglPixelFormat formats[] = { CoglPixelFormat formats[] = {
COGL_PIXEL_FORMAT_ABGR_2101010,
COGL_PIXEL_FORMAT_ARGB_2101010,
COGL_PIXEL_FORMAT_XRGB_2101010, COGL_PIXEL_FORMAT_XRGB_2101010,
COGL_PIXEL_FORMAT_RGBA_1010102, COGL_PIXEL_FORMAT_ARGB_2101010_PRE,
COGL_PIXEL_FORMAT_BGRA_1010102,
COGL_PIXEL_FORMAT_XBGR_2101010, COGL_PIXEL_FORMAT_XBGR_2101010,
COGL_PIXEL_FORMAT_ABGR_2101010_PRE,
COGL_PIXEL_FORMAT_RGBA_1010102_PRE,
COGL_PIXEL_FORMAT_BGRA_1010102_PRE,
}; };
int i; int i;
@ -74,6 +76,7 @@ test_offscreen_texture_formats_store_rgb10 (void)
red = (rgb10_red / (float) (1 << 10)) + 0.00001; red = (rgb10_red / (float) (1 << 10)) + 0.00001;
green = (rgb10_green / (float) (1 << 10)) + 0.00001; green = (rgb10_green / (float) (1 << 10)) + 0.00001;
blue = (rgb10_blue / (float) (1 << 10)) + 0.00001; blue = (rgb10_blue / (float) (1 << 10)) + 0.00001;
alpha = (rgb10_alpha / (float) (1 << 2)) + 0.00001;
/* Make sure that that the color value can't be represented using rgb8. */ /* Make sure that that the color value can't be represented using rgb8. */
g_assert_cmpint (rgb8_to_rgb10 (rgb10_to_rgb8 (rgb10_red)), !=, rgb10_red); g_assert_cmpint (rgb8_to_rgb10 (rgb10_to_rgb8 (rgb10_red)), !=, rgb10_red);
@ -85,8 +88,7 @@ test_offscreen_texture_formats_store_rgb10 (void)
CoglTexture2D *tex; CoglTexture2D *tex;
CoglOffscreen *offscreen; CoglOffscreen *offscreen;
uint32_t rgb8_readback[4]; uint32_t rgb8_readback[4];
uint8_t *rgb8_buf; int j, k;
int j;
/* Allocate 2x2 to ensure we avoid any fast paths. */ /* Allocate 2x2 to ensure we avoid any fast paths. */
tex = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[i]); tex = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[i]);
@ -97,72 +99,84 @@ test_offscreen_texture_formats_store_rgb10 (void)
cogl_framebuffer_clear4f (COGL_FRAMEBUFFER (offscreen), cogl_framebuffer_clear4f (COGL_FRAMEBUFFER (offscreen),
COGL_BUFFER_BIT_COLOR, COGL_BUFFER_BIT_COLOR,
red, green, blue, 1.0); red, green, blue, alpha);
for (j = 0; j < G_N_ELEMENTS (formats); j++) for (j = 0; j < G_N_ELEMENTS (formats); j++)
{ {
uint32_t rgb10_readback[4]; uint32_t rgb10_readback[4];
int channels[3]; int alpha_out;
int alpha;
cogl_framebuffer_read_pixels (COGL_FRAMEBUFFER (offscreen), 0, 0, 2, 2, cogl_framebuffer_read_pixels (COGL_FRAMEBUFFER (offscreen), 0, 0, 2, 2,
formats[j], formats[j],
(uint8_t *) &rgb10_readback); (uint8_t *) &rgb10_readback);
switch (formats[j]) for (k = 0; k < 4; k++)
{ {
case COGL_PIXEL_FORMAT_RGBA_1010102: int channels[3];
case COGL_PIXEL_FORMAT_BGRA_1010102:
channels[0] = get_bits (rgb10_readback[0], 31, 22);
channels[1] = get_bits (rgb10_readback[0], 21, 12);
channels[2] = get_bits (rgb10_readback[0], 11, 2);
alpha = get_bits (rgb10_readback[0], 1, 0);
break;
case COGL_PIXEL_FORMAT_XRGB_2101010:
case COGL_PIXEL_FORMAT_ARGB_2101010:
case COGL_PIXEL_FORMAT_XBGR_2101010:
case COGL_PIXEL_FORMAT_ABGR_2101010:
alpha = get_bits (rgb10_readback[0], 31, 30);
channels[0] = get_bits (rgb10_readback[0], 29, 20);
channels[1] = get_bits (rgb10_readback[0], 19, 10);
channels[2] = get_bits (rgb10_readback[0], 9, 0);
break;
default:
g_assert_not_reached ();
}
g_assert_cmpint (alpha, ==, 0x3); switch (formats[j])
{
case COGL_PIXEL_FORMAT_RGBA_1010102_PRE:
case COGL_PIXEL_FORMAT_BGRA_1010102_PRE:
channels[0] = get_bits (rgb10_readback[k], 31, 22);
channels[1] = get_bits (rgb10_readback[k], 21, 12);
channels[2] = get_bits (rgb10_readback[k], 11, 2);
alpha_out = get_bits (rgb10_readback[k], 1, 0);
break;
case COGL_PIXEL_FORMAT_XRGB_2101010:
case COGL_PIXEL_FORMAT_ARGB_2101010_PRE:
case COGL_PIXEL_FORMAT_XBGR_2101010:
case COGL_PIXEL_FORMAT_ABGR_2101010_PRE:
alpha_out = get_bits (rgb10_readback[k], 31, 30);
channels[0] = get_bits (rgb10_readback[k], 29, 20);
channels[1] = get_bits (rgb10_readback[k], 19, 10);
channels[2] = get_bits (rgb10_readback[k], 9, 0);
break;
default:
g_assert_not_reached ();
}
switch (formats[j]) if ((formats[i] & COGL_A_BIT) && (formats[j] & COGL_A_BIT))
{ g_assert_cmpint (alpha_out, ==, rgb10_alpha);
case COGL_PIXEL_FORMAT_RGBA_1010102: else if (!(formats[i] & COGL_A_BIT) && !(formats[j] & COGL_A_BIT))
case COGL_PIXEL_FORMAT_XRGB_2101010: g_assert_cmpint (alpha_out, ==, 0x3);
case COGL_PIXEL_FORMAT_ARGB_2101010:
g_assert_cmpint (channels[0], ==, rgb10_red); switch (formats[j])
g_assert_cmpint (channels[1], ==, rgb10_green); {
g_assert_cmpint (channels[2], ==, rgb10_blue); case COGL_PIXEL_FORMAT_RGBA_1010102_PRE:
break; case COGL_PIXEL_FORMAT_XRGB_2101010:
case COGL_PIXEL_FORMAT_BGRA_1010102: case COGL_PIXEL_FORMAT_ARGB_2101010_PRE:
case COGL_PIXEL_FORMAT_XBGR_2101010: g_assert_cmpint (channels[0], ==, rgb10_red);
case COGL_PIXEL_FORMAT_ABGR_2101010: g_assert_cmpint (channels[1], ==, rgb10_green);
g_assert_cmpint (channels[0], ==, rgb10_blue); g_assert_cmpint (channels[2], ==, rgb10_blue);
g_assert_cmpint (channels[1], ==, rgb10_green); break;
g_assert_cmpint (channels[2], ==, rgb10_red); case COGL_PIXEL_FORMAT_BGRA_1010102_PRE:
break; case COGL_PIXEL_FORMAT_XBGR_2101010:
default: case COGL_PIXEL_FORMAT_ABGR_2101010_PRE:
g_assert_not_reached (); g_assert_cmpint (channels[0], ==, rgb10_blue);
g_assert_cmpint (channels[1], ==, rgb10_green);
g_assert_cmpint (channels[2], ==, rgb10_red);
break;
default:
g_assert_not_reached ();
}
} }
} }
cogl_framebuffer_read_pixels (COGL_FRAMEBUFFER (offscreen), 0, 0, 2, 2, cogl_framebuffer_read_pixels (COGL_FRAMEBUFFER (offscreen), 0, 0, 2, 2,
COGL_PIXEL_FORMAT_RGBA_8888, COGL_PIXEL_FORMAT_RGBX_8888,
(uint8_t *) &rgb8_readback); (uint8_t *) &rgb8_readback);
rgb8_buf = (uint8_t *) &rgb8_readback[0]; for (k = 0; k < 4; k++)
{
uint8_t *rgb8_buf = (uint8_t *) &rgb8_readback[k];
g_assert_cmpint (rgb8_buf[0], ==, rgb10_to_rgb8 (rgb10_red)); g_assert_cmpint (rgb8_buf[0], ==, rgb10_to_rgb8 (rgb10_red));
g_assert_cmpint (rgb8_buf[1], ==, rgb10_to_rgb8 (rgb10_green)); g_assert_cmpint (rgb8_buf[1], ==, rgb10_to_rgb8 (rgb10_green));
g_assert_cmpint (rgb8_buf[2], ==, rgb10_to_rgb8 (rgb10_blue)); g_assert_cmpint (rgb8_buf[2], ==, rgb10_to_rgb8 (rgb10_blue));
g_assert_cmpint (rgb8_buf[3], ==, 0xff);
if (!(formats[i] & COGL_A_BIT))
g_assert_cmpint (rgb8_buf[3], ==, 0xff);
}
g_object_unref (offscreen); g_object_unref (offscreen);
cogl_object_unref (tex); cogl_object_unref (tex);
@ -273,58 +287,133 @@ test_offscreen_texture_formats_paint_rgb10 (void)
const int rgb10_red = 514; const int rgb10_red = 514;
const int rgb10_green = 258; const int rgb10_green = 258;
const int rgb10_blue = 18; const int rgb10_blue = 18;
const int rgb10_alpha = 2;
float red; float red;
float green; float green;
float blue; float blue;
CoglTexture2D *tex_src; float alpha;
CoglOffscreen *offscreen_src; CoglPixelFormat formats[] = {
CoglTexture2D *tex_dst; COGL_PIXEL_FORMAT_XRGB_2101010,
CoglOffscreen *offscreen_dst; COGL_PIXEL_FORMAT_ARGB_2101010_PRE,
CoglPipeline *pipeline; COGL_PIXEL_FORMAT_XBGR_2101010,
uint32_t rgb10_readback[4]; COGL_PIXEL_FORMAT_ABGR_2101010_PRE,
GError *error = NULL; COGL_PIXEL_FORMAT_RGBA_1010102_PRE,
COGL_PIXEL_FORMAT_BGRA_1010102_PRE,
};
int i;
/* The extra fraction is there to avoid rounding inconsistencies in OpenGL /* The extra fraction is there to avoid rounding inconsistencies in OpenGL
* implementations. */ * implementations. */
red = (rgb10_red / (float) (1 << 10)) + 0.00001; red = (rgb10_red / (float) (1 << 10)) + 0.00001;
green = (rgb10_green / (float) (1 << 10)) + 0.00001; green = (rgb10_green / (float) (1 << 10)) + 0.00001;
blue = (rgb10_blue / (float) (1 << 10)) + 0.00001; blue = (rgb10_blue / (float) (1 << 10)) + 0.00001;
alpha = (rgb10_alpha / (float) (1 << 2)) + 0.00001;
/* Make sure that that the color value can't be represented using rgb8. */ /* Make sure that that the color value can't be represented using rgb8. */
g_assert_cmpint (rgb8_to_rgb10 (rgb10_to_rgb8 (rgb10_red)), !=, rgb10_red); g_assert_cmpint (rgb8_to_rgb10 (rgb10_to_rgb8 (rgb10_red)), !=, rgb10_red);
g_assert_cmpint (rgb8_to_rgb10 (rgb10_to_rgb8 (rgb10_green)), !=, rgb10_green); g_assert_cmpint (rgb8_to_rgb10 (rgb10_to_rgb8 (rgb10_green)), !=, rgb10_green);
g_assert_cmpint (rgb8_to_rgb10 (rgb10_to_rgb8 (rgb10_blue)), !=, rgb10_blue); g_assert_cmpint (rgb8_to_rgb10 (rgb10_to_rgb8 (rgb10_blue)), !=, rgb10_blue);
tex_src = cogl_texture_2d_new_with_format (test_ctx, 2, 2, for (i = 0; i < G_N_ELEMENTS (formats); i++)
COGL_PIXEL_FORMAT_RGBA_1010102); {
offscreen_src = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex_src)); CoglTexture2D *tex_src;
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen_src), &error); CoglOffscreen *offscreen_src;
g_assert_no_error (error); GError *error = NULL;
int j;
tex_dst = cogl_texture_2d_new_with_format (test_ctx, 2, 2, tex_src = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[i]);
COGL_PIXEL_FORMAT_ABGR_2101010); offscreen_src = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex_src));
offscreen_dst = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex_dst)); cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen_src), &error);
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen_dst), &error); g_assert_no_error (error);
g_assert_no_error (error);
cogl_framebuffer_clear4f (COGL_FRAMEBUFFER (offscreen_src), for (j = 0; j < G_N_ELEMENTS (formats); j++)
COGL_BUFFER_BIT_COLOR, {
red, green, blue, 1.0); CoglTexture2D *tex_dst;
CoglOffscreen *offscreen_dst;
CoglPipeline *pipeline;
uint32_t rgb10_readback[4];
int k;
pipeline = cogl_pipeline_new (test_ctx); tex_dst = cogl_texture_2d_new_with_format (test_ctx, 2, 2, formats[j]);
cogl_pipeline_set_layer_texture (pipeline, 0, tex_src); offscreen_dst = cogl_offscreen_new_with_texture (COGL_TEXTURE (tex_dst));
cogl_framebuffer_draw_rectangle (COGL_FRAMEBUFFER (offscreen_dst), cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen_dst), &error);
pipeline, g_assert_no_error (error);
-1.0, -1.0, 1.0, 1.0);
cogl_object_unref (pipeline);
cogl_framebuffer_read_pixels (COGL_FRAMEBUFFER (offscreen_dst), 0, 0, 2, 2, cogl_framebuffer_clear4f (COGL_FRAMEBUFFER (offscreen_src),
COGL_PIXEL_FORMAT_ABGR_2101010, COGL_BUFFER_BIT_COLOR,
(uint8_t *) &rgb10_readback); red, green, blue, alpha);
g_assert_cmpint (get_bits (rgb10_readback[0], 31, 30), ==, 0x3);
g_assert_cmpint (get_bits (rgb10_readback[0], 29, 20), ==, rgb10_blue); pipeline = cogl_pipeline_new (test_ctx);
g_assert_cmpint (get_bits (rgb10_readback[0], 19, 10), ==, rgb10_green); cogl_pipeline_set_layer_texture (pipeline, 0, tex_src);
g_assert_cmpint (get_bits (rgb10_readback[0], 9, 0), ==, rgb10_red); cogl_framebuffer_draw_rectangle (COGL_FRAMEBUFFER (offscreen_dst),
pipeline,
-1.0, -1.0, 1.0, 1.0);
cogl_object_unref (pipeline);
cogl_framebuffer_read_pixels (COGL_FRAMEBUFFER (offscreen_dst),
0, 0, 2, 2, formats[j],
(uint8_t *) &rgb10_readback);
for (k = 0; k < 4; k++)
{
int channels[3];
int alpha_out;
switch (formats[j])
{
case COGL_PIXEL_FORMAT_RGBA_1010102_PRE:
case COGL_PIXEL_FORMAT_BGRA_1010102_PRE:
channels[0] = get_bits (rgb10_readback[k], 31, 22);
channels[1] = get_bits (rgb10_readback[k], 21, 12);
channels[2] = get_bits (rgb10_readback[k], 11, 2);
alpha_out = get_bits (rgb10_readback[k], 1, 0);
break;
case COGL_PIXEL_FORMAT_XRGB_2101010:
case COGL_PIXEL_FORMAT_ARGB_2101010_PRE:
case COGL_PIXEL_FORMAT_XBGR_2101010:
case COGL_PIXEL_FORMAT_ABGR_2101010_PRE:
alpha_out = get_bits (rgb10_readback[k], 31, 30);
channels[0] = get_bits (rgb10_readback[k], 29, 20);
channels[1] = get_bits (rgb10_readback[k], 19, 10);
channels[2] = get_bits (rgb10_readback[k], 9, 0);
break;
default:
g_assert_not_reached ();
}
if ((formats[i] & COGL_A_BIT) && (formats[j] & COGL_A_BIT))
g_assert_cmpint (alpha_out, ==, rgb10_alpha);
else if (!(formats[i] & COGL_A_BIT) && !(formats[j] & COGL_A_BIT))
g_assert_cmpint (alpha_out, ==, 0x3);
switch (formats[j])
{
case COGL_PIXEL_FORMAT_RGBA_1010102_PRE:
case COGL_PIXEL_FORMAT_XRGB_2101010:
case COGL_PIXEL_FORMAT_ARGB_2101010_PRE:
g_assert_cmpint (channels[0], ==, rgb10_red);
g_assert_cmpint (channels[1], ==, rgb10_green);
g_assert_cmpint (channels[2], ==, rgb10_blue);
break;
case COGL_PIXEL_FORMAT_BGRA_1010102_PRE:
case COGL_PIXEL_FORMAT_XBGR_2101010:
case COGL_PIXEL_FORMAT_ABGR_2101010_PRE:
g_assert_cmpint (channels[0], ==, rgb10_blue);
g_assert_cmpint (channels[1], ==, rgb10_green);
g_assert_cmpint (channels[2], ==, rgb10_red);
break;
default:
g_assert_not_reached ();
}
}
g_object_unref (offscreen_dst);
cogl_object_unref (tex_dst);
}
g_object_unref (offscreen_src);
cogl_object_unref (tex_src);
}
} }
static void static void