<div dir="ltr"> <div class="gmail_extra"> <div class="gmail_quote">On Sat, Jun 28, 2014 at 6:28 AM, Brian Paul <<a href="mailto:brianp@vmware.com" target="_blank">brianp@vmware.com</a>> wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="HOEnZb"><div class="h5">On 06/27/2014 05:31 PM, Jason Ekstrand wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> This tests glCopyTexSubImage on all of the allowed combinations of internal texture formats. Signed-off-by: Jason Ekstrand <<a href="mailto:jason.ekstrand@intel.com" target="_blank">jason.ekstrand@intel.com</a>> --- tests/all.py | 77 +++++++ tests/spec/arb_copy_image/CMakeLists.gl.txt | 1 + tests/spec/arb_copy_image/formats.c | 334 ++++++++++++++++++++++++++++ 3 files changed, 412 insertions(+) create mode 100644 tests/spec/arb_copy_image/formats.c diff --git a/tests/all.py b/tests/all.py index 8235e6e..02fc9d2 100644 --- a/tests/all.py +++ b/tests/all.py @@ -3188,6 +3188,83 @@ add_concurrent_test(arb_copy_image, 'arb_copy_image-targets GL_TEXTURE_3D 32 32 add_concurrent_test(arb_copy_image, 'arb_copy_image-targets GL_TEXTURE_3D 32 32 17 GL_TEXTURE_CUBE_MAP_ARRAY 16 16 18 11 5 2 5 9 7 5 7 11') add_concurrent_test(arb_copy_image, 'arb_copy_image-targets GL_TEXTURE_3D 32 32 17 GL_TEXTURE_3D 32 16 18 11 5 2 5 9 7 14 7 11') +def arb_copy_image_add_format_tests(formats): + for src_format in formats: + for dst_format in formats: + add_concurrent_test(arb_copy_image,'arb_copy_image-formats ' + + src_format + ' ' + dst_format) + +arb_copy_image_add_format_tests([ + 'GL_R8UI', + 'GL_R8I', + 'GL_R8', + 'GL_R8_SNORM', +]) +arb_copy_image_add_format_tests([ + 'GL_RG8UI', + 'GL_RG8I', + 'GL_RG8', + 'GL_RG8_SNORM', + 'GL_R16UI', + 'GL_R16I', + 'GL_R16', + 'GL_R16_SNORM', +]) +arb_copy_image_add_format_tests([ + 'GL_RGB8UI', + 'GL_RGB8I', + 'GL_RGB8', + 'GL_RGB8_SNORM', +]) +arb_copy_image_add_format_tests([ + 'GL_RGBA8UI', + 'GL_RGBA8I', + 'GL_RGBA8', + 'GL_RGBA8_SNORM', + 'GL_RG16UI', + 'GL_RG16I', + 'GL_RG16', + 'GL_RG16_SNORM', + 'GL_R32F', +]) +arb_copy_image_add_format_tests([ + 'GL_RGB16UI', + 'GL_RGB16I', + 'GL_RGB16', + 'GL_RGB16_SNORM', +]) +arb_copy_image_add_format_tests([ + 'GL_RGBA16UI', + 'GL_RGBA16I', + 'GL_RGBA16', + 'GL_RGBA16_SNORM', + 'GL_RG32UI', + 'GL_RG32I', + 'GL_RG32F', + 'GL_COMPRESSED_RGB_S3TC_DXT1_EXT', + 'GL_COMPRESSED_SRGB_S3TC_DXT1_EXT', + 'GL_COMPRESSED_RGBA_S3TC_DXT1_EXT', + 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT', + 'GL_COMPRESSED_RED_RGTC1', + 'GL_COMPRESSED_SIGNED_RED_RGTC1', +]) +arb_copy_image_add_format_tests([ + 'GL_RGB32UI', + 'GL_RGB32I', + 'GL_RGB32F', +]) +arb_copy_image_add_format_tests([ + 'GL_RGBA32UI', + 'GL_RGBA32I', + 'GL_RGBA32F', + 'GL_COMPRESSED_RGBA_S3TC_DXT3_EXT', + 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT', + 'GL_COMPRESSED_RGBA_S3TC_DXT5_EXT', + 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT', + 'GL_COMPRESSED_RG_RGTC2', + 'GL_COMPRESSED_SIGNED_RG_RGTC2', +]) + arb_half_float_vertex = {} spec['ARB_half_float_vertex'] = arb_half_float_vertex add_plain_test(arb_half_float_vertex, 'draw-vertices-half-float') diff --git a/tests/spec/arb_copy_image/CMakeLists.gl.txt b/tests/spec/arb_copy_image/CMakeLists.gl.txt index f0d631a..c8b0406 100644 --- a/tests/spec/arb_copy_image/CMakeLists.gl.txt +++ b/tests/spec/arb_copy_image/CMakeLists.gl.txt @@ -10,5 +10,6 @@ link_libraries ( piglit_add_executable (arb_copy_image-simple simple.c) piglit_add_executable (arb_copy_image-targets targets.c) +piglit_add_executable (arb_copy_image-formats formats.c) # vim: ft=cmake: diff --git a/tests/spec/arb_copy_image/formats.c b/tests/spec/arb_copy_image/formats.c new file mode 100644 index 0000000..fdc4584 --- /dev/null +++ b/tests/spec/arb_copy_image/formats.c @@ -0,0 +1,334 @@ +/* + * Copyright 2014 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. + */ + +/* + * This tests glCopySubImageData on different (possibly compressed) texture + * formats. One texture is created and filled with random data. The + * texture is then copied to a second texture, the texture is downloaded, + * and the data verified. Because glCopySubImageData is supposed to be a + * direct memcpy, the copy is verified to be bit-for-bit copy of the + * original. + */ + +#include "piglit-util-gl-common.h" + +#define TEX_SIZE 32 + +PIGLIT_GL_TEST_CONFIG_BEGIN + + config.supports_gl_compat_version = 13; + + config.window_width = TEX_SIZE * 12; + config.window_height = TEX_SIZE * 4; + config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE; + +PIGLIT_GL_TEST_CONFIG_END + +struct texture_format { + GLenum internal_format; + const char *name; + GLenum format; + GLenum data_type; + GLuint bytes; + GLuint block_width; + GLuint block_height; +}; + +#define FORMAT(IF, F, D, B, W, H) { IF, #IF, F, D, B, W, H } + +struct texture_format formats[] = { + FORMAT(GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, 1, 1, 1), + FORMAT(GL_R8I, GL_RED_INTEGER, GL_BYTE, 1, 1, 1), + FORMAT(GL_R8, GL_RED, GL_UNSIGNED_BYTE, 1, 1, 1), + FORMAT(GL_R8_SNORM, GL_RED, GL_BYTE, 1, 1, 1), + + FORMAT(GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE, 2, 1, 1), + FORMAT(GL_RG8I, GL_RG_INTEGER, GL_BYTE, 2, 1, 1), + FORMAT(GL_RG8, GL_RG, GL_UNSIGNED_BYTE, 2, 1, 1), + FORMAT(GL_RG8_SNORM, GL_RG, GL_BYTE, 2, 1, 1), + FORMAT(GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT, 2, 1, 1), + FORMAT(GL_R16I, GL_RED_INTEGER, GL_SHORT, 2, 1, 1), + FORMAT(GL_R16, GL_RED, GL_UNSIGNED_SHORT, 2, 1, 1), + FORMAT(GL_R16_SNORM, GL_RED, GL_SHORT, 2, 1, 1), + + FORMAT(GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE, 3, 1, 1), + FORMAT(GL_RGB8I, GL_RGB_INTEGER, GL_BYTE, 3, 1, 1), + FORMAT(GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE, 3, 1, 1), + FORMAT(GL_RGB8_SNORM, GL_RGB, GL_BYTE, 3, 1, 1), + + FORMAT(GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, 4, 1, 1), + FORMAT(GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, 4, 1, 1), + FORMAT(GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, 4, 1, 1), + FORMAT(GL_RGBA8_SNORM, GL_RGBA, GL_BYTE, 4, 1, 1), + FORMAT(GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT, 4, 1, 1), + FORMAT(GL_RG16I, GL_RG_INTEGER, GL_SHORT, 4, 1, 1), + FORMAT(GL_RG16, GL_RG, GL_UNSIGNED_SHORT, 4, 1, 1), + FORMAT(GL_RG16_SNORM, GL_RG, GL_SHORT, 4, 1, 1), + FORMAT(GL_R32F, GL_RED, GL_FLOAT, 4, 1, 1), + + FORMAT(GL_RGB16UI, GL_RGB_INTEGER, GL_UNSIGNED_SHORT, 6, 1, 1), + FORMAT(GL_RGB16I, GL_RGB_INTEGER, GL_SHORT, 6, 1, 1), + FORMAT(GL_RGB16, GL_RGB, GL_UNSIGNED_SHORT, 6, 1, 1), + FORMAT(GL_RGB16_SNORM, GL_RGB, GL_SHORT, 6, 1, 1), + + FORMAT(GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, 8, 1, 1), + FORMAT(GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT, 8, 1, 1), + FORMAT(GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT, 8, 1, 1), + FORMAT(GL_RGBA16_SNORM, GL_RGBA, GL_SHORT, 8, 1, 1), + FORMAT(GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, 8, 1, 1), + FORMAT(GL_RG32I, GL_RG_INTEGER, GL_INT, 8, 1, 1), + FORMAT(GL_RG32F, GL_RG, GL_FLOAT, 8, 1, 1), + + FORMAT(GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RED, GL_BYTE, 8, 4, 4), + FORMAT(GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, GL_RED, GL_BYTE, 8, 4, 4), + FORMAT(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_RED, GL_BYTE, 8, 4, 4), + FORMAT(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL_RED, GL_BYTE, 8, 4, 4), + FORMAT(GL_COMPRESSED_RED_RGTC1, GL_RED, GL_BYTE, 8, 4, 4), + FORMAT(GL_COMPRESSED_SIGNED_RED_RGTC1, GL_RED, GL_BYTE, 8, 4, 4), + + FORMAT(GL_RGB32UI, GL_RGB_INTEGER, GL_UNSIGNED_INT, 12, 1, 1), + FORMAT(GL_RGB32I, GL_RGB_INTEGER, GL_INT, 12, 1, 1), + FORMAT(GL_RGB32F, GL_RGB, GL_FLOAT, 12, 1, 1), + + FORMAT(GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, 16, 1, 1), + FORMAT(GL_RGBA32I, GL_RGBA_INTEGER, GL_INT, 16, 1, 1), + FORMAT(GL_RGBA32F, GL_RGBA, GL_FLOAT, 16, 1, 1), + + FORMAT(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RED, GL_BYTE, 16, 4, 4), + FORMAT(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_RED, GL_BYTE, 16, 4, 4), + FORMAT(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RED, GL_BYTE, 16, 4, 4), + FORMAT(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RED, GL_BYTE, 16, 4, 4), + FORMAT(GL_COMPRESSED_RG_RGTC2, GL_RED, GL_BYTE, 16, 4, 4), + FORMAT(GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RED, GL_BYTE, 16, 4, 4), + +#ifdef GL_COMPRESSED_RGBA_BPTC_UNORM + FORMAT(GL_COMPRESSED_RGBA_BPTC_UNORM, GL_RGBA, GL_BYTE, 16, 4, 4), + FORMAT(GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, GL_RGB, GL_BYTE, 16, 4, 4), + FORMAT(GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, GL_RGB, GL_BYTE, 16, 4, 4), + FORMAT(GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, GL_RGB, GL_BYTE, 16, 4, 4), +#endif +}; + +#undef FORMAT + +struct texture_format * +find_format(const char *str) +{ + int i; + + for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i) + if (strcmp(str, formats[i].name) == 0) + return &formats[i]; + + return NULL; +} + +struct texture_format *src_format, *dst_format; +unsigned char *src_data, *dst_data, *result; + +void +piglit_init(int argc, char **argv) +{ + int i, seed; + + if (sscanf(argv[1], "--seed=%d", &seed) > 0) { + srand(seed); + --argc; + ++argv; + } else { + srand(0); + } + + if (argc < 2) { + printf("usage: [--seed=seed] arb_copy_image-formats src_format dst_format"); + exit(1); + } + + piglit_require_extension("GL_ARB_copy_image"); + + src_format = find_format(argv[1]); + assert(src_format != NULL); + + dst_format = find_format(argv[2]); + assert(dst_format != NULL); + + assert(dst_format->bytes == src_format->bytes); + + src_data = malloc(TEX_SIZE * TEX_SIZE * src_format->bytes); + dst_data = malloc(TEX_SIZE * TEX_SIZE * dst_format->bytes); + result = malloc(TEX_SIZE * TEX_SIZE * dst_format->bytes); + + if (src_format->data_type == GL_FLOAT || + dst_format->data_type == GL_FLOAT) { + /* If it's a floating-point type, let's avoid using invalid + * floating-point values. That might throw things off */ + + for (i = 0; i < TEX_SIZE * TEX_SIZE * src_format->bytes / sizeof(float); ++i) + ((float *)src_data)[i] = rand() / (float)RAND_MAX; + + for (i = 0; i < TEX_SIZE * TEX_SIZE * src_format->bytes / sizeof(float); ++i) + ((float *)dst_data)[i] = rand() / (float)RAND_MAX; + } else { + for (i = 0; i < TEX_SIZE * TEX_SIZE * src_format->bytes; ++i) + src_data[i] = rand(); + + for (i = 0; i < TEX_SIZE * TEX_SIZE * src_format->bytes; ++i) + dst_data[i] = rand(); + } + </blockquote> </div></div> Some comments about what's being done here would help.<div class=""> </div></blockquote><div> </div><div>Done. Also made it more clear in general. </div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> <div class=""> <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> + memcpy(result, + dst_data, + (TEX_SIZE / 4) * TEX_SIZE * src_format->bytes); + for (i = TEX_SIZE / 4; i < (TEX_SIZE / 4) * 3; ++i) { + memcpy(result + (i * TEX_SIZE) * src_format->bytes, + dst_data + (i * TEX_SIZE) * src_format->bytes, + (TEX_SIZE / 4) * src_format->bytes); + + memcpy(result + (i * TEX_SIZE + TEX_SIZE / 4) * src_format->bytes, + src_data + (i * TEX_SIZE + TEX_SIZE / 4) * src_format->bytes, + (TEX_SIZE / 2) * src_format->bytes); + + memcpy(result + (i * TEX_SIZE + (TEX_SIZE / 4) * 3) * src_format->bytes, + dst_data + (i * TEX_SIZE + (TEX_SIZE / 4) * 3) * src_format->bytes, + (TEX_SIZE / 4) * src_format->bytes); + } + memcpy(result + ((TEX_SIZE / 4) * 3) * TEX_SIZE * src_format->bytes, + dst_data + ((TEX_SIZE / 4) * 3) * TEX_SIZE * src_format->bytes, + (TEX_SIZE / 4) * TEX_SIZE * src_format->bytes); +} + +bool +check_texture(GLuint texture, struct texture_format *format, </blockquote> </div> const struct texture_format ?<div><div class="h5"> </div></div></blockquote><div> </div><div>Yup. I made the data parameter const as well. </div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> <div><div class="h5"> <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> + unsigned char *data) +{ + int i, j, k; + bool pass = true; + unsigned char *tex_data; + float passrate; + + tex_data = malloc(TEX_SIZE * TEX_SIZE * format->bytes); + + glBindTexture(GL_TEXTURE_2D, texture); + if (format->block_width != 1 || format->block_height != 1) { + /* Compressed */ + glGetCompressedTexImage(GL_TEXTURE_2D, 0, tex_data); + } else { + glGetTexImage(GL_TEXTURE_2D, 0, format->format, + format->data_type, tex_data); + } + + passrate = 0; + for (j = 0; j < TEX_SIZE; ++j) { + for (i = 0; i < TEX_SIZE; ++i) { + if (memcmp(tex_data + ((j * TEX_SIZE) + i) * format->bytes, + data + ((j * TEX_SIZE) + i) * format->bytes, + format->bytes) == 0) { + passrate += 1; + } else { + fprintf(stdout, "texel mismatch at (%d, %d); expected 0x", + i, j); + for (k = format->bytes - 1; k >= 0; --k) + fprintf(stdout, "%02x", data[((j * TEX_SIZE) + i) * format->bytes + k]); + + fprintf(stdout, ", received 0x"); + for (k = format->bytes - 1; k >= 0; --k) + fprintf(stdout, "%02x", tex_data[((j * TEX_SIZE) + i) * format->bytes + k]); + fprintf(stdout, ".\n"); + + pass = false; + } + } + } + passrate /= TEX_SIZE * TEX_SIZE; + printf("%0.1f%% of pixels match\n", passrate * 100); + </blockquote> </div></div> free(tex_data);<div><div class="h5"> </div></div></blockquote><div> </div><div>Thanks, fixed. </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div> <div class="h5"> <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> + return pass; +} + +enum piglit_result +piglit_display(void) +{ + bool pass = true; + GLuint texture[2]; + GLuint src_width, src_height, dst_width, dst_height; + + glEnable(GL_TEXTURE_2D); + + glGenTextures(2, texture); + + src_width = TEX_SIZE * src_format->block_width; + src_height = TEX_SIZE * src_format->block_height; + + glBindTexture(GL_TEXTURE_2D, texture[0]); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + if (src_format->block_width != 1 || src_format->block_height != 1) { + /* Compressed */ + glCompressedTexImage2D(GL_TEXTURE_2D, 0, + src_format->internal_format, + src_width, src_height, 0, + TEX_SIZE * TEX_SIZE * src_format->bytes, + src_data); + } else { + glTexImage2D(GL_TEXTURE_2D, 0, src_format->internal_format, + src_width, src_height, 0, src_format->format, + src_format->data_type, src_data); + } + pass &= piglit_check_gl_error(GL_NO_ERROR); + pass &= check_texture(texture[0], src_format, src_data); + + dst_width = TEX_SIZE * dst_format->block_width; + dst_height = TEX_SIZE * dst_format->block_height; + + glBindTexture(GL_TEXTURE_2D, texture[1]); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + if (dst_format->block_width != 1 || dst_format->block_height != 1) { + /* Compressed */ + glCompressedTexImage2D(GL_TEXTURE_2D, 0, + dst_format->internal_format, + dst_width, dst_height, 0, + TEX_SIZE * TEX_SIZE * dst_format->bytes, + dst_data); + } else { + glTexImage2D(GL_TEXTURE_2D, 0, dst_format->internal_format, + dst_width, dst_height, 0, dst_format->format, + dst_format->data_type, dst_data); + } + pass &= piglit_check_gl_error(GL_NO_ERROR); + pass &= check_texture(texture[1], dst_format, dst_data); + + glCopyImageSubData(texture[0], GL_TEXTURE_2D, 0, + src_width / 4, src_height / 4, 0, + texture[1], GL_TEXTURE_2D, 0, + dst_width / 4, dst_height / 4, 0, + src_width / 2, src_height / 2, 1); + pass &= piglit_check_gl_error(GL_NO_ERROR); + pass &= check_texture(texture[1], dst_format, result); + + glDeleteTextures(2, texture); + + glDisable(GL_TEXTURE_2D); + + return pass ? PIGLIT_PASS : PIGLIT_FAIL; +} </blockquote> </div></div> Same comments about extension/version requirements and static functions. Looks pretty good otherwise! </blockquote><div> </div><div>Thanks for the review. </div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> -Brian _______________________________________________ Piglit mailing list <a href="mailto:Piglit@lists.freedesktop.org" target="_blank">Piglit@lists.freedesktop.org</a> <a href="http://lists.freedesktop.org/mailman/listinfo/piglit" target="_blank">http://lists.freedesktop.org/mailman/listinfo/piglit</a> </blockquote></div> </div></div>