[Piglit] [PATCH v2 3/3] ARB_copy_image: Test different combinations of texture formats
Jason Ekstrand
jason at jlekstrand.net
Mon Jun 30 10:36:02 PDT 2014
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 | 75 ++++++
tests/spec/arb_copy_image/CMakeLists.gl.txt | 1 +
tests/spec/arb_copy_image/formats.c | 385 ++++++++++++++++++++++++++++
3 files changed, 461 insertions(+)
create mode 100644 tests/spec/arb_copy_image/formats.c
diff --git a/tests/all.py b/tests/all.py
index 8235e6e..4e6598c 100644
--- a/tests/all.py
+++ b/tests/all.py
@@ -3188,6 +3188,81 @@ 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, dst_format in itertools.product(formats, formats):
+ add_concurrent_test(arb_copy_image, 'arb_copy_image-formats {0} {1}'.format(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..1800709
--- /dev/null
+++ b/tests/spec/arb_copy_image/formats.c
@@ -0,0 +1,385 @@
+/*
+ * 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_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),
+
+#ifdef GL_EXT_texture_compression_s3tc
+ FORMAT(GL_COMPRESSED_RGB_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_RGBA_S3TC_DXT3_EXT, GL_RED, GL_BYTE, 16, 4, 4),
+ FORMAT(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RED, GL_BYTE, 16, 4, 4),
+#ifdef GL_EXT_texture_sRGB
+ FORMAT(GL_COMPRESSED_SRGB_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_SRGB_ALPHA_S3TC_DXT3_EXT, GL_RED, GL_BYTE, 16, 4, 4),
+ FORMAT(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RED, GL_BYTE, 16, 4, 4),
+#endif
+#endif
+
+#ifdef GL_EXT_texture_compression_rgtc
+ 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),
+#endif
+
+#ifdef GL_EXT_texture_compression_s3tc
+#endif
+
+#ifdef GL_EXT_texture_compression_rgtc
+ 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),
+#endif
+
+#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
+
+static struct texture_format *
+find_format(const char *str)
+{
+ int i;
+ struct texture_format *format = NULL;
+
+ for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i) {
+ if (strcmp(str, formats[i].name) == 0) {
+ format = &formats[i];
+ break;
+ }
+ }
+
+ assert(format);
+
+ switch (format->internal_format) {
+#ifdef GL_EXT_texture_compression_rgtc
+ case GL_COMPRESSED_RED_RGTC1:
+ case GL_COMPRESSED_SIGNED_RED_RGTC1:
+ case GL_COMPRESSED_RG_RGTC2:
+ case GL_COMPRESSED_SIGNED_RG_RGTC2:
+ piglit_require_extension("GL_EXT_texture_compression_rgtc");
+ break;
+#endif
+
+#ifdef GL_EXT_texture_compression_s3tc
+#ifdef GL_EXT_texture_sRGB
+ case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
+ case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
+ piglit_require_extension("GL_EXT_texture_sRGB");
+#endif
+ case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+ piglit_require_extension("GL_EXT_texture_compression_s3tc");
+ break;
+#endif
+
+#ifdef GL_ARB_texture_compression_bptc
+ case GL_COMPRESSED_RGBA_BPTC_UNORM:
+ case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
+ case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
+ case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
+ piglit_require_extension("GL_ARB_texture_compression_bptc");
+ break;
+#endif
+ }
+
+ return format;
+}
+
+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");
+ piglit_require_extension("GL_EXT_framebuffer_object");
+ piglit_require_extension("GL_EXT_texture_integer");
+
+ 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();
+ }
+
+ /* Creates the expected result image from the source and
+ * destination images. The middle TEX_SIZE/2 x TEX_SIZE/2 pixels
+ * should come from src_data while the rest should come from
+ * dest_data. */
+
+ /* Copy all of dst_data to result */
+ memcpy(result, dst_data, TEX_SIZE * TEX_SIZE * src_format->bytes);
+ /* Copy the center TEX_SIZE/2 x TEX_SIZE/2 pixels froms src_data */
+ for (i = TEX_SIZE / 4; i < (TEX_SIZE / 4) * 3; ++i)
+ 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);
+}
+
+static bool
+check_texture(GLuint texture, const struct texture_format *format,
+ const 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);
+
+ free(tex_data);
+
+ 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;
+}
--
2.0.0
More information about the Piglit
mailing list