[Piglit] [PATCH 3/3] ARB_copy_image: Test different combinations of texture formats

Mon Jun 30 08:29:30 PDT 2014

On Friday, June 27, 2014 04:31:54 PM Jason Ekstrand wrote:
> This tests glCopyTexSubImage on all of the allowed combinations of internal
> texture formats.
> 
> Signed-off-by: Jason Ekstrand <jason.ekstrand at intel.com>
> ---
>  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)

a couple of things:
1) you're missing a space after the comma in add_concurrent_test
2) using str.format() is almost always more readable than concat
3) itertools is your friend

for src, dst, in itertools.product(formats, repeat=2):
	add_concurrent_test(
		arb_copy_image,
         'arb_copy_image-formats {0} {1}'.format(src, dst))

> +
> +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();
> +	}
> +
> +	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,
> +	      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);
> +
> +	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;
> +}
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 473 bytes
Desc: This is a digitally signed message part.
URL: <http://lists.freedesktop.org/archives/piglit/attachments/20140630/8ed26ec6/attachment-0001.sig>